Update app.py

app.py

@@ -27,16 +27,6 @@ def home():
 @app.route('/groq', methods=['POST'])
 def proxy_to_groq():
     """Main proxy endpoint - keeps /groq URL but uses iFlow API internally"""
-    return proxy_to_iflow_internal()
-
-@app.route('/iflow', methods=['POST'])
-@app.route('/chat/completions', methods=['POST'])
-def proxy_to_iflow():
-    """Alternative endpoints for iFlow API"""
-    return proxy_to_iflow_internal()
-
-def proxy_to_iflow_internal():
-    """Internal function that handles the iFlow API proxy logic"""
     try:
         # Validate proxy authentication from header
         auth_header = request.headers.get('X-API-Key') or request.headers.get('Authorization')
@@ -232,24 +222,35 @@ def proxy_to_iflow_internal():
             iflow_response = response.json()
             logger.info(f"iFlow response received successfully")
             
-            # For /groq endpoint compatibility, return plain text
-            if request.path == '/groq':
-                # Extract content from iFlow's response
-                if 'choices' in iflow_response and len(iflow_response['choices']) > 0:
-                    choice = iflow_response['choices'][0]
-                    if 'message' in choice:
-                        content = choice['message'].get('content', '')
-                        
-                        if not content:
-                            logger.warning("Empty content in iFlow response")
-                            content = "No response content"
-                        
-                        # Return plain text for /groq endpoint
-                        logger.info("Successfully returning response to app via /groq")
-                        return content, 200, {'Content-Type': 'text/plain'}
+            # Extract content from iFlow's response
+            if 'choices' in iflow_response and len(iflow_response['choices']) > 0:
+                choice = iflow_response['choices'][0]
+                if 'message' in choice:
+                    content = choice['message'].get('content', '')
+                    
+                    if not content:
+                        logger.warning("Empty content in iFlow response")
+                        content = "No response content"
+                    
+                    # Return plain text for /groq endpoint (original format)
+                    logger.info("Successfully returning response to app via /groq")
+                    return content, 200, {'Content-Type': 'text/plain'}
+                else:
+                    logger.error("No message in iFlow response choice")
+                    return jsonify({
+                        'error': {
+                            'message': 'Invalid response format from iFlow API',
+                            'type': 'api_error'
+                        }
+                    }), 500
             else:
-                # For /iflow and /chat/completions endpoints, return JSON
-                return jsonify(iflow_response), 200
+                logger.error("No choices in iFlow response")
+                return jsonify({
+                    'error': {
+                        'message': 'Invalid response format from iFlow API',
+                        'type': 'api_error'
+                    }
+                }), 500
         
     except requests.exceptions.Timeout:
         logger.error("iFlow API request timeout")
@@ -284,6 +285,172 @@ def proxy_to_iflow_internal():
             }
         }), 500
 
+@app.route('/iflow', methods=['POST'])
+@app.route('/chat/completions', methods=['POST'])
+def proxy_to_iflow():
+    """Alternative endpoints for iFlow API (returns JSON format)"""
+    try:
+        # Validate proxy authentication from header
+        auth_header = request.headers.get('X-API-Key') or request.headers.get('Authorization')
+        if auth_header:
+            # Check if it's Bearer token format
+            if auth_header.startswith('Bearer '):
+                auth_key = auth_header.replace('Bearer ', '')
+            else:
+                auth_key = auth_header
+            
+            if auth_key != PROXY_AUTH_KEY:
+                logger.warning("Unauthorized request with invalid API key")
+                return jsonify({
+                    'error': {
+                        'message': 'Invalid authentication credentials',
+                        'type': 'invalid_request_error',
+                        'code': 'invalid_api_key'
+                    }
+                }), 401
+        else:
+            logger.warning("No authentication header provided")
+            return jsonify({
+                'error': {
+                    'message': 'You must provide an API key',
+                    'type': 'invalid_request_error',
+                    'code': 'missing_api_key'
+                }
+            }), 401
+        
+        # Get the Gemini format payload from app
+        gemini_payload = request.get_json()
+        if not gemini_payload:
+            logger.error("No JSON payload received")
+            return jsonify({
+                'error': {
+                    'message': 'No JSON payload received',
+                    'type': 'invalid_request_error'
+                }
+            }), 400
+        
+        # Check for streaming request
+        stream = gemini_payload.get('stream', False)
+        
+        # Transform Gemini format to iFlow (OpenAI-compatible) format
+        iflow_payload = {
+            'model': gemini_payload.get('model', DEFAULT_MODEL),
+            'messages': [],
+            'stream': stream
+        }
+        
+        # Copy common parameters if present
+        common_params = ['temperature', 'max_tokens', 'top_p', 'frequency_penalty', 
+                        'presence_penalty', 'stop', 'seed', 'response_format']
+        
+        for param in common_params:
+            if param in gemini_payload:
+                iflow_payload[param] = gemini_payload[param]
+        
+        # Convert messages from Gemini parts format to OpenAI content format
+        messages = gemini_payload.get('messages', [])
+        if not messages:
+            logger.error("No messages in payload")
+            return jsonify({
+                'error': {
+                    'message': 'No messages in payload',
+                    'type': 'invalid_request_error'
+                }
+            }), 400
+        
+        for msg in messages:
+            # Extract text from parts array
+            parts = msg.get('parts', [])
+            
+            # Handle both Gemini format (parts array) and OpenAI format (content string)
+            if parts:
+                # Gemini format: parts array with text
+                content_parts = []
+                for part in parts:
+                    text = part.get('text', '')
+                    if text:
+                        content_parts.append(text)
+                
+                if not content_parts:
+                    logger.warning(f"Message with role '{msg.get('role')}' has no text content")
+                    continue
+                
+                content = '\n'.join(content_parts)
+            else:
+                # OpenAI format: direct content field
+                content = msg.get('content', '')
+                if not content:
+                    logger.warning(f"Message with role '{msg.get('role')}' has no content")
+                    continue
+            
+            # Map Gemini roles to OpenAI roles
+            role = msg.get('role')
+            if role == 'model':
+                role = 'assistant'  # OpenAI uses 'assistant', not 'model'
+            
+            # Handle function calls if present (for OpenAI-compatible format)
+            message_dict = {
+                'role': role,
+                'content': content
+            }
+            
+            # Copy any additional fields that might be present
+            additional_fields = ['name', 'function_call', 'tool_calls', 'tool_call_id']
+            for field in additional_fields:
+                if field in msg:
+                    message_dict[field] = msg[field]
+            
+            iflow_payload['messages'].append(message_dict)
+        
+        if not iflow_payload['messages']:
+            logger.error("No valid messages after transformation")
+            return jsonify({
+                'error': {
+                    'message': 'No valid messages in payload',
+                    'type': 'invalid_request_error'
+                }
+            }), 400
+        
+        # Call iFlow API
+        headers = {
+            'Authorization': f'Bearer {IFLOW_API_KEY}',
+            'Content-Type': 'application/json',
+            'User-Agent': 'iFlow-Proxy/1.0'
+        }
+        
+        response = requests.post(
+            IFLOW_API_URL, 
+            json=iflow_payload, 
+            headers=headers, 
+            timeout=60
+        )
+        
+        if response.status_code != 200:
+            error_text = response.text[:500]
+            logger.error(f"iFlow API error: {response.status_code} - {error_text}")
+            try:
+                error_json = response.json()
+                return jsonify(error_json), response.status_code
+            except:
+                return jsonify({
+                    'error': {
+                        'message': f'iFlow API error: {response.status_code}',
+                        'type': 'api_error'
+                    }
+                }), response.status_code
+        
+        # Return the iFlow response directly (OpenAI-compatible JSON)
+        return jsonify(response.json()), 200
+        
+    except Exception as e:
+        logger.error(f"Error in iflow endpoint: {e}")
+        return jsonify({
+            'error': {
+                'message': f'Internal server error: {str(e)}',
+                'type': 'server_error'
+            }
+        }), 500
+
 @app.route('/v1/models', methods=['GET'])
 def list_models():
     """List available models (OpenAI-compatible endpoint)"""
@@ -421,6 +588,8 @@ def health_check():
                 timeout=15
             )
             health_status["iflow_api_accessible"] = test_response.status_code == 200
+            if test_response.status_code == 200:
+                health_status["iflow_api_test"] = "Connection successful"
         except Exception as e:
             health_status["iflow_api_accessible"] = False
             health_status["iflow_api_error"] = str(e)[:100]