added better logging

src/auth.py

@@ -2,6 +2,7 @@ import os
 import json
 import base64
 import time
+import logging
 from datetime import datetime
 from fastapi import Request, HTTPException, Depends
 from fastapi.security import HTTPBasic
@@ -195,7 +196,7 @@ def get_credentials():
         prompt="consent",
         include_granted_scopes='true'
     )
-    print(f"\nPlease open this URL in your browser to log in:\n{auth_url}\n")
+    logging.info(f"Please open this URL in your browser to log in: {auth_url}")
     
     server = HTTPServer(("", 8080), _OAuthCallbackHandler)
     server.handle_request()
@@ -220,10 +221,10 @@ def get_credentials():
         credentials = flow.credentials
         credentials_from_env = False  # Mark as file-based credentials
         save_credentials(credentials)
-        print("Authentication successful! Credentials saved.")
+        logging.info("Authentication successful! Credentials saved.")
         return credentials
     except Exception as e:
-        print(f"Authentication failed: {e}")
+        logging.error(f"Authentication failed: {e}")
         return None
     finally:
         oauthlib.oauth2.rfc6749.parameters.validate_token_parameters = original_validate

src/google_api_client.py

@@ -115,6 +115,9 @@ def _handle_streaming_response(resp) -> StreamingResponse:
                                     response_line = f"data: {response_json}\n\n"
                                     yield response_line
                                     await asyncio.sleep(0)
+                                else:
+                                    obj_json = json.dumps(obj, separators=(',', ':'))
+                                    yield f"data: {obj_json}\n\n"
                             except json.JSONDecodeError:
                                 continue
                 

src/main.py

@@ -1,9 +1,16 @@
+import logging
 from fastapi import FastAPI, Request, Response
 from fastapi.middleware.cors import CORSMiddleware
 from .gemini_routes import router as gemini_router
 from .openai_routes import router as openai_router
 from .auth import get_credentials, get_user_project_id, onboard_user
 
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+)
+
 app = FastAPI()
 
 # Add CORS middleware for preflight requests
@@ -18,22 +25,24 @@ app.add_middleware(
 @app.on_event("startup")
 async def startup_event():
     try:
+        logging.info("Starting Gemini proxy server...")
         creds = get_credentials()
         if creds:
             try:
                 proj_id = get_user_project_id(creds)
                 if proj_id:
                     onboard_user(creds, proj_id)
-                print("Gemini proxy server started")
-                print("Authentication required - Password: see .env file")
+                    logging.info(f"Successfully onboarded with project ID: {proj_id}")
+                logging.info("Gemini proxy server started successfully")
+                logging.info("Authentication required - Password: see .env file")
             except Exception as e:
-                print(f"Setup failed: {str(e)}")
-                print("Server started but may not function properly until setup issues are resolved.")
+                logging.error(f"Setup failed: {str(e)}")
+                logging.warning("Server started but may not function properly until setup issues are resolved.")
         else:
-            print("Could not obtain credentials. Please authenticate and restart the server.")
+            logging.error("Could not obtain credentials. Please authenticate and restart the server.")
     except Exception as e:
-        print(f"Startup error: {str(e)}")
-        print("Server may not function properly.")
+        logging.error(f"Startup error: {str(e)}")
+        logging.warning("Server may not function properly.")
 
 @app.options("/{full_path:path}")
 async def handle_preflight(request: Request, full_path: str):

src/openai_routes.py

@@ -6,6 +6,7 @@ and delegate to the Google API client.
 import json
 import uuid
 import asyncio
+import logging
 from fastapi import APIRouter, Request, Response, Depends
 from fastapi.responses import StreamingResponse
 
@@ -29,55 +30,92 @@ async def openai_chat_completions(
 ):
     """
     OpenAI-compatible chat completions endpoint.
-    Transforms OpenAI requests to Gemini format, sends to Google API, 
+    Transforms OpenAI requests to Gemini format, sends to Google API,
     and transforms responses back to OpenAI format.
     """
     
-    # Transform OpenAI request to Gemini format
-    gemini_request_data = openai_request_to_gemini(request)
-    
-    # Build the payload for Google API
-    gemini_payload = build_gemini_payload_from_openai(gemini_request_data)
+    try:
+        logging.info(f"OpenAI chat completion request: model={request.model}, stream={request.stream}")
+        
+        # Transform OpenAI request to Gemini format
+        gemini_request_data = openai_request_to_gemini(request)
+        
+        # Build the payload for Google API
+        gemini_payload = build_gemini_payload_from_openai(gemini_request_data)
+        
+    except Exception as e:
+        logging.error(f"Error processing OpenAI request: {str(e)}")
+        return Response(
+            content=json.dumps({
+                "error": {
+                    "message": f"Request processing failed: {str(e)}",
+                    "type": "invalid_request_error"
+                }
+            }),
+            status_code=400,
+            media_type="application/json"
+        )
     
     if request.stream:
         # Handle streaming response
         async def openai_stream_generator():
-            response = send_gemini_request(gemini_payload, is_streaming=True)
-            
-            if isinstance(response, StreamingResponse):
-                response_id = "chatcmpl-" + str(uuid.uuid4())
+            try:
+                response = send_gemini_request(gemini_payload, is_streaming=True)
                 
-                async for chunk in response.body_iterator:
-                    if isinstance(chunk, bytes):
-                        chunk = chunk.decode('utf-8')
+                if isinstance(response, StreamingResponse):
+                    response_id = "chatcmpl-" + str(uuid.uuid4())
+                    logging.info(f"Starting streaming response: {response_id}")
                     
-                    if chunk.startswith('data: '):
-                        try:
-                            # Parse the Gemini streaming chunk
-                            chunk_data = chunk[6:]  # Remove 'data: ' prefix
-                            gemini_chunk = json.loads(chunk_data)
-                            
-                            # Transform to OpenAI format
-                            openai_chunk = gemini_stream_chunk_to_openai(
-                                gemini_chunk, 
-                                request.model, 
-                                response_id
-                            )
-                            
-                            # Send as OpenAI streaming format
-                            yield f"data: {json.dumps(openai_chunk)}\n\n"
-                            await asyncio.sleep(0)
-                            
-                        except (json.JSONDecodeError, KeyError, UnicodeDecodeError) as e:
-                            continue
-                
-                # Send the final [DONE] marker
-                yield "data: [DONE]\n\n"
-            else:
-                # Error case - forward the error response
+                    async for chunk in response.body_iterator:
+                        if isinstance(chunk, bytes):
+                            chunk = chunk.decode('utf-8')
+                        
+                        if chunk.startswith('data: '):
+                            try:
+                                # Parse the Gemini streaming chunk
+                                chunk_data = chunk[6:]  # Remove 'data: ' prefix
+                                gemini_chunk = json.loads(chunk_data)
+                                
+                                # Transform to OpenAI format
+                                openai_chunk = gemini_stream_chunk_to_openai(
+                                    gemini_chunk,
+                                    request.model,
+                                    response_id
+                                )
+                                
+                                # Send as OpenAI streaming format
+                                yield f"data: {json.dumps(openai_chunk)}\n\n"
+                                await asyncio.sleep(0)
+                                
+                            except (json.JSONDecodeError, KeyError, UnicodeDecodeError) as e:
+                                logging.warning(f"Failed to parse streaming chunk: {str(e)}")
+                                continue
+                    
+                    # Send the final [DONE] marker
+                    yield "data: [DONE]\n\n"
+                    logging.info(f"Completed streaming response: {response_id}")
+                else:
+                    # Error case - log and forward the error response
+                    error_msg = "Streaming request failed"
+                    if hasattr(response, 'status_code'):
+                        error_msg += f" (status: {response.status_code})"
+                    if hasattr(response, 'body'):
+                        error_msg += f" (body: {response.body})"
+                    
+                    logging.error(error_msg)
+                    error_data = {
+                        "error": {
+                            "message": error_msg,
+                            "type": "api_error"
+                        }
+                    }
+                    yield f"data: {json.dumps(error_data)}\n\n"
+                    yield "data: [DONE]\n\n"
+            except Exception as e:
+                logging.error(f"Streaming error: {str(e)}")
                 error_data = {
                     "error": {
-                        "message": "Streaming request failed",
+                        "message": f"Streaming failed: {str(e)}",
                         "type": "api_error"
                     }
                 }
@@ -91,24 +129,40 @@ async def openai_chat_completions(
     
     else:
         # Handle non-streaming response
-        response = send_gemini_request(gemini_payload, is_streaming=False)
-        
-        if isinstance(response, Response) and response.status_code != 200:
-            # Forward error responses as-is
-            return response
-        
         try:
-            # Parse Gemini response and transform to OpenAI format
-            gemini_response = json.loads(response.body)
-            openai_response = gemini_response_to_openai(gemini_response, request.model)
+            response = send_gemini_request(gemini_payload, is_streaming=False)
             
-            return openai_response
+            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
             
-        except (json.JSONDecodeError, AttributeError) as e:
+            try:
+                # Parse Gemini response and transform to OpenAI format
+                gemini_response = json.loads(response.body)
+                openai_response = gemini_response_to_openai(gemini_response, request.model)
+                
+                logging.info(f"Successfully processed non-streaming response for model: {request.model}")
+                return openai_response
+                
+            except (json.JSONDecodeError, AttributeError) as e:
+                logging.error(f"Failed to parse Gemini response: {str(e)}")
+                return Response(
+                    content=json.dumps({
+                        "error": {
+                            "message": f"Failed to process response: {str(e)}",
+                            "type": "api_error"
+                        }
+                    }),
+                    status_code=500,
+                    media_type="application/json"
+                )
+        except Exception as e:
+            logging.error(f"Non-streaming request failed: {str(e)}")
             return Response(
                 content=json.dumps({
                     "error": {
-                        "message": "Failed to process response",
+                        "message": f"Request failed: {str(e)}",
                         "type": "api_error"
                     }
                 }),
@@ -124,41 +178,58 @@ async def openai_list_models(username: str = Depends(authenticate_user)):
     Returns available models in OpenAI format.
     """
     
-    # Convert our Gemini models to OpenAI format
-    from .config import SUPPORTED_MODELS
-    
-    openai_models = []
-    for model in SUPPORTED_MODELS:
-        # Remove "models/" prefix for OpenAI compatibility
-        model_id = model["name"].replace("models/", "")
-        openai_models.append({
-            "id": model_id,
-            "object": "model",
-            "created": 1677610602,  # Static timestamp
-            "owned_by": "google",
-            "permission": [
-                {
-                    "id": "modelperm-" + model_id.replace("/", "-"),
-                    "object": "model_permission",
-                    "created": 1677610602,
-                    "allow_create_engine": False,
-                    "allow_sampling": True,
-                    "allow_logprobs": False,
-                    "allow_search_indices": False,
-                    "allow_view": True,
-                    "allow_fine_tuning": False,
-                    "organization": "*",
-                    "group": None,
-                    "is_blocking": False
+    try:
+        logging.info("OpenAI models list requested")
+        
+        # Convert our Gemini models to OpenAI format
+        from .config import SUPPORTED_MODELS
+        
+        openai_models = []
+        for model in SUPPORTED_MODELS:
+            # Remove "models/" prefix for OpenAI compatibility
+            model_id = model["name"].replace("models/", "")
+            openai_models.append({
+                "id": model_id,
+                "object": "model",
+                "created": 1677610602,  # Static timestamp
+                "owned_by": "google",
+                "permission": [
+                    {
+                        "id": "modelperm-" + model_id.replace("/", "-"),
+                        "object": "model_permission",
+                        "created": 1677610602,
+                        "allow_create_engine": False,
+                        "allow_sampling": True,
+                        "allow_logprobs": False,
+                        "allow_search_indices": False,
+                        "allow_view": True,
+                        "allow_fine_tuning": False,
+                        "organization": "*",
+                        "group": None,
+                        "is_blocking": False
+                    }
+                ],
+                "root": model_id,
+                "parent": None
+            })
+        
+        logging.info(f"Returning {len(openai_models)} models")
+        return {
+            "object": "list",
+            "data": openai_models
+        }
+        
+    except Exception as e:
+        logging.error(f"Failed to list models: {str(e)}")
+        return Response(
+            content=json.dumps({
+                "error": {
+                    "message": f"Failed to list models: {str(e)}",
+                    "type": "api_error"
                 }
-            ],
-            "root": model_id,
-            "parent": None
-        })
-    
-    return {
-        "object": "list",
-        "data": openai_models
-    }
+            }),
+            status_code=500,
+            media_type="application/json"
+        )