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

ccproxy/core/codex_transformers.py

@@ -0,0 +1,389 @@
+"""Codex-specific transformers for request/response transformation."""
+
+import json
+
+import structlog
+from typing_extensions import TypedDict
+
+from ccproxy.core.transformers import RequestTransformer
+from ccproxy.core.types import ProxyRequest, TransformContext
+from ccproxy.models.detection import CodexCacheData
+
+
+logger = structlog.get_logger(__name__)
+
+
+class CodexRequestData(TypedDict):
+    """Typed structure for transformed Codex request data."""
+
+    method: str
+    url: str
+    headers: dict[str, str]
+    body: bytes | None
+
+
+class CodexRequestTransformer(RequestTransformer):
+    """Codex request transformer for header and instructions field injection."""
+
+    def __init__(self) -> None:
+        """Initialize Codex request transformer."""
+        super().__init__()
+
+    async def _transform_request(
+        self, request: ProxyRequest, context: TransformContext | None = None
+    ) -> ProxyRequest:
+        """Transform a proxy request for Codex API.
+
+        Args:
+            request: The structured proxy request to transform
+            context: Optional transformation context
+
+        Returns:
+            The transformed proxy request
+        """
+        # Extract required data from context
+        access_token = ""
+        session_id = ""
+        account_id = ""
+        codex_detection_data = None
+
+        if context:
+            if hasattr(context, "access_token"):
+                access_token = context.access_token
+            elif isinstance(context, dict):
+                access_token = context.get("access_token", "")
+
+            if hasattr(context, "session_id"):
+                session_id = context.session_id
+            elif isinstance(context, dict):
+                session_id = context.get("session_id", "")
+
+            if hasattr(context, "account_id"):
+                account_id = context.account_id
+            elif isinstance(context, dict):
+                account_id = context.get("account_id", "")
+
+            if hasattr(context, "codex_detection_data"):
+                codex_detection_data = context.codex_detection_data
+            elif isinstance(context, dict):
+                codex_detection_data = context.get("codex_detection_data")
+
+        # Transform URL - remove codex prefix and forward to ChatGPT backend
+        transformed_url = self._transform_codex_url(request.url)
+
+        # Convert request body to bytes for header processing
+        body_bytes = None
+        if request.body:
+            if isinstance(request.body, bytes):
+                body_bytes = request.body
+            elif isinstance(request.body, str):
+                body_bytes = request.body.encode("utf-8")
+            elif isinstance(request.body, dict):
+                body_bytes = json.dumps(request.body).encode("utf-8")
+
+        # Transform headers with Codex CLI identity
+        transformed_headers = self.create_codex_headers(
+            request.headers,
+            access_token,
+            session_id,
+            account_id,
+            body_bytes,
+            codex_detection_data,
+        )
+
+        # Transform body to inject instructions
+        transformed_body = request.body
+        if request.body:
+            if isinstance(request.body, bytes):
+                transformed_body = self.transform_codex_body(
+                    request.body, codex_detection_data
+                )
+            else:
+                # Convert to bytes if needed
+                body_bytes = (
+                    json.dumps(request.body).encode("utf-8")
+                    if isinstance(request.body, dict)
+                    else str(request.body).encode("utf-8")
+                )
+                transformed_body = self.transform_codex_body(
+                    body_bytes, codex_detection_data
+                )
+
+        # Create new transformed request
+        return ProxyRequest(
+            method=request.method,
+            url=transformed_url,
+            headers=transformed_headers,
+            params={},  # Query params handled in URL
+            body=transformed_body,
+            protocol=request.protocol,
+            timeout=request.timeout,
+            metadata=request.metadata,
+        )
+
+    async def transform_codex_request(
+        self,
+        method: str,
+        path: str,
+        headers: dict[str, str],
+        body: bytes | None,
+        access_token: str,
+        session_id: str,
+        account_id: str,
+        codex_detection_data: CodexCacheData | None = None,
+        target_base_url: str = "https://chatgpt.com/backend-api/codex",
+    ) -> CodexRequestData:
+        """Transform Codex request using direct parameters from ProxyService.
+
+        Args:
+            method: HTTP method
+            path: Request path
+            headers: Request headers
+            body: Request body
+            access_token: OAuth access token
+            session_id: Codex session ID
+            account_id: ChatGPT account ID
+            codex_detection_data: Optional Codex detection data
+            target_base_url: Base URL for the Codex API
+
+        Returns:
+            Dictionary with transformed request data (method, url, headers, body)
+        """
+        # Transform URL path
+        transformed_path = self._transform_codex_path(path)
+        target_url = f"{target_base_url.rstrip('/')}{transformed_path}"
+
+        # Transform body first (inject instructions)
+        codex_body = None
+        if body:
+            # body is guaranteed to be bytes due to parameter type
+            codex_body = self.transform_codex_body(body, codex_detection_data)
+
+        # Transform headers with Codex CLI identity and authentication
+        codex_headers = self.create_codex_headers(
+            headers, access_token, session_id, account_id, body, codex_detection_data
+        )
+
+        # Update Content-Length if body was transformed and size changed
+        if codex_body and body and len(codex_body) != len(body):
+            # Remove any existing content-length headers (case-insensitive)
+            codex_headers = {
+                k: v for k, v in codex_headers.items() if k.lower() != "content-length"
+            }
+            codex_headers["Content-Length"] = str(len(codex_body))
+        elif codex_body and not body:
+            # New body was created where none existed
+            codex_headers["Content-Length"] = str(len(codex_body))
+
+        return CodexRequestData(
+            method=method,
+            url=target_url,
+            headers=codex_headers,
+            body=codex_body,
+        )
+
+    def _transform_codex_url(self, url: str) -> str:
+        """Transform URL from proxy format to ChatGPT backend format."""
+        # Extract base URL and path
+        if "://" in url:
+            protocol, rest = url.split("://", 1)
+            if "/" in rest:
+                domain, path = rest.split("/", 1)
+                path = "/" + path
+            else:
+                path = "/"
+        else:
+            path = url if url.startswith("/") else "/" + url
+
+        # Transform path and build target URL
+        transformed_path = self._transform_codex_path(path)
+        return f"https://chatgpt.com/backend-api/codex{transformed_path}"
+
+    def _transform_codex_path(self, path: str) -> str:
+        """Transform request path for Codex API."""
+        # Remove /codex prefix if present
+        if path.startswith("/codex"):
+            path = path[6:]  # Remove "/codex" prefix
+
+        # Ensure we have a valid path
+        if not path or path == "/":
+            path = "/responses"
+
+        # Handle session_id in path for /codex/{session_id}/responses pattern
+        if path.startswith("/") and "/" in path[1:]:
+            # This might be /{session_id}/responses - extract the responses part
+            parts = path.strip("/").split("/")
+            if len(parts) >= 2 and parts[-1] == "responses":
+                # Keep the /responses endpoint, session_id will be in headers
+                path = "/responses"
+
+        return path
+
+    def create_codex_headers(
+        self,
+        headers: dict[str, str],
+        access_token: str,
+        session_id: str,
+        account_id: str,
+        body: bytes | None = None,
+        codex_detection_data: CodexCacheData | None = None,
+    ) -> dict[str, str]:
+        """Create Codex headers with CLI identity and authentication."""
+        codex_headers = {}
+
+        # Strip potentially problematic headers
+        excluded_headers = {
+            "host",
+            "x-forwarded-for",
+            "x-forwarded-proto",
+            "x-forwarded-host",
+            "forwarded",
+            # Authentication headers to be replaced
+            "authorization",
+            "x-api-key",
+            # Compression headers to avoid decompression issues
+            "accept-encoding",
+            "content-encoding",
+            # CORS headers - should not be forwarded to upstream
+            "origin",
+            "access-control-request-method",
+            "access-control-request-headers",
+            "access-control-allow-origin",
+            "access-control-allow-methods",
+            "access-control-allow-headers",
+            "access-control-allow-credentials",
+            "access-control-max-age",
+            "access-control-expose-headers",
+        }
+
+        # Copy important headers (excluding problematic ones)
+        for key, value in headers.items():
+            lower_key = key.lower()
+            if lower_key not in excluded_headers:
+                codex_headers[key] = value
+
+        # Set authentication with OAuth token
+        if access_token:
+            codex_headers["Authorization"] = f"Bearer {access_token}"
+
+        # Set defaults for essential headers
+        if "content-type" not in [k.lower() for k in codex_headers]:
+            codex_headers["Content-Type"] = "application/json"
+        if "accept" not in [k.lower() for k in codex_headers]:
+            codex_headers["Accept"] = "application/json"
+
+        # Use detected Codex CLI headers when available
+        if codex_detection_data:
+            detected_headers = codex_detection_data.headers.to_headers_dict()
+            # Override with session-specific values
+            detected_headers["session_id"] = session_id
+            if account_id:
+                detected_headers["chatgpt-account-id"] = account_id
+            codex_headers.update(detected_headers)
+            logger.debug(
+                "using_detected_codex_headers",
+                version=codex_detection_data.codex_version,
+            )
+        else:
+            # Fallback to hardcoded Codex headers
+            codex_headers.update(
+                {
+                    "session_id": session_id,
+                    "originator": "codex_cli_rs",
+                    "openai-beta": "responses=experimental",
+                    "version": "0.21.0",
+                }
+            )
+            if account_id:
+                codex_headers["chatgpt-account-id"] = account_id
+            logger.debug("using_fallback_codex_headers")
+
+        # Don't set Accept header - let the backend handle it based on stream parameter
+        # Setting Accept: text/event-stream with stream:true in body causes 400 Bad Request
+        # The backend will determine the response format based on the stream parameter
+
+        return codex_headers
+
+    def _is_streaming_request(self, body: bytes | None) -> bool:
+        """Check if the request body indicates a streaming request (including injected default)."""
+        if not body:
+            return False
+
+        try:
+            data = json.loads(body.decode("utf-8"))
+            return data.get("stream", False) is True
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            return False
+
+    def _is_user_streaming_request(self, body: bytes | None) -> bool:
+        """Check if the user explicitly requested streaming (has 'stream' field in original body)."""
+        if not body:
+            return False
+
+        try:
+            data = json.loads(body.decode("utf-8"))
+            # Only return True if user explicitly included "stream" field (regardless of its value)
+            return "stream" in data and data.get("stream") is True
+        except (json.JSONDecodeError, UnicodeDecodeError):
+            return False
+
+    def transform_codex_body(
+        self, body: bytes, codex_detection_data: CodexCacheData | None = None
+    ) -> bytes:
+        """Transform request body to inject Codex CLI instructions."""
+        if not body:
+            return body
+
+        try:
+            data = json.loads(body.decode("utf-8"))
+        except (json.JSONDecodeError, UnicodeDecodeError) as e:
+            # Return original if not valid JSON
+            logger.warning(
+                "codex_transform_json_decode_failed",
+                error=str(e),
+                body_preview=body[:200].decode("utf-8", errors="replace")
+                if body
+                else None,
+                body_length=len(body) if body else 0,
+            )
+            return body
+
+        # Check if this request already has the full Codex instructions
+        # If instructions field exists and is longer than 1000 chars, it's already set
+        if (
+            "instructions" in data
+            and data["instructions"]
+            and len(data["instructions"]) > 1000
+        ):
+            # This already has full Codex instructions, don't replace them
+            logger.debug("skipping_codex_transform_has_full_instructions")
+            return body
+
+        # Get the instructions to inject
+        detected_instructions = None
+        if codex_detection_data:
+            detected_instructions = codex_detection_data.instructions.instructions_field
+        else:
+            # Fallback instructions from req.json
+            detected_instructions = (
+                "You are a coding agent running in the Codex CLI, a terminal-based coding assistant. "
+                "Codex CLI is an open source project led by OpenAI. You are expected to be precise, safe, and helpful.\n\n"
+                "Your capabilities:\n"
+                "- Receive user prompts and other context provided by the harness, such as files in the workspace.\n"
+                "- Communicate with the user by streaming thinking & responses, and by making & updating plans.\n"
+                "- Emit function calls to run terminal commands and apply patches. Depending on how this specific run is configured, "
+                "you can request that these function calls be escalated to the user for approval before running. "
+                'More on this in the "Sandbox and approvals" section.\n\n'
+                "Within this context, Codex refers to the open-source agentic coding interface "
+                "(not the old Codex language model built by OpenAI)."
+            )
+
+        # Always inject/override the instructions field
+        data["instructions"] = detected_instructions
+
+        # Only inject stream: true if user explicitly requested streaming or didn't specify
+        # For now, we'll inject stream: true by default since Codex seems to expect it
+        if "stream" not in data:
+            data["stream"] = True
+
+        return json.dumps(data, separators=(",", ":")).encode("utf-8")

ccproxy/core/http_transformers.py

@@ -361,6 +361,139 @@ class HTTPRequestTransformer(RequestTransformer):
 
         return proxy_headers
 
+    def _count_cache_control_blocks(self, data: dict[str, Any]) -> dict[str, int]:
+        """Count cache_control blocks in different parts of the request.
+
+        Returns:
+            Dictionary with counts for 'injected_system', 'user_system', and 'messages'
+        """
+        counts = {"injected_system": 0, "user_system": 0, "messages": 0}
+
+        # Count in system field
+        system = data.get("system")
+        if system:
+            if isinstance(system, str):
+                # String system prompts don't have cache_control
+                pass
+            elif isinstance(system, list):
+                # Count cache_control in system prompt blocks
+                # The first block(s) are injected, rest are user's
+                injected_count = 0
+                for i, block in enumerate(system):
+                    if isinstance(block, dict) and "cache_control" in block:
+                        # Check if this is the injected prompt (contains Claude Code identity)
+                        text = block.get("text", "")
+                        if "Claude Code" in text or "Anthropic's official CLI" in text:
+                            counts["injected_system"] += 1
+                            injected_count = max(injected_count, i + 1)
+                        elif i < injected_count:
+                            # Part of injected system (multiple blocks)
+                            counts["injected_system"] += 1
+                        else:
+                            counts["user_system"] += 1
+
+        # Count in messages
+        messages = data.get("messages", [])
+        for msg in messages:
+            content = msg.get("content")
+            if isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict) and "cache_control" in block:
+                        counts["messages"] += 1
+
+        return counts
+
+    def _limit_cache_control_blocks(
+        self, data: dict[str, Any], max_blocks: int = 4
+    ) -> dict[str, Any]:
+        """Limit the number of cache_control blocks to comply with Anthropic's limit.
+
+        Priority order:
+        1. Injected system prompt cache_control (highest priority - Claude Code identity)
+        2. User's system prompt cache_control
+        3. User's message cache_control (lowest priority)
+
+        Args:
+            data: Request data dictionary
+            max_blocks: Maximum number of cache_control blocks allowed (default: 4)
+
+        Returns:
+            Modified data dictionary with cache_control blocks limited
+        """
+        import copy
+
+        # Deep copy to avoid modifying original
+        data = copy.deepcopy(data)
+
+        # Count existing blocks
+        counts = self._count_cache_control_blocks(data)
+        total = counts["injected_system"] + counts["user_system"] + counts["messages"]
+
+        if total <= max_blocks:
+            # No need to remove anything
+            return data
+
+        logger.warning(
+            "cache_control_limit_exceeded",
+            total_blocks=total,
+            max_blocks=max_blocks,
+            injected=counts["injected_system"],
+            user_system=counts["user_system"],
+            messages=counts["messages"],
+        )
+
+        # Calculate how many to remove
+        to_remove = total - max_blocks
+        removed = 0
+
+        # Remove from messages first (lowest priority)
+        if to_remove > 0 and counts["messages"] > 0:
+            messages = data.get("messages", [])
+            for msg in reversed(messages):  # Remove from end first
+                if removed >= to_remove:
+                    break
+                content = msg.get("content")
+                if isinstance(content, list):
+                    for block in reversed(content):
+                        if removed >= to_remove:
+                            break
+                        if isinstance(block, dict) and "cache_control" in block:
+                            del block["cache_control"]
+                            removed += 1
+                            logger.debug("removed_cache_control", location="message")
+
+        # Remove from user system prompts next
+        if removed < to_remove and counts["user_system"] > 0:
+            system = data.get("system")
+            if isinstance(system, list):
+                # Find and remove cache_control from user system blocks (non-injected)
+                for block in reversed(system):
+                    if removed >= to_remove:
+                        break
+                    if isinstance(block, dict) and "cache_control" in block:
+                        text = block.get("text", "")
+                        # Skip injected prompts (highest priority)
+                        if (
+                            "Claude Code" not in text
+                            and "Anthropic's official CLI" not in text
+                        ):
+                            del block["cache_control"]
+                            removed += 1
+                            logger.debug(
+                                "removed_cache_control", location="user_system"
+                            )
+
+        # In theory, we should never need to remove injected system cache_control
+        # but include this for completeness
+        if removed < to_remove:
+            logger.error(
+                "cannot_preserve_injected_cache_control",
+                needed_to_remove=to_remove,
+                actually_removed=removed,
+            )
+
+        return data
+
     def transform_request_body(
         self,
         body: bytes,
@@ -398,8 +531,16 @@ class HTTPRequestTransformer(RequestTransformer):
             import json
 
             data = json.loads(body.decode("utf-8"))
-        except (json.JSONDecodeError, UnicodeDecodeError):
+        except (json.JSONDecodeError, UnicodeDecodeError) as e:
             # Return original if not valid JSON
+            logger.warning(
+                "http_transform_json_decode_failed",
+                error=str(e),
+                body_preview=body[:200].decode("utf-8", errors="replace")
+                if body
+                else None,
+                body_length=len(body) if body else 0,
+            )
             return body
 
         # Get the system field to inject
@@ -440,6 +581,9 @@ class HTTPRequestTransformer(RequestTransformer):
                     # Both are lists, concatenate
                     data["system"] = detected_system + existing_system
 
+        # Limit cache_control blocks to comply with Anthropic's limit
+        data = self._limit_cache_control_blocks(data)
+
         return json.dumps(data).encode("utf-8")
 
     def _is_openai_request(self, path: str, body: bytes) -> bool:
@@ -462,7 +606,14 @@ class HTTPRequestTransformer(RequestTransformer):
                 messages = data.get("messages", [])
                 if messages and any(msg.get("role") == "system" for msg in messages):
                     return True
-            except (json.JSONDecodeError, UnicodeDecodeError):
+            except (json.JSONDecodeError, UnicodeDecodeError) as e:
+                logger.warning(
+                    "openai_request_detection_json_decode_failed",
+                    error=str(e),
+                    body_preview=body[:100].decode("utf-8", errors="replace")
+                    if body
+                    else None,
+                )
                 pass
 
         return False

ccproxy/models/detection.py

@@ -124,3 +124,85 @@ class ClaudeCacheData(BaseModel):
     ] = None  # type: ignore # Pydantic handles this via default_factory
 
     model_config = ConfigDict(extra="forbid")
+
+
+class CodexHeaders(BaseModel):
+    """Pydantic model for Codex CLI headers extraction with field aliases."""
+
+    session_id: str = Field(
+        alias="session_id",
+        description="Codex session identifier",
+        default="",
+    )
+    originator: str = Field(
+        description="Codex originator identifier",
+        default="codex_cli_rs",
+    )
+    openai_beta: str = Field(
+        alias="openai-beta",
+        description="OpenAI beta features",
+        default="responses=experimental",
+    )
+    version: str = Field(
+        description="Codex CLI version",
+        default="0.21.0",
+    )
+    chatgpt_account_id: str = Field(
+        alias="chatgpt-account-id",
+        description="ChatGPT account identifier",
+        default="",
+    )
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    def to_headers_dict(self) -> dict[str, str]:
+        """Convert to headers dictionary for HTTP forwarding with proper case."""
+        headers = {}
+
+        # Map field names to proper HTTP header names
+        header_mapping = {
+            "session_id": "session_id",
+            "originator": "originator",
+            "openai_beta": "openai-beta",
+            "version": "version",
+            "chatgpt_account_id": "chatgpt-account-id",
+        }
+
+        for field_name, header_name in header_mapping.items():
+            value = getattr(self, field_name, None)
+            if value is not None and value != "":
+                headers[header_name] = value
+
+        return headers
+
+
+class CodexInstructionsData(BaseModel):
+    """Extracted Codex instructions information."""
+
+    instructions_field: Annotated[
+        str,
+        Field(
+            description="Complete instructions field as detected from Codex CLI, preserving exact text content"
+        ),
+    ]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class CodexCacheData(BaseModel):
+    """Cached Codex CLI detection data with version tracking."""
+
+    codex_version: Annotated[str, Field(description="Codex CLI version")]
+    headers: Annotated[CodexHeaders, Field(description="Extracted headers")]
+    instructions: Annotated[
+        CodexInstructionsData, Field(description="Extracted instructions")
+    ]
+    cached_at: Annotated[
+        datetime,
+        Field(
+            description="Cache timestamp",
+            default_factory=lambda: datetime.now(UTC),
+        ),
+    ] = None  # type: ignore # Pydantic handles this via default_factory
+
+    model_config = ConfigDict(extra="forbid")

ccproxy/models/requests.py

@@ -83,3 +83,25 @@ class Usage(BaseModel):
     cache_read_input_tokens: Annotated[
         int | None, Field(description="Number of tokens read from cache")
     ] = None
+
+
+class CodexMessage(BaseModel):
+    """Message format for Codex requests."""
+
+    role: Annotated[Literal["user", "assistant"], Field(description="Message role")]
+    content: Annotated[str, Field(description="Message content")]
+
+
+class CodexRequest(BaseModel):
+    """OpenAI Codex completion request model."""
+
+    model: Annotated[str, Field(description="Model name (e.g., gpt-5)")] = "gpt-5"
+    instructions: Annotated[
+        str | None, Field(description="System instructions for the model")
+    ] = None
+    messages: Annotated[list[CodexMessage], Field(description="Conversation messages")]
+    stream: Annotated[bool, Field(description="Whether to stream the response")] = True
+
+    model_config = ConfigDict(
+        extra="allow"
+    )  # Allow additional fields for compatibility