added error logging and handling

src/gemini_routes.py

@@ -4,6 +4,7 @@ This module provides native Gemini API endpoints that proxy directly to Google's
 without any format transformations.
 """
 import json
+import logging
 from fastapi import APIRouter, Request, Response, Depends
 
 from .auth import authenticate_user
@@ -20,15 +21,31 @@ async def gemini_list_models(request: Request, username: str = Depends(authentic
     Returns available models in Gemini format, matching the official Gemini API.
     """
     
-    models_response = {
-        "models": SUPPORTED_MODELS
-    }
-    
-    return Response(
-        content=json.dumps(models_response), 
-        status_code=200, 
-        media_type="application/json; charset=utf-8"
-    )
+    try:
+        logging.info("Gemini models list requested")
+        
+        models_response = {
+            "models": SUPPORTED_MODELS
+        }
+        
+        logging.info(f"Returning {len(SUPPORTED_MODELS)} Gemini models")
+        return Response(
+            content=json.dumps(models_response),
+            status_code=200,
+            media_type="application/json; charset=utf-8"
+        )
+    except Exception as e:
+        logging.error(f"Failed to list Gemini models: {str(e)}")
+        return Response(
+            content=json.dumps({
+                "error": {
+                    "message": f"Failed to list models: {str(e)}",
+                    "code": 500
+                }
+            }),
+            status_code=500,
+            media_type="application/json"
+        )
 
 
 @router.api_route("/{full_path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH"])
@@ -44,53 +61,78 @@ async def gemini_proxy(request: Request, full_path: str, username: str = Depends
     - etc.
     """
     
-    # Get the request body
-    post_data = await request.body()
-    
-    # Determine if this is a streaming request
-    is_streaming = "stream" in full_path.lower()
-    
-    # Extract model name from the path
-    # Paths typically look like: v1beta/models/gemini-1.5-pro/generateContent
-    model_name = _extract_model_from_path(full_path)
-    
-    if not model_name:
-        return Response(
-            content=json.dumps({
-                "error": {
-                    "message": f"Could not extract model name from path: {full_path}",
-                    "code": 400
-                }
-            }),
-            status_code=400,
-            media_type="application/json"
-        )
-    
-    # Parse the incoming request
     try:
-        if post_data:
-            incoming_request = json.loads(post_data)
-        else:
-            incoming_request = {}
-    except json.JSONDecodeError:
+        # Get the request body
+        post_data = await request.body()
+        
+        # Determine if this is a streaming request
+        is_streaming = "stream" in full_path.lower()
+        
+        # Extract model name from the path
+        # Paths typically look like: v1beta/models/gemini-1.5-pro/generateContent
+        model_name = _extract_model_from_path(full_path)
+        
+        logging.info(f"Gemini proxy request: path={full_path}, model={model_name}, stream={is_streaming}")
+        
+        if not model_name:
+            logging.error(f"Could not extract model name from path: {full_path}")
+            return Response(
+                content=json.dumps({
+                    "error": {
+                        "message": f"Could not extract model name from path: {full_path}",
+                        "code": 400
+                    }
+                }),
+                status_code=400,
+                media_type="application/json"
+            )
+        
+        # Parse the incoming request
+        try:
+            if post_data:
+                incoming_request = json.loads(post_data)
+            else:
+                incoming_request = {}
+        except json.JSONDecodeError as e:
+            logging.error(f"Invalid JSON in request body: {str(e)}")
+            return Response(
+                content=json.dumps({
+                    "error": {
+                        "message": "Invalid JSON in request body",
+                        "code": 400
+                    }
+                }),
+                status_code=400,
+                media_type="application/json"
+            )
+        
+        # Build the payload for Google API
+        gemini_payload = build_gemini_payload_from_native(incoming_request, model_name)
+        
+        # Send the request to Google API
+        response = send_gemini_request(gemini_payload, is_streaming=is_streaming)
+        
+        # Log the response status
+        if hasattr(response, 'status_code'):
+            if response.status_code != 200:
+                logging.error(f"Gemini API returned error: status={response.status_code}")
+            else:
+                logging.info(f"Successfully processed Gemini request for model: {model_name}")
+        
+        return response
+        
+    except Exception as e:
+        logging.error(f"Gemini proxy error: {str(e)}")
         return Response(
             content=json.dumps({
                 "error": {
-                    "message": "Invalid JSON in request body",
-                    "code": 400
+                    "message": f"Proxy error: {str(e)}",
+                    "code": 500
                 }
             }),
-            status_code=400,
+            status_code=500,
             media_type="application/json"
         )
-    
-    # Build the payload for Google API
-    gemini_payload = build_gemini_payload_from_native(incoming_request, model_name)
-    
-    # Send the request to Google API
-    response = send_gemini_request(gemini_payload, is_streaming=is_streaming)
-    
-    return response
 
 
 def _extract_model_from_path(path: str) -> str:

src/google_api_client.py

@@ -3,6 +3,7 @@ Google API Client - Handles all communication with Google's Gemini API.
 This module is used by both OpenAI compatibility layer and native Gemini endpoints.
 """
 import json
+import logging
 import requests
 from fastapi import Response
 from fastapi.responses import StreamingResponse
@@ -80,29 +81,79 @@ def send_gemini_request(payload: dict, is_streaming: bool = False) -> Response:
     final_post_data = json.dumps(final_payload)
 
     # Send the request
-    if is_streaming:
-        resp = requests.post(target_url, data=final_post_data, headers=request_headers, stream=True)
-        return _handle_streaming_response(resp)
-    else:
-        resp = requests.post(target_url, data=final_post_data, headers=request_headers)
-        return _handle_non_streaming_response(resp)
+    try:
+        if is_streaming:
+            resp = requests.post(target_url, data=final_post_data, headers=request_headers, stream=True)
+            return _handle_streaming_response(resp)
+        else:
+            resp = requests.post(target_url, data=final_post_data, headers=request_headers)
+            return _handle_non_streaming_response(resp)
+    except requests.exceptions.RequestException as e:
+        logging.error(f"Request to Google API failed: {str(e)}")
+        return Response(
+            content=json.dumps({"error": {"message": f"Request failed: {str(e)}"}}),
+            status_code=500,
+            media_type="application/json"
+        )
+    except Exception as e:
+        logging.error(f"Unexpected error during Google API request: {str(e)}")
+        return Response(
+            content=json.dumps({"error": {"message": f"Unexpected error: {str(e)}"}}),
+            status_code=500,
+            media_type="application/json"
+        )
 
 
 def _handle_streaming_response(resp) -> StreamingResponse:
     """Handle streaming response from Google API."""
     
+    # Check for HTTP errors before starting to stream
+    if resp.status_code != 200:
+        logging.error(f"Google API returned status {resp.status_code}: {resp.text}")
+        error_message = f"Google API error: {resp.status_code}"
+        try:
+            error_data = resp.json()
+            if "error" in error_data:
+                error_message = error_data["error"].get("message", error_message)
+        except:
+            pass
+        
+        # Return error as a streaming response
+        async def error_generator():
+            error_response = {
+                "error": {
+                    "message": error_message,
+                    "type": "invalid_request_error" if resp.status_code == 404 else "api_error",
+                    "code": resp.status_code
+                }
+            }
+            yield f'data: {json.dumps(error_response)}\n\n'.encode('utf-8')
+        
+        response_headers = {
+            "Content-Type": "text/event-stream",
+            "Content-Disposition": "attachment",
+            "Vary": "Origin, X-Origin, Referer",
+            "X-XSS-Protection": "0",
+            "X-Frame-Options": "SAMEORIGIN",
+            "X-Content-Type-Options": "nosniff",
+            "Server": "ESF"
+        }
+        
+        return StreamingResponse(
+            error_generator(),
+            media_type="text/event-stream",
+            headers=response_headers,
+            status_code=resp.status_code
+        )
+    
     async def stream_generator():
         try:
             with resp:
-                resp.raise_for_status()
-                
-                
                 for chunk in resp.iter_lines():
                     if chunk:
                         if not isinstance(chunk, str):
                             chunk = chunk.decode('utf-8')
                             
-                                                    
                         if chunk.startswith('data: '):
                             chunk = chunk[len('data: '):]
                             
@@ -113,18 +164,34 @@ def _handle_streaming_response(resp) -> StreamingResponse:
                                     response_chunk = obj["response"]
                                     response_json = json.dumps(response_chunk, separators=(',', ':'))
                                     response_line = f"data: {response_json}\n\n"
-                                    yield response_line
+                                    yield response_line.encode('utf-8')
                                     await asyncio.sleep(0)
                                 else:
                                     obj_json = json.dumps(obj, separators=(',', ':'))
-                                    yield f"data: {obj_json}\n\n"
+                                    yield f"data: {obj_json}\n\n".encode('utf-8')
                             except json.JSONDecodeError:
                                 continue
                 
         except requests.exceptions.RequestException as e:
-            yield f'data: {{"error": {{"message": "Upstream request failed: {str(e)}"}}}}\n\n'.encode('utf-8')
+            logging.error(f"Streaming request failed: {str(e)}")
+            error_response = {
+                "error": {
+                    "message": f"Upstream request failed: {str(e)}",
+                    "type": "api_error",
+                    "code": 502
+                }
+            }
+            yield f'data: {json.dumps(error_response)}\n\n'.encode('utf-8')
         except Exception as e:
-            yield f'data: {{"error": {{"message": "An unexpected error occurred: {str(e)}"}}}}\n\n'.encode('utf-8')
+            logging.error(f"Unexpected error during streaming: {str(e)}")
+            error_response = {
+                "error": {
+                    "message": f"An unexpected error occurred: {str(e)}",
+                    "type": "api_error",
+                    "code": 500
+                }
+            }
+            yield f'data: {json.dumps(error_response)}\n\n'.encode('utf-8')
 
     response_headers = {
         "Content-Type": "text/event-stream",
@@ -153,20 +220,45 @@ def _handle_non_streaming_response(resp) -> Response:
             google_api_response = json.loads(google_api_response)
             standard_gemini_response = google_api_response.get("response")
             return Response(
-                content=json.dumps(standard_gemini_response), 
-                status_code=200, 
+                content=json.dumps(standard_gemini_response),
+                status_code=200,
                 media_type="application/json; charset=utf-8"
             )
         except (json.JSONDecodeError, AttributeError) as e:
+            logging.error(f"Failed to parse Google API response: {str(e)}")
             return Response(
-                content=resp.content, 
-                status_code=resp.status_code, 
+                content=resp.content,
+                status_code=resp.status_code,
                 media_type=resp.headers.get("Content-Type")
             )
     else:
+        # Log the error details
+        logging.error(f"Google API returned status {resp.status_code}: {resp.text}")
+        
+        # Try to parse error response and provide meaningful error message
+        try:
+            error_data = resp.json()
+            if "error" in error_data:
+                error_message = error_data["error"].get("message", f"API error: {resp.status_code}")
+                error_response = {
+                    "error": {
+                        "message": error_message,
+                        "type": "invalid_request_error" if resp.status_code == 404 else "api_error",
+                        "code": resp.status_code
+                    }
+                }
+                return Response(
+                    content=json.dumps(error_response),
+                    status_code=resp.status_code,
+                    media_type="application/json"
+                )
+        except (json.JSONDecodeError, KeyError):
+            pass
+        
+        # Fallback to original response if we can't parse the error
         return Response(
-            content=resp.content, 
-            status_code=resp.status_code, 
+            content=resp.content,
+            status_code=resp.status_code,
             media_type=resp.headers.get("Content-Type")
         )
 

src/openai_routes.py

@@ -49,7 +49,8 @@ async def openai_chat_completions(
             content=json.dumps({
                 "error": {
                     "message": f"Request processing failed: {str(e)}",
-                    "type": "invalid_request_error"
+                    "type": "invalid_request_error",
+                    "code": 400
                 }
             }),
             status_code=400,
@@ -76,6 +77,21 @@ async def openai_chat_completions(
                                 chunk_data = chunk[6:]  # Remove 'data: ' prefix
                                 gemini_chunk = json.loads(chunk_data)
                                 
+                                # Check if this is an error chunk
+                                if "error" in gemini_chunk:
+                                    logging.error(f"Error in streaming response: {gemini_chunk['error']}")
+                                    # Transform error to OpenAI format
+                                    error_data = {
+                                        "error": {
+                                            "message": gemini_chunk["error"].get("message", "Unknown error"),
+                                            "type": gemini_chunk["error"].get("type", "api_error"),
+                                            "code": gemini_chunk["error"].get("code")
+                                        }
+                                    }
+                                    yield f"data: {json.dumps(error_data)}\n\n"
+                                    yield "data: [DONE]\n\n"
+                                    return
+                                
                                 # Transform to OpenAI format
                                 openai_chunk = gemini_stream_chunk_to_openai(
                                     gemini_chunk,
@@ -95,18 +111,32 @@ async def openai_chat_completions(
                     yield "data: [DONE]\n\n"
                     logging.info(f"Completed streaming response: {response_id}")
                 else:
-                    # Error case - log and forward the error response
+                    # Error case - handle Response object with error
                     error_msg = "Streaming request failed"
+                    status_code = 500
+                    
                     if hasattr(response, 'status_code'):
-                        error_msg += f" (status: {response.status_code})"
+                        status_code = response.status_code
+                        error_msg += f" (status: {status_code})"
+                    
                     if hasattr(response, 'body'):
-                        error_msg += f" (body: {response.body})"
+                        try:
+                            # Try to parse error response
+                            error_body = response.body
+                            if isinstance(error_body, bytes):
+                                error_body = error_body.decode('utf-8')
+                            error_data = json.loads(error_body)
+                            if "error" in error_data:
+                                error_msg = error_data["error"].get("message", error_msg)
+                        except:
+                            pass
                     
-                    logging.error(error_msg)
+                    logging.error(f"Streaming request failed: {error_msg}")
                     error_data = {
                         "error": {
                             "message": error_msg,
-                            "type": "api_error"
+                            "type": "invalid_request_error" if status_code == 404 else "api_error",
+                            "code": status_code
                         }
                     }
                     yield f"data: {json.dumps(error_data)}\n\n"
@@ -116,7 +146,8 @@ async def openai_chat_completions(
                 error_data = {
                     "error": {
                         "message": f"Streaming failed: {str(e)}",
-                        "type": "api_error"
+                        "type": "api_error",
+                        "code": 500
                     }
                 }
                 yield f"data: {json.dumps(error_data)}\n\n"
@@ -133,9 +164,45 @@ async def openai_chat_completions(
             response = send_gemini_request(gemini_payload, is_streaming=False)
             
             if isinstance(response, Response) and response.status_code != 200:
-                # Log and forward error responses
-                logging.error(f"Gemini API error: status={response.status_code}, body={response.body}")
-                return response
+                # Handle error responses from Google API
+                logging.error(f"Gemini API error: status={response.status_code}")
+                
+                try:
+                    # Try to parse the error response and transform to OpenAI format
+                    error_body = response.body
+                    if isinstance(error_body, bytes):
+                        error_body = error_body.decode('utf-8')
+                    
+                    error_data = json.loads(error_body)
+                    if "error" in error_data:
+                        # Transform Google API error to OpenAI format
+                        openai_error = {
+                            "error": {
+                                "message": error_data["error"].get("message", f"API error: {response.status_code}"),
+                                "type": error_data["error"].get("type", "invalid_request_error" if response.status_code == 404 else "api_error"),
+                                "code": error_data["error"].get("code", response.status_code)
+                            }
+                        }
+                        return Response(
+                            content=json.dumps(openai_error),
+                            status_code=response.status_code,
+                            media_type="application/json"
+                        )
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    pass
+                
+                # Fallback error response
+                return Response(
+                    content=json.dumps({
+                        "error": {
+                            "message": f"API error: {response.status_code}",
+                            "type": "invalid_request_error" if response.status_code == 404 else "api_error",
+                            "code": response.status_code
+                        }
+                    }),
+                    status_code=response.status_code,
+                    media_type="application/json"
+                )
             
             try:
                 # Parse Gemini response and transform to OpenAI format
@@ -151,7 +218,8 @@ async def openai_chat_completions(
                     content=json.dumps({
                         "error": {
                             "message": f"Failed to process response: {str(e)}",
-                            "type": "api_error"
+                            "type": "api_error",
+                            "code": 500
                         }
                     }),
                     status_code=500,
@@ -163,7 +231,8 @@ async def openai_chat_completions(
                 content=json.dumps({
                     "error": {
                         "message": f"Request failed: {str(e)}",
-                        "type": "api_error"
+                        "type": "api_error",
+                        "code": 500
                     }
                 }),
                 status_code=500,
@@ -225,7 +294,8 @@ async def openai_list_models(username: str = Depends(authenticate_user)):
             content=json.dumps({
                 "error": {
                     "message": f"Failed to list models: {str(e)}",
-                    "type": "api_error"
+                    "type": "api_error",
+                    "code": 500
                 }
             }),
             status_code=500,