Update proxy_server.py

proxy_server.py

@@ -12,32 +12,23 @@ from fastapi.responses import StreamingResponse, JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from loguru import logger
 from typing import AsyncGenerator, Set, Optional, Dict, Any, List
-# from urllib.parse import urlparse # Removed: No longer needed for logging
 
 # --- Logging Configuration ---
 logger.remove()
 log_level = os.getenv("LOG_LEVEL", "INFO").upper()
-# Ensure DEBUG level enables detailed logging
 logger.add(sys.stderr, level=log_level, format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>")
 
 # --- Environment Variable Configuration ---
-# Target OpenAI API endpoint (can be OpenAI's official API or another compatible proxy like chat-api)
 OPENAI_API_ENDPOINT = os.getenv("OPENAI_API_ENDPOINT", "https://api.openai.com/v1/chat/completions")
-# API Key for authenticating with the target OpenAI endpoint (if required by the endpoint)
 OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
-# List of valid API keys for this proxy service, comma-separated
-PROXY_API_KEYS_STR = os.getenv("PROXY_API_KEYS", "") # Example: "key1,key2,mysecretkey"
+PROXY_API_KEYS_STR = os.getenv("PROXY_API_KEYS", "")
 VALID_API_KEYS: Set[str] = set(key.strip() for key in PROXY_API_KEYS_STR.split(',') if key.strip())
-# httpx client timeouts
 CONNECT_TIMEOUT = float(os.getenv("CONNECT_TIMEOUT", 5.0))
-# Increased read timeout for potentially long LLM responses
 READ_TIMEOUT = float(os.getenv("READ_TIMEOUT", 180.0))
 WRITE_TIMEOUT = float(os.getenv("WRITE_TIMEOUT", 30.0))
 POOL_TIMEOUT = float(os.getenv("POOL_TIMEOUT", 5.0))
-# httpx client connection pool limits
 MAX_CONNECTIONS = int(os.getenv("MAX_CONNECTIONS", 100))
 MAX_KEEPALIVE = int(os.getenv("MAX_KEEPALIVE", 20))
-# Optional outbound proxy (e.g., http://user:pass@host:port or socks5://host:port)
 HTTP_PROXY = os.getenv("HTTP_PROXY")
 
 # --- Global httpx Client ---
@@ -51,11 +42,10 @@ async def lifespan(app: FastAPI):
     timeout_config = httpx.Timeout(connect=CONNECT_TIMEOUT, read=READ_TIMEOUT, write=WRITE_TIMEOUT, pool=POOL_TIMEOUT)
     proxy_config = {"http://": HTTP_PROXY, "https://": HTTP_PROXY} if HTTP_PROXY else None
 
-    # Completely hide target endpoint info from logs
-    logger.info("Initializing httpx client for upstream requests.") # Generic message
+    logger.info("Initializing httpx client for upstream requests.")
 
     if proxy_config:
-        logger.info(f"Using outbound proxy: {HTTP_PROXY}") # Proxy URL might still be sensitive
+        logger.info(f"Using outbound proxy: {HTTP_PROXY}")
     if not OPENAI_API_KEY:
         logger.warning("OPENAI_API_KEY is not set. Requests to the target endpoint might fail if it requires authentication.")
     if not VALID_API_KEYS:
@@ -65,7 +55,7 @@ async def lifespan(app: FastAPI):
         limits=limits,
         timeout=timeout_config,
         proxies=proxy_config,
-        http2=True, # Enable HTTP/2 if supported by the server
+        http2=True,
         follow_redirects=True
     )
     yield
@@ -83,14 +73,14 @@ app = FastAPI(
 # --- CORS Middleware ---
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"], # Allow all origins, or specify allowed origins
+    allow_origins=["*"],
     allow_credentials=True,
-    allow_methods=["*"], # Allow all methods (GET, POST, etc.)
-    allow_headers=["*"], # Allow all headers
+    allow_methods=["*"],
+    allow_headers=["*"],
 )
 
 # --- API Key Authentication ---
-API_KEY_NAME = "X-API-Key" # Standard header name for API keys
+API_KEY_NAME = "X-API-Key"
 api_key_header = APIKeyHeader(name=API_KEY_NAME, auto_error=False)
 
 async def get_api_key(key: Optional[str] = Security(api_key_header)) -> str:
@@ -110,60 +100,42 @@ async def get_api_key(key: Optional[str] = Security(api_key_header)) -> str:
 
 # --- Format Conversion Logic ---
 
-# --- FIX: Removed client_api_key parameter and the "user" field addition ---
 def claude_request_to_openai_payload(claude_request: Dict[str, Any]) -> Dict[str, Any]:
-    """
-    Converts a Claude API request body to OpenAI API format.
-    """
+    """Converts a Claude API request body to OpenAI API format."""
     messages = []
     system_prompt = claude_request.get("system")
     if system_prompt:
-        # Ensure system prompt content is a string
+        system_content = ""
         if isinstance(system_prompt, list):
-             # Combine text blocks if system prompt is a list (like in Claude's format)
             system_content = "\n".join(block.get("text", "") for block in system_prompt if block.get("type") == "text")
         elif isinstance(system_prompt, str):
             system_content = system_prompt
-        else:
-             system_content = "" # Handle other unexpected types if necessary
         if system_content:
              messages.append({"role": "system", "content": system_content})
 
-
     for msg in claude_request.get("messages", []):
         role = msg.get("role")
         content_parts = []
-        # Claude content is a list of blocks
         if isinstance(msg.get("content"), list):
             for block in msg.get("content", []):
                 if block.get("type") == "text":
                     content_parts.append(block.get("text", ""))
-        elif isinstance(msg.get("content"), str): # Handle simple string content if provided
+        elif isinstance(msg.get("content"), str):
              content_parts.append(msg.get("content"))
-
         if role and content_parts:
-            # Combine multiple text blocks into one message for OpenAI
             messages.append({"role": role, "content": "\n".join(content_parts)})
 
-    # Map parameters (add more mappings as needed)
     openai_payload = {
-        "model": claude_request.get("model", "gpt-3.5-turbo"), # Use model from request or default
+        "model": claude_request.get("model", "gpt-3.5-turbo"),
         "messages": messages,
         "stream": claude_request.get("stream", False),
-        # --- FIX: Removed the "user" field ---
-        # Optional parameters - only include if present in Claude request
         **({ "max_tokens": v } if (v := claude_request.get("max_tokens")) is not None else {}),
         **({ "temperature": v } if (v := claude_request.get("temperature")) is not None else {}),
         **({ "top_p": v } if (v := claude_request.get("top_p")) is not None else {}),
         **({ "stop": v } if (v := claude_request.get("stop_sequences")) is not None else {}),
-        # Add other relevant parameter mappings here (e.g., presence_penalty, frequency_penalty)
     }
-
-    # logger.debug("Converted Claude request to OpenAI payload.") # Keep this simple
     return openai_payload
-# --- End Fix ---
 
-# ... (openai_response_to_claude_response and stream_openai_response_to_claude_events remain the same) ...
 def openai_response_to_claude_response(openai_response: Dict[str, Any], claude_request_id: str) -> Dict[str, Any]:
     """Converts a non-streaming OpenAI response to Claude API format."""
     try:
@@ -171,34 +143,25 @@ def openai_response_to_claude_response(openai_response: Dict[str, Any], claude_r
         message = choice.get("message", {})
         content = message.get("content", "")
         role = message.get("role", "assistant")
-        finish_reason = choice.get("finish_reason", "stop") # Map OpenAI finish reasons
+        finish_reason = choice.get("finish_reason", "stop")
 
-        # Map OpenAI finish reasons to Claude stop reasons
         stop_reason_map = {
-            "stop": "end_turn",
-            "length": "max_tokens",
-            "function_call": "tool_use", # Or handle appropriately if tools are used
-            "content_filter": "stop_sequence", # Approximate mapping
-            "null": "stop_sequence", # Approximate mapping
+            "stop": "end_turn", "length": "max_tokens", "function_call": "tool_use",
+            "content_filter": "stop_sequence", "null": "stop_sequence",
         }
-        claude_stop_reason = stop_reason_map.get(finish_reason, "stop_sequence") # Default if unknown
+        claude_stop_reason = stop_reason_map.get(finish_reason, "stop_sequence")
 
         usage = openai_response.get("usage", {})
         prompt_tokens = usage.get("prompt_tokens", 0)
         completion_tokens = usage.get("completion_tokens", 0)
 
         claude_response = {
-            "id": openai_response.get("id", claude_request_id), # Use OpenAI ID or original request ID
-            "type": "message",
-            "role": role,
-            "content": [{"type": "text", "text": content or ""}], # Ensure content is not None
-            "model": openai_response.get("model", "claude-proxy-model"), # Model used by OpenAI
-            "stop_reason": claude_stop_reason,
-            "stop_sequence": None, # OpenAI doesn't explicitly return the sequence
-            "usage": {
-                "input_tokens": prompt_tokens,
-                "output_tokens": completion_tokens,
-            },
+            "id": openai_response.get("id", claude_request_id),
+            "type": "message", "role": role,
+            "content": [{"type": "text", "text": content or ""}],
+            "model": openai_response.get("model", "claude-proxy-model"),
+            "stop_reason": claude_stop_reason, "stop_sequence": None,
+            "usage": { "input_tokens": prompt_tokens, "output_tokens": completion_tokens },
         }
         logger.debug(f"[{claude_request_id}] Converted non-streaming OpenAI response to Claude format.")
         return claude_response
@@ -208,18 +171,18 @@ def openai_response_to_claude_response(openai_response: Dict[str, Any], claude_r
 
 async def stream_openai_response_to_claude_events(openai_response: httpx.Response, claude_request_id: str, requested_model: str) -> AsyncGenerator[str, None]:
     """Converts an OpenAI SSE stream to Claude API SSE format."""
-    message_id = claude_request_id # Use the original request ID for consistency
-    accumulated_content_len = 0 # Track length instead of full content
+    message_id = claude_request_id
+    accumulated_content_len = 0
     openai_finish_reason = None
-    input_tokens = 0 # Will be updated if usage info is sent
-    output_tokens = 0 # Will be updated if usage info is sent
+    input_tokens = 0 # Try to capture this
+    output_tokens = 0
     last_ping_time = time.time()
 
     logger.debug(f"[{message_id}] Starting Claude SSE stream conversion.")
 
     # 1. Send message_start event
-    yield f"event: message_start\ndata: {json.dumps({'type': 'message_start', 'message': {'id': message_id, 'type': 'message', 'role': 'assistant', 'content': [], 'model': requested_model, 'stop_reason': None, 'stop_sequence': None, 'usage': {'input_tokens': 0, 'output_tokens': 0}}})}\n\n"
-    # 2. Send content_block_start event for the text block
+    yield f"event: message_start\ndata: {json.dumps({'type': 'message_start', 'message': {'id': message_id, 'type': 'message', 'role': 'assistant', 'content': [], 'model': requested_model, 'stop_reason': None, 'stop_sequence': None, 'usage': {'input_tokens': 0, 'output_tokens': 0}}})}\n\n" # Initial usage is 0
+    # 2. Send content_block_start event
     yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': 0, 'content_block': {'type': 'text', 'text': ''}})}\n\n"
     # 3. Send initial ping
     yield f"event: ping\ndata: {json.dumps({'type': 'ping'})}\n\n"
@@ -227,95 +190,113 @@ async def stream_openai_response_to_claude_events(openai_response: httpx.Respons
     try:
         async for line in openai_response.aiter_lines():
             line = line.strip()
-            if not line:
-                continue # Skip empty lines
+            if not line: continue
 
             if line.startswith("data:"):
                 data_str = line[len("data: "):].strip()
                 if data_str == "[DONE]":
                     logger.debug(f"[{message_id}] Received [DONE] marker from OpenAI stream.")
-                    break # End of OpenAI stream
+                    break
 
                 try:
                     data = json.loads(data_str)
                     choices = data.get("choices", [])
-                    if not choices:
-                        continue
+                    if not choices: continue
+
+                    # --- Try to capture input tokens if sent early ---
+                    usage_update = data.get("usage")
+                    if usage_update and usage_update.get("prompt_tokens") is not None and input_tokens == 0:
+                         input_tokens = usage_update.get("prompt_tokens", 0)
+                         logger.debug(f"[{message_id}] Captured input_tokens: {input_tokens}")
+                    # ---
 
                     delta = choices[0].get("delta", {})
                     content_chunk = delta.get("content")
 
-                    # Check for finish reason in the chunk
                     if choices[0].get("finish_reason"):
                         openai_finish_reason = choices[0].get("finish_reason")
                         logger.debug(f"[{message_id}] Received OpenAI finish_reason: {openai_finish_reason}")
 
-                    # Check for usage update (some models send it at the end)
-                    usage_update = data.get("usage")
-                    if usage_update:
-                        input_tokens = usage_update.get("prompt_tokens", input_tokens)
+                    # Update output tokens based on usage update if available
+                    if usage_update and usage_update.get("completion_tokens") is not None:
                         output_tokens = usage_update.get("completion_tokens", output_tokens)
-                        logger.debug(f"[{message_id}] Received usage update: input={input_tokens}, output={output_tokens}")
+                        logger.debug(f"[{message_id}] Received completion_tokens update: {output_tokens}")
+
 
                     if content_chunk:
                         accumulated_content_len += len(content_chunk)
-                        # 4. Send content_block_delta for the text chunk
+                        # Estimate output tokens if not provided by usage update
+                        if not (usage_update and usage_update.get("completion_tokens") is not None):
+                             output_tokens += 1 # Simple increment per chunk as fallback
+
+                        # 4. Send content_block_delta
                         yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': 0, 'delta': {'type': 'text_delta', 'text': content_chunk}})}\n\n"
 
                 except json.JSONDecodeError:
                     logger.warning(f"[{message_id}] Could not decode JSON from stream line: {data_str}")
-                    continue
                 except Exception as e:
                     logger.error(f"[{message_id}] Error processing stream data chunk: {e}")
-                    continue # Skip this chunk
 
-            # Send periodic pings
             current_time = time.time()
-            if current_time - last_ping_time >= 10: # Ping every 10 seconds
+            if current_time - last_ping_time >= 10:
                 yield f"event: ping\ndata: {json.dumps({'type': 'ping'})}\n\n"
                 last_ping_time = current_time
 
     except httpx.ReadTimeout:
         logger.error(f"[{message_id}] Timeout reading from OpenAI stream.")
-        openai_finish_reason = "error_timeout" # Custom reason
+        openai_finish_reason = "error_timeout"
         yield f"event: error\ndata: {json.dumps({'type': 'error', 'error': {'type': 'overloaded_error', 'message': 'Proxy timed out waiting for OpenAI stream'}})}\n\n"
     except Exception as e:
         logger.exception(f"[{message_id}] Unexpected error during stream processing: {e}")
-        openai_finish_reason = "error_exception" # Custom reason
+        openai_finish_reason = "error_exception"
         yield f"event: error\ndata: {json.dumps({'type': 'error', 'error': {'type': 'internal_server_error', 'message': f'Proxy stream processing error: {e}'}})}\n\n"
     finally:
-        # Map OpenAI finish reason to Claude stop reason
         stop_reason_map = {
-            "stop": "end_turn",
-            "length": "max_tokens",
-            "function_call": "tool_use",
-            "content_filter": "stop_sequence",
-            "null": "stop_sequence",
-            "error_timeout": "error", # Custom mapping
-            "error_exception": "error", # Custom mapping
+            "stop": "end_turn", "length": "max_tokens", "function_call": "tool_use",
+            "content_filter": "stop_sequence", "null": "stop_sequence",
+            "error_timeout": "error", "error_exception": "error",
         }
-        claude_stop_reason = stop_reason_map.get(openai_finish_reason, "stop_sequence") # Default
+        claude_stop_reason = stop_reason_map.get(openai_finish_reason, "stop_sequence")
 
         logger.debug(f"[{message_id}] Stream finished. OpenAI finish reason: {openai_finish_reason}, mapped Claude stop reason: {claude_stop_reason}")
 
         # 5. Send content_block_stop
         yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': 0})}\n\n"
 
-        # 6. Send message_delta with final usage and stop reason
+        # 6. Send message_delta with final stop reason ONLY
         final_delta = {
             'type': 'message_delta',
             'delta': {
                 'stop_reason': claude_stop_reason,
-                'stop_sequence': None # OpenAI doesn't provide this
-            },
-            'usage': {
-                'output_tokens': output_tokens if output_tokens > 0 else (accumulated_content_len // 4) # Rough estimate
+                'stop_sequence': None
             }
+            # Removed usage from here
         }
         yield f"event: message_delta\ndata: {json.dumps(final_delta)}\n\n"
 
-        # 7. Send message_stop
-        yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
+        # 7. Send message_stop (including final usage)
+        # --- FIX: Add usage info to the message_stop event ---
+        final_stop_event_data = {
+            'type': 'message_stop',
+            # Claude API v1 examples sometimes show a nested 'message' object here,
+            # but let's try putting usage directly under the event first for simplicity,
+            # similar to how message_start includes a 'message' object.
+            # If this doesn't work, we might need the nested 'message' structure.
+             'amazon-bedrock-invocationMetrics': { # Mimic Bedrock's potential structure for usage
+                 'inputTokenCount': input_tokens,
+                 'outputTokenCount': output_tokens if output_tokens > 0 else (accumulated_content_len // 4), # Use estimate if needed
+                 'invocationLatency': 0, # Placeholder
+                 'firstByteLatency': 0 # Placeholder
+             }
+            # Alternative simpler structure (if the above fails):
+            # 'usage': {
+            #      'input_tokens': input_tokens,
+            #      'output_tokens': output_tokens if output_tokens > 0 else (accumulated_content_len // 4)
+            # }
+        }
+        yield f"event: message_stop\ndata: {json.dumps(final_stop_event_data)}\n\n"
+        # --- End Fix ---
+
         logger.info(f"[{message_id}] Completed sending Claude SSE stream.")
 
 
@@ -323,26 +304,18 @@ def create_error_response(status_code: int, error_type: str, message: str) -> JS
     """Creates a JSONResponse with a Claude-like error structure."""
     return JSONResponse(
         status_code=status_code,
-        content={
-            "type": "error",
-            "error": {
-                "type": error_type,
-                "message": message
-            }
-        }
+        content={"type": "error", "error": {"type": error_type, "message": message}}
     )
 
 # --- Main Proxy Endpoint ---
-# --- FIX: Removed client_api_key parameter from signature as it's not used in payload conversion anymore ---
 @app.post("/v1/messages", dependencies=[Depends(get_api_key)])
 async def proxy_claude_to_openai(request: Request):
-# --- End Fix ---
     """
     Receives a Claude-formatted request, proxies it to OpenAI,
     and returns a Claude-formatted response.
     Requires a valid API key via the X-API-Key header.
     """
-    request_id = f"msg_{uuid.uuid4().hex[:24]}" # Generate a unique ID for logging/tracking
+    request_id = f"msg_{uuid.uuid4().hex[:24]}"
     try:
         claude_request_data = await request.json()
         logger.info(f"[{request_id}] Received request. Stream: {claude_request_data.get('stream', False)}. Model: {claude_request_data.get('model')}")
@@ -350,19 +323,15 @@ async def proxy_claude_to_openai(request: Request):
         logger.error(f"[{request_id}] Invalid JSON received in request body.")
         return create_error_response(400, "invalid_request_error", "Invalid JSON data in request body.")
 
-    # Convert request format
     try:
-        # --- FIX: Call conversion function without client_api_key ---
         openai_payload = claude_request_to_openai_payload(claude_request_data)
-        # --- End Fix ---
     except Exception as e:
         logger.error(f"[{request_id}] Failed to convert Claude request to OpenAI format: {e}")
         return create_error_response(400, "invalid_request_error", f"Failed to process request data: {e}")
 
     is_streaming = openai_payload.get("stream", False)
-    requested_model = openai_payload.get("model", "unknown_model") # For response generation
+    requested_model = openai_payload.get("model", "unknown_model")
 
-    # Prepare headers for the target OpenAI endpoint
     target_headers = { "Content-Type": "application/json" }
     if OPENAI_API_KEY:
         target_headers["Authorization"] = f"Bearer {OPENAI_API_KEY}"
@@ -370,56 +339,35 @@ async def proxy_claude_to_openai(request: Request):
     else:
         logger.debug(f"[{request_id}] No OPENAI_API_KEY configured for upstream request.")
 
-    # Log headers and payload if log level is DEBUG
-    if logger.level("DEBUG").no >= logger.level(log_level).no: # Check if DEBUG is enabled
+    if logger.level("DEBUG").no >= logger.level(log_level).no:
         logged_headers = target_headers.copy()
-        if "Authorization" in logged_headers:
-             logged_headers["Authorization"] = "Bearer [REDACTED]"
+        if "Authorization" in logged_headers: logged_headers["Authorization"] = "Bearer [REDACTED]"
         logger.debug(f"[{request_id}] Sending request to upstream API.")
         logger.debug(f"[{request_id}] Upstream Headers: {json.dumps(logged_headers)}")
         try:
             payload_str = json.dumps(openai_payload, indent=2)
             max_log_len = 1024
-            if len(payload_str) > max_log_len:
-                 logger.debug(f"[{request_id}] Upstream Payload (truncated): {payload_str[:max_log_len]}...")
-            else:
-                 logger.debug(f"[{request_id}] Upstream Payload: {payload_str}")
+            logger.debug(f"[{request_id}] Upstream Payload {'(truncated)' if len(payload_str) > max_log_len else ''}: {payload_str[:max_log_len]}{'...' if len(payload_str) > max_log_len else ''}")
         except Exception as log_e:
             logger.warning(f"[{request_id}] Could not serialize or log upstream payload: {log_e}")
     else:
-         logger.debug(f"[{request_id}] Sending request to upstream API...") # Generic message for INFO level
-
+         logger.debug(f"[{request_id}] Sending request to upstream API...")
 
     try:
-        # Build the request to the target endpoint
-        target_request = client.build_request(
-            method="POST",
-            url=OPENAI_API_ENDPOINT,
-            headers=target_headers, # Use the prepared headers
-            json=openai_payload,
-        )
-
-        # Send the request and handle the response
+        target_request = client.build_request("POST", OPENAI_API_ENDPOINT, headers=target_headers, json=openai_payload)
         response = await client.send(target_request, stream=is_streaming)
+        response.raise_for_status()
 
-        # Check for HTTP errors from the target endpoint *before* processing the body
-        response.raise_for_status() # Raises exception for 4xx/5xx errors
-
-        # Process the response based on streaming or non-streaming
         if is_streaming:
             logger.info(f"[{request_id}] Upstream response is streaming. Starting SSE conversion.")
             return StreamingResponse(
                 stream_openai_response_to_claude_events(response, request_id, requested_model),
                 media_type="text/event-stream",
-                headers={
-                    "X-Content-Type-Options": "nosniff",
-                    "Cache-Control": "no-cache",
-                    "Connection": "keep-alive",
-                }
+                headers={"X-Content-Type-Options": "nosniff", "Cache-Control": "no-cache", "Connection": "keep-alive"}
             )
         else:
             logger.info(f"[{request_id}] Upstream response is non-streaming. Converting.")
-            openai_response_data = response.json() # No await needed
+            openai_response_data = response.json()
             logger.debug(f"[{request_id}] Received non-streaming response from upstream.")
             try:
                 claude_response_data = openai_response_to_claude_response(openai_response_data, request_id)
@@ -431,31 +379,22 @@ async def proxy_claude_to_openai(request: Request):
                  logger.exception(f"[{request_id}] Unexpected error converting non-streaming response: {e}")
                  return create_error_response(500, "internal_server_error", "Unexpected error processing upstream response.")
 
-
-    # --- Error Handling for Target API Request ---
     except httpx.HTTPStatusError as e:
         status_code = e.response.status_code
         error_detail_text = "[Could not decode error response]"
         try:
-            error_detail = e.response.json()
-            error_detail_text = json.dumps(error_detail)
+            error_detail = e.response.json(); error_detail_text = json.dumps(error_detail)
         except json.JSONDecodeError:
-            try:
-                error_detail_text = e.response.text
-            except Exception:
-                 logger.warning(f"[{request_id}] Could not read error response body as text.")
-
+            try: error_detail_text = e.response.text
+            except Exception: logger.warning(f"[{request_id}] Could not read error response body as text.")
         logger.error(f"[{request_id}] HTTP error from target endpoint ({status_code}). Response snippet: {error_detail_text[:200]}...")
-
         if status_code == 400: err_type, msg = "invalid_request_error", f"Upstream API Bad Request ({status_code})."
         elif status_code == 401: err_type, msg = "authentication_error", f"Authentication failed with upstream API ({status_code})."
         elif status_code == 403: err_type, msg = "permission_error", f"Forbidden by upstream API ({status_code})."
         elif status_code == 429: err_type, msg = "rate_limit_error", f"Rate limit exceeded with upstream API ({status_code})."
         elif status_code >= 500: err_type, msg = "api_error", f"Upstream API unavailable or encountered an error ({status_code})."
         else: err_type, msg = "api_error", f"Received unexpected error from upstream API ({status_code})."
-
         return create_error_response(status_code, err_type, msg)
-
     except httpx.TimeoutException:
         logger.error(f"[{request_id}] Request to target endpoint timed out ({READ_TIMEOUT}s).")
         return create_error_response(504, "api_error", "Gateway Timeout: Request to upstream API timed out.")
@@ -479,14 +418,12 @@ if __name__ == "__main__":
         from dotenv import load_dotenv
         load_dotenv()
         logger.info("Loaded environment variables from .env file (if present).")
-        # Reload config vars after loading .env
         PROXY_API_KEYS_STR = os.getenv("PROXY_API_KEYS", "")
         VALID_API_KEYS = set(key.strip() for key in PROXY_API_KEYS_STR.split(',') if key.strip())
         OPENAI_API_ENDPOINT = os.getenv("OPENAI_API_ENDPOINT", "https://api.openai.com/v1/chat/completions")
         OPENAI_API_KEY = os.getenv("OPENAI_API_KEY")
         HTTP_PROXY = os.getenv("HTTP_PROXY")
         log_level = os.getenv("LOG_LEVEL", "INFO").upper()
-        # Reconfigure logger if level changed
         logger.remove()
         logger.add(sys.stderr, level=log_level, format="<green>{time:YYYY-MM-DD HH:mm:ss.SSS}</green> | <level>{level: <8}</level> | <cyan>{name}</cyan>:<cyan>{function}</cyan>:<cyan>{line}</cyan> - <level>{message}</level>")
         logger.info(f"Log level set to: {log_level}")
@@ -497,12 +434,6 @@ if __name__ == "__main__":
     port = int(os.getenv("PORT", 7860))
     host = os.getenv("HOST", "0.0.0.0")
     log_config_level = log_level.lower() if log_level in ["CRITICAL", "ERROR", "WARNING", "INFO", "DEBUG", "TRACE"] else "info"
-
     logger.info(f"Starting Uvicorn server on {host}:{port}")
-    uvicorn.run(
-        "proxy_server:app",
-        host=host,
-        port=port,
-        reload=True,
-        log_level=log_config_level
-    )
+    uvicorn.run("proxy_server:app", host=host, port=port, reload=True, log_level=log_config_level)
+