ccproxy-api 0.1.5__py3-none-any.whl → 0.1.6__py3-none-any.whl

ccproxy/services/proxy_service.py

@@ -13,9 +13,11 @@ import httpx
 import structlog
 from fastapi import HTTPException, Request
 from fastapi.responses import StreamingResponse
+from starlette.responses import Response
 from typing_extensions import TypedDict
 
 from ccproxy.config.settings import Settings
+from ccproxy.core.codex_transformers import CodexRequestTransformer
 from ccproxy.core.http import BaseProxyClient
 from ccproxy.core.http_transformers import (
     HTTPRequestTransformer,
@@ -107,6 +109,7 @@ class ProxyService:
         # Create concrete transformers
         self.request_transformer = HTTPRequestTransformer()
         self.response_transformer = HTTPResponseTransformer()
+        self.codex_transformer = CodexRequestTransformer()
 
         # Create OpenAI adapter for stream transformation
         from ccproxy.adapters.openai.adapter import OpenAIAdapter
@@ -414,6 +417,384 @@ class ProxyService:
                 ctx.add_metadata(error=e)
                 raise
 
+    async def handle_codex_request(
+        self,
+        method: str,
+        path: str,
+        session_id: str,
+        access_token: str,
+        request: Request,
+        settings: Settings,
+    ) -> StreamingResponse | Response:
+        """Handle OpenAI Codex proxy request with request/response capture.
+
+        Args:
+            method: HTTP method
+            path: Request path (e.g., "/responses" or "/{session_id}/responses")
+            session_id: Resolved session ID
+            access_token: OpenAI access token
+            request: FastAPI request object
+            settings: Application settings
+
+        Returns:
+            StreamingResponse or regular Response
+        """
+        try:
+            # Read request body - check if already stored by middleware
+            if hasattr(request.state, "body"):
+                body = request.state.body
+            else:
+                body = await request.body()
+
+            # Parse request data to capture the instructions field and other metadata
+            request_data = None
+            try:
+                request_data = json.loads(body.decode("utf-8")) if body else {}
+            except (json.JSONDecodeError, UnicodeDecodeError) as e:
+                request_data = {}
+                logger.warning(
+                    "codex_json_decode_failed",
+                    error=str(e),
+                    body_preview=body[:100].decode("utf-8", errors="replace")
+                    if body
+                    else None,
+                    body_length=len(body) if body else 0,
+                )
+
+            # Parse request to extract account_id from token if available
+            import jwt
+
+            account_id = "unknown"
+            try:
+                decoded = jwt.decode(access_token, options={"verify_signature": False})
+                account_id = decoded.get(
+                    "org_id", decoded.get("sub", decoded.get("account_id", "unknown"))
+                )
+            except Exception:
+                pass
+
+            # Get Codex detection data from app state
+            codex_detection_data = None
+            if self.app_state and hasattr(self.app_state, "codex_detection_data"):
+                codex_detection_data = self.app_state.codex_detection_data
+
+            # Use CodexRequestTransformer to build request
+            original_headers = dict(request.headers)
+            transformed_request = await self.codex_transformer.transform_codex_request(
+                method=method,
+                path=path,
+                headers=original_headers,
+                body=body,
+                access_token=access_token,
+                session_id=session_id,
+                account_id=account_id,
+                codex_detection_data=codex_detection_data,
+                target_base_url=settings.codex.base_url,
+            )
+
+            target_url = transformed_request["url"]
+            headers = transformed_request["headers"]
+            transformed_body = transformed_request["body"] or body
+
+            # Parse transformed body for logging
+            transformed_request_data = request_data
+            if transformed_body and transformed_body != body:
+                try:
+                    transformed_request_data = json.loads(
+                        transformed_body.decode("utf-8")
+                    )
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    transformed_request_data = request_data
+
+            # Generate request ID for logging
+            from uuid import uuid4
+
+            request_id = f"codex_{uuid4().hex[:8]}"
+
+            # Log Codex request (including instructions field and headers)
+            await self._log_codex_request(
+                request_id=request_id,
+                method=method,
+                url=target_url,
+                headers=headers,
+                body_data=transformed_request_data,
+                session_id=session_id,
+            )
+
+            # Check if user explicitly requested streaming (from original request)
+            user_requested_streaming = self.codex_transformer._is_streaming_request(
+                body
+            )
+
+            # Forward request to ChatGPT backend
+            if user_requested_streaming:
+                # Handle streaming request with proper context management
+                # First, collect the response to check for errors
+                collected_chunks = []
+                chunk_count = 0
+                total_bytes = 0
+                response_status_code = 200
+                response_headers = {}
+
+                async def stream_codex_response() -> AsyncGenerator[bytes, None]:
+                    nonlocal \
+                        collected_chunks, \
+                        chunk_count, \
+                        total_bytes, \
+                        response_status_code, \
+                        response_headers
+
+                    logger.debug(
+                        "proxy_service_streaming_started",
+                        request_id=request_id,
+                        session_id=session_id,
+                    )
+
+                    async with (
+                        httpx.AsyncClient(timeout=240.0) as client,
+                        client.stream(
+                            method=method,
+                            url=target_url,
+                            headers=headers,
+                            content=transformed_body,
+                        ) as response,
+                    ):
+                        # Capture response info for error checking
+                        response_status_code = response.status_code
+                        response_headers = dict(response.headers)
+
+                        # Log response headers for streaming
+                        await self._log_codex_response_headers(
+                            request_id=request_id,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            stream_type="codex_sse",
+                        )
+
+                        # Check if upstream actually returned streaming
+                        content_type = response.headers.get("content-type", "")
+                        is_streaming = "text/event-stream" in content_type
+
+                        if not is_streaming:
+                            logger.warning(
+                                "codex_expected_streaming_but_got_regular",
+                                content_type=content_type,
+                                status_code=response.status_code,
+                            )
+
+                        async for chunk in response.aiter_bytes():
+                            chunk_count += 1
+                            chunk_size = len(chunk)
+                            total_bytes += chunk_size
+                            collected_chunks.append(chunk)
+
+                            logger.debug(
+                                "proxy_service_streaming_chunk",
+                                request_id=request_id,
+                                chunk_number=chunk_count,
+                                chunk_size=chunk_size,
+                                total_bytes=total_bytes,
+                            )
+
+                            yield chunk
+
+                    logger.debug(
+                        "proxy_service_streaming_complete",
+                        request_id=request_id,
+                        total_chunks=chunk_count,
+                        total_bytes=total_bytes,
+                    )
+
+                    # Log the complete stream data after streaming finishes
+                    await self._log_codex_streaming_complete(
+                        request_id=request_id,
+                        chunks=collected_chunks,
+                    )
+
+                # Execute the stream generator to collect the response
+                generator_chunks = []
+                async for chunk in stream_codex_response():
+                    generator_chunks.append(chunk)
+
+                # Now check if this should be an error response
+                content_type = response_headers.get("content-type", "")
+                if (
+                    response_status_code >= 400
+                    and "text/event-stream" not in content_type
+                ):
+                    # Return error as regular Response with proper status code
+                    error_content = b"".join(collected_chunks)
+                    logger.warning(
+                        "codex_returning_error_as_regular_response",
+                        status_code=response_status_code,
+                        content_type=content_type,
+                        content_preview=error_content[:200].decode(
+                            "utf-8", errors="replace"
+                        ),
+                    )
+                    return Response(
+                        content=error_content,
+                        status_code=response_status_code,
+                        headers=response_headers,
+                    )
+
+                # Return normal streaming response
+                async def replay_stream() -> AsyncGenerator[bytes, None]:
+                    for chunk in generator_chunks:
+                        yield chunk
+
+                # Forward upstream headers but filter out incompatible ones for streaming
+                streaming_headers = dict(response_headers)
+                # Remove headers that conflict with streaming responses
+                streaming_headers.pop("content-length", None)
+                streaming_headers.pop("content-encoding", None)
+                streaming_headers.pop("date", None)
+                # Set streaming-specific headers
+                streaming_headers.update(
+                    {
+                        "content-type": "text/event-stream",
+                        "cache-control": "no-cache",
+                        "connection": "keep-alive",
+                    }
+                )
+
+                return StreamingResponse(
+                    replay_stream(),
+                    media_type="text/event-stream",
+                    headers=streaming_headers,
+                )
+            else:
+                # Handle non-streaming request
+                async with httpx.AsyncClient(timeout=240.0) as client:
+                    response = await client.request(
+                        method=method,
+                        url=target_url,
+                        headers=headers,
+                        content=transformed_body,
+                    )
+
+                    # Check if upstream response is streaming (shouldn't happen)
+                    content_type = response.headers.get("content-type", "")
+                    transfer_encoding = response.headers.get("transfer-encoding", "")
+                    upstream_is_streaming = "text/event-stream" in content_type or (
+                        transfer_encoding == "chunked" and content_type == ""
+                    )
+
+                    logger.debug(
+                        "codex_response_non_streaming",
+                        content_type=content_type,
+                        user_requested_streaming=user_requested_streaming,
+                        upstream_is_streaming=upstream_is_streaming,
+                        transfer_encoding=transfer_encoding,
+                    )
+
+                    if upstream_is_streaming:
+                        # Upstream is streaming but user didn't request streaming
+                        # Collect all streaming data and return as JSON
+                        logger.debug(
+                            "converting_upstream_stream_to_json", request_id=request_id
+                        )
+
+                        collected_chunks = []
+                        async for chunk in response.aiter_bytes():
+                            collected_chunks.append(chunk)
+
+                        # Combine all chunks
+                        full_content = b"".join(collected_chunks)
+
+                        # Try to parse the streaming data and extract the final response
+                        try:
+                            # Parse SSE data to extract JSON response
+                            content_str = full_content.decode("utf-8")
+                            lines = content_str.strip().split("\n")
+
+                            # Look for the last data line with JSON content
+                            final_json = None
+                            for line in reversed(lines):
+                                if line.startswith("data: ") and not line.endswith(
+                                    "[DONE]"
+                                ):
+                                    try:
+                                        json_str = line[6:]  # Remove "data: " prefix
+                                        final_json = json.loads(json_str)
+                                        break
+                                    except json.JSONDecodeError:
+                                        continue
+
+                            if final_json:
+                                response_content = json.dumps(final_json).encode(
+                                    "utf-8"
+                                )
+                            else:
+                                # Fallback: return the raw content
+                                response_content = full_content
+
+                        except (UnicodeDecodeError, json.JSONDecodeError):
+                            # Fallback: return raw content
+                            response_content = full_content
+
+                        # Log the complete response
+                        try:
+                            response_data = json.loads(response_content.decode("utf-8"))
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            response_data = {
+                                "raw_content": response_content.decode(
+                                    "utf-8", errors="replace"
+                                )
+                            }
+
+                        await self._log_codex_response(
+                            request_id=request_id,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            body_data=response_data,
+                        )
+
+                        # Return as JSON response
+                        return Response(
+                            content=response_content,
+                            status_code=response.status_code,
+                            headers={
+                                "content-type": "application/json",
+                                "content-length": str(len(response_content)),
+                            },
+                            media_type="application/json",
+                        )
+                    else:
+                        # For regular non-streaming responses
+                        response_data = None
+                        try:
+                            response_data = (
+                                json.loads(response.content.decode("utf-8"))
+                                if response.content
+                                else {}
+                            )
+                        except (json.JSONDecodeError, UnicodeDecodeError):
+                            response_data = {
+                                "raw_content": response.content.decode(
+                                    "utf-8", errors="replace"
+                                )
+                            }
+
+                        await self._log_codex_response(
+                            request_id=request_id,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            body_data=response_data,
+                        )
+
+                        # Return regular response
+                        return Response(
+                            content=response.content,
+                            status_code=response.status_code,
+                            headers=dict(response.headers),
+                            media_type=response.headers.get("content-type"),
+                        )
+
+        except Exception as e:
+            logger.error("Codex request failed", error=str(e), session_id=session_id)
+            raise
+
     async def _get_access_token(self) -> str:
         """Get access token for upstream authentication.
 
@@ -584,6 +965,155 @@ class ProxyService:
             timestamp=timestamp,
         )
 
+    async def _log_codex_request(
+        self,
+        request_id: str,
+        method: str,
+        url: str,
+        headers: dict[str, str],
+        body_data: dict[str, Any] | None,
+        session_id: str,
+    ) -> None:
+        """Log outgoing Codex request preserving instructions field exactly."""
+        if not self._verbose_api:
+            return
+
+        # Log to console with redacted headers
+        logger.info(
+            "verbose_codex_request",
+            request_id=request_id,
+            method=method,
+            url=url,
+            headers=self._redact_headers(headers),
+            session_id=session_id,
+            instructions_preview=(
+                body_data.get("instructions", "")[:100] + "..."
+                if body_data and body_data.get("instructions")
+                else None
+            ),
+        )
+
+        # Save complete request to file (without redaction)
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_request",
+            data={
+                "method": method,
+                "url": url,
+                "headers": dict(headers),
+                "body": body_data,
+                "session_id": session_id,
+            },
+            timestamp=timestamp,
+        )
+
+    async def _log_codex_response(
+        self,
+        request_id: str,
+        status_code: int,
+        headers: dict[str, str],
+        body_data: dict[str, Any] | None,
+    ) -> None:
+        """Log complete non-streaming Codex response."""
+        if not self._verbose_api:
+            return
+
+        # Log to console with redacted headers
+        logger.info(
+            "verbose_codex_response",
+            request_id=request_id,
+            status_code=status_code,
+            headers=self._redact_headers(headers),
+            response_type="non_streaming",
+        )
+
+        # Save complete response to file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_response",
+            data={
+                "status_code": status_code,
+                "headers": dict(headers),
+                "body": body_data,
+            },
+            timestamp=timestamp,
+        )
+
+    async def _log_codex_response_headers(
+        self,
+        request_id: str,
+        status_code: int,
+        headers: dict[str, str],
+        stream_type: str,
+    ) -> None:
+        """Log streaming Codex response headers."""
+        if not self._verbose_api:
+            return
+
+        # Log to console with redacted headers
+        logger.info(
+            "verbose_codex_response_headers",
+            request_id=request_id,
+            status_code=status_code,
+            headers=self._redact_headers(headers),
+            stream_type=stream_type,
+        )
+
+        # Save response headers to file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_response_headers",
+            data={
+                "status_code": status_code,
+                "headers": dict(headers),
+                "stream_type": stream_type,
+            },
+            timestamp=timestamp,
+        )
+
+    async def _log_codex_streaming_complete(
+        self,
+        request_id: str,
+        chunks: list[bytes],
+    ) -> None:
+        """Log complete streaming data after stream finishes."""
+        if not self._verbose_api:
+            return
+
+        # Combine chunks and decode for analysis
+        complete_data = b"".join(chunks)
+        try:
+            decoded_data = complete_data.decode("utf-8", errors="replace")
+        except Exception:
+            decoded_data = f"<binary data of length {len(complete_data)}>"
+
+        # Log to console with preview
+        logger.info(
+            "verbose_codex_streaming_complete",
+            request_id=request_id,
+            total_bytes=len(complete_data),
+            chunk_count=len(chunks),
+            data_preview=decoded_data[:200] + "..."
+            if len(decoded_data) > 200
+            else decoded_data,
+        )
+
+        # Save complete streaming data to file
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        await write_request_log(
+            request_id=request_id,
+            log_type="codex_streaming_complete",
+            data={
+                "total_bytes": len(complete_data),
+                "chunk_count": len(chunks),
+                "complete_data": decoded_data,
+            },
+            timestamp=timestamp,
+        )
+
     def _should_stream_response(self, headers: dict[str, str]) -> bool:
         """Check if response should be streamed based on request headers.
 

ccproxy/utils/model_mapping.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 # Combined mapping: OpenAI models → Claude models AND Claude aliases → canonical Claude models
 MODEL_MAPPING: dict[str, str] = {
+    "gpt-5": "claude-sonnet-4-20250514",
     # OpenAI GPT-4 models → Claude 3.5 Sonnet (most comparable)
     "gpt-4": "claude-3-5-sonnet-20241022",
     "gpt-4-turbo": "claude-3-5-sonnet-20241022",
@@ -80,11 +81,12 @@ def map_model_to_claude(model_name: str) -> str:
         return "claude-3-7-sonnet-20250219"
     elif model_name.startswith("gpt-3.5"):
         return "claude-3-5-haiku-latest"
-    elif model_name.startswith("o1"):
-        return "claude-sonnet-4-20250514"
-    elif model_name.startswith("o3"):
-        return "claude-opus-4-20250514"
-    elif model_name.startswith("gpt"):
+    elif (
+        model_name.startswith("o1")
+        or model_name.startswith("gpt-5")
+        or model_name.startswith("o3")
+        or model_name.startswith("gpt")
+    ):
         return "claude-sonnet-4-20250514"
 
     # If it's already a Claude model, pass through unchanged

ccproxy/utils/startup_helpers.py

@@ -23,6 +23,7 @@ from ccproxy.scheduler.errors import SchedulerError
 from ccproxy.scheduler.manager import start_scheduler, stop_scheduler
 from ccproxy.services.claude_detection_service import ClaudeDetectionService
 from ccproxy.services.claude_sdk_service import ClaudeSDKService
+from ccproxy.services.codex_detection_service import CodexDetectionService
 from ccproxy.services.credentials.manager import CredentialsManager
 
 
@@ -126,6 +127,41 @@ async def check_claude_cli_startup(app: FastAPI, settings: Settings) -> None:
         )
 
 
+async def check_codex_cli_startup(app: FastAPI, settings: Settings) -> None:
+    """Check Codex CLI availability at startup.
+
+    Args:
+        app: FastAPI application instance
+        settings: Application settings
+    """
+    try:
+        from ccproxy.api.routes.health import get_codex_cli_info
+
+        codex_info = await get_codex_cli_info()
+
+        if codex_info.status == "available":
+            logger.info(
+                "codex_cli_available",
+                status=codex_info.status,
+                version=codex_info.version,
+                binary_path=codex_info.binary_path,
+            )
+        else:
+            logger.warning(
+                "codex_cli_unavailable",
+                status=codex_info.status,
+                error=codex_info.error,
+                binary_path=codex_info.binary_path,
+                message=f"Codex CLI status: {codex_info.status}",
+            )
+    except Exception as e:
+        logger.error(
+            "codex_cli_check_failed",
+            error=str(e),
+            message="Failed to check Codex CLI status during startup",
+        )
+
+
 async def initialize_log_storage_startup(app: FastAPI, settings: Settings) -> None:
     """Initialize log storage if needed and backend is DuckDB.
 
@@ -261,6 +297,32 @@ async def initialize_claude_detection_startup(app: FastAPI, settings: Settings)
         app.state.claude_detection_service = detection_service
 
 
+async def initialize_codex_detection_startup(app: FastAPI, settings: Settings) -> None:
+    """Initialize Codex detection service.
+
+    Args:
+        app: FastAPI application instance
+        settings: Application settings
+    """
+    try:
+        logger.debug("initializing_codex_detection")
+        detection_service = CodexDetectionService(settings)
+        codex_data = await detection_service.initialize_detection()
+        app.state.codex_detection_data = codex_data
+        app.state.codex_detection_service = detection_service
+        logger.debug(
+            "codex_detection_completed",
+            version=codex_data.codex_version,
+            cached_at=codex_data.cached_at.isoformat(),
+        )
+    except Exception as e:
+        logger.error("codex_detection_startup_failed", error=str(e))
+        # Continue startup with fallback - detection service will provide fallback data
+        detection_service = CodexDetectionService(settings)
+        app.state.codex_detection_data = detection_service._get_fallback_data()
+        app.state.codex_detection_service = detection_service
+
+
 async def initialize_claude_sdk_startup(app: FastAPI, settings: Settings) -> None:
     """Initialize ClaudeSDKService and store in app state.