refactor: improve error handling and streaming response management in Codex endpoints

Enhanced error handling for non-streaming Codex responses by properly
detecting and
returning error responses with correct HTTP status codes instead of
treating them as
streaming responses. Added comprehensive error response parsing to
handle various error
formats (detail, error, message fields) and improved streaming response
collection to
differentiate between actual streaming content and error responses.

Key improvements:
- Added error response detection in both streaming and non-streaming
paths
- Proper status code forwarding for error responses
- Enhanced JSON error parsing with fallback mechanisms
- Improved streaming response buffering and replay functionality
- Better content-type checking to distinguish between streaming and
error responses
- Added comprehensive error logging for debugging purposes

feat: improve Codex streaming response handling with proper header
management

- Capture and forward upstream response headers from Codex API
- Add comprehensive error handling for HTTP 4xx/5xx responses in
streaming mode
- Convert API errors to streaming-compatible JSON format with proper
error structure
- Filter out conflicting headers (content-length, content-encoding,
date) for streaming responses
- Implement header capture pattern in both codex.py and proxy_service.py
- Ensure streaming responses maintain proper SSE format even for error
conditions
- Add debug logging for response headers and error conditions

refactor: simplify Codex adapter imports and consolidate response
handling

- Removed unused CodexAdapter and CodexResponseChoice from
adapters/codex/__init__.py
- Consolidated Codex models to use centralized request/response models
from ccproxy.models
- Simplified response data extraction in response_adapter.py by removing
redundant type checks
- Enhanced codex chat completions route with improved error handling and
streaming logic
- Added proper type hints and error response handling for better
debugging
- Streamlined SSE event processing with clearer reasoning block
detection
- Fixed response format conversion to maintain consistency with OpenAI
Chat Completions API

The changes consolidate Codex-related code organization, improve error
handling robustness, and enhance the streaming response conversion
between Response API format and Chat Completions format. This reduces
code duplication and improves maintainability while ensuring proper
OpenAI API compatibility.

Author: CaddyGlow

ccproxy/adapters/codex/__init__.py

@@ -1,18 +1,11 @@
 """Codex adapter for format conversion."""
 
-from ccproxy.adapters.codex.adapter import CodexAdapter
-from ccproxy.adapters.codex.models import (
-    CodexMessage,
-    CodexRequest,
-    CodexResponse,
-    CodexResponseChoice,
-)
+from ccproxy.models.requests import CodexMessage, CodexRequest
+from ccproxy.models.responses import CodexResponse
 
 
 __all__ = [
-    "CodexAdapter",
     "CodexMessage",
     "CodexRequest",
     "CodexResponse",
-    "CodexResponseChoice",
 ]

ccproxy/adapters/openai/response_adapter.py

@@ -123,37 +123,37 @@ def response_to_chat_completion(
         Returns:
             Chat Completions formatted response
         """
+        # Extract the actual response data
+        response_dict: dict[str, Any]
         if isinstance(response_data, ResponseCompleted):
-            response = response_data.response
-        elif isinstance(response_data, dict):
+            # Convert Pydantic model to dict
+            response_dict = response_data.response.model_dump()
+        else:  # isinstance(response_data, dict)
             if "response" in response_data:
-                response = response_data["response"]
+                response_dict = response_data["response"]
             else:
-                response = response_data
-        else:
-            response = response_data
+                response_dict = response_data
 
         # Extract content from Response API output
         content = ""
-        if isinstance(response, dict):
-            output = response.get("output", [])
-            # Look for message type output (skip reasoning)
-            for output_item in output:
-                if output_item.get("type") == "message":
-                    output_content = output_item.get("content", [])
-                    for content_block in output_content:
-                        if content_block.get("type") in ["output_text", "text"]:
-                            content += content_block.get("text", "")
+        output = response_dict.get("output", [])
+        # Look for message type output (skip reasoning)
+        for output_item in output:
+            if output_item.get("type") == "message":
+                output_content = output_item.get("content", [])
+                for content_block in output_content:
+                    if content_block.get("type") in ["output_text", "text"]:
+                        content += content_block.get("text", "")
 
         # Build Chat Completions response
-        usage_data = response.get("usage") if isinstance(response, dict) else None
+        usage_data = response_dict.get("usage")
         converted_usage = self._convert_usage(usage_data) if usage_data else None
-        
+
         return OpenAIChatCompletionResponse(
-            id=response.get("id", f"resp_{uuid.uuid4().hex}") if isinstance(response, dict) else f"resp_{uuid.uuid4().hex}",
+            id=response_dict.get("id", f"resp_{uuid.uuid4().hex}"),
             object="chat.completion",
-            created=response.get("created_at", int(time.time())) if isinstance(response, dict) else int(time.time()),
-            model=response.get("model", "gpt-5") if isinstance(response, dict) else "gpt-5",
+            created=response_dict.get("created_at", int(time.time())),
+            model=response_dict.get("model", "gpt-5"),
             choices=[
                 OpenAIChoice(
                     index=0,
@@ -164,7 +164,7 @@ def response_to_chat_completion(
                 )
             ],
             usage=converted_usage,
-            system_fingerprint=response.get("safety_identifier") if isinstance(response, dict) else None,
+            system_fingerprint=response_dict.get("safety_identifier"),
         )
 
     async def stream_response_to_chat(
@@ -310,12 +310,12 @@ async def stream_response_to_chat(
                                 {"index": 0, "delta": {}, "finish_reason": "stop"}
                             ],
                         }
-                        
+
                         # Add usage if available
                         converted_usage = self._convert_usage(usage) if usage else None
                         if converted_usage:
                             chunk_data["usage"] = converted_usage.model_dump()
-                            
+
                         yield chunk_data
 
         logger.debug(