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

ccproxy/core/logging.py

@@ -1,10 +1,22 @@
 import logging
+import shutil
 import sys
+from collections.abc import MutableMapping
 from pathlib import Path
+from typing import Any, TextIO
 
 import structlog
+from rich.console import Console
+from rich.traceback import Traceback
 from structlog.stdlib import BoundLogger
-from structlog.typing import Processor
+from structlog.typing import ExcInfo, Processor
+
+
+suppress_debug = [
+    "ccproxy.scheduler",
+    "ccproxy.observability.context",
+    "ccproxy.utils.simple_request_logger",
+]
 
 
 def configure_structlog(log_level: int = logging.INFO) -> None:
@@ -30,12 +42,28 @@ def configure_structlog(log_level: int = logging.INFO) -> None:
         )
 
     # Common processors for all log levels
+    # First add timestamp with microseconds
+    processors.append(
+        structlog.processors.TimeStamper(
+            fmt="%H:%M:%S.%f" if log_level < logging.INFO else "%Y-%m-%d %H:%M:%S.%f",
+            key="timestamp_raw",
+        )
+    )
+
+    # Then add processor to convert microseconds to milliseconds
+    def format_timestamp_ms(
+        logger: Any, log_method: str, event_dict: MutableMapping[str, Any]
+    ) -> MutableMapping[str, Any]:
+        """Format timestamp with milliseconds instead of microseconds."""
+        if "timestamp_raw" in event_dict:
+            # Truncate microseconds to milliseconds (6 digits to 3)
+            timestamp_raw = event_dict.pop("timestamp_raw")
+            event_dict["timestamp"] = timestamp_raw[:-3]
+        return event_dict
+
     processors.extend(
         [
-            # Use human-readable timestamp for structlog logs in debug mode, normal otherwise
-            structlog.processors.TimeStamper(
-                fmt="%H:%M:%S" if log_level < logging.INFO else "%Y-%m-%d %H:%M:%S"
-            ),
+            format_timestamp_ms,
             structlog.processors.StackInfoRenderer(),
             structlog.dev.set_exc_info,  # Handle exceptions properly
             # This MUST be the last processor - allows different renderers per handler
@@ -48,12 +76,42 @@ def configure_structlog(log_level: int = logging.INFO) -> None:
         context_class=dict,
         logger_factory=structlog.stdlib.LoggerFactory(),
         wrapper_class=structlog.stdlib.BoundLogger,
-        cache_logger_on_first_use=True,  # Cache for performance
+        cache_logger_on_first_use=True,
+    )
+
+
+def rich_traceback(sio: TextIO, exc_info: ExcInfo) -> None:
+    """Pretty-print *exc_info* to *sio* using the *Rich* package.
+
+    Based on:
+    https://github.com/hynek/structlog/blob/74cdff93af217519d4ebea05184f5e0db2972556/src/structlog/dev.py#L179-L192
+
+    """
+    term_width, _height = shutil.get_terminal_size((80, 123))
+    sio.write("\n")
+    # Rich docs: https://rich.readthedocs.io/en/stable/reference/traceback.html
+    Console(file=sio, color_system="truecolor").print(
+        Traceback.from_exception(
+            *exc_info,
+            # show_locals=True,  # Takes up too much vertical space
+            extra_lines=1,  # Reduce amount of source code displayed
+            width=term_width,  # Maximize width
+            max_frames=5,  # Default is 10
+            suppress=[
+                "click",
+                "typer",
+                "uvicorn",
+                "fastapi",
+                "starlette",
+            ],  # Suppress noise from these libraries
+        ),
     )
 
 
 def setup_logging(
-    json_logs: bool = False, log_level_name: str = "DEBUG", log_file: str | None = None
+    json_logs: bool = False,
+    log_level_name: str = "DEBUG",
+    log_file: str | None = None,
 ) -> BoundLogger:
     """
     Setup logging for the entire application using canonical structlog pattern.
@@ -61,6 +119,21 @@ def setup_logging(
     """
     log_level = getattr(logging, log_level_name.upper(), logging.INFO)
 
+    # Install rich traceback handler globally with frame limit
+    # install_rich_traceback(
+    #     show_locals=log_level <= logging.DEBUG,  # Only show locals in debug mode
+    #     max_frames=max_traceback_frames,
+    #     width=120,
+    #     word_wrap=True,
+    #     suppress=[
+    #         "click",
+    #         "typer",
+    #         "uvicorn",
+    #         "fastapi",
+    #         "starlette",
+    #     ],  # Suppress noise from these libraries
+    # )
+
     # Get root logger and set level BEFORE configuring structlog
     root_logger = logging.getLogger()
     root_logger.setLevel(log_level)
@@ -91,12 +164,26 @@ def setup_logging(
         )
 
     # Add appropriate timestamper for console vs file
+    # Using custom lambda to truncate microseconds to milliseconds
     console_timestamper = (
-        structlog.processors.TimeStamper(fmt="%H:%M:%S")
+        structlog.processors.TimeStamper(fmt="%H:%M:%S.%f", key="timestamp_raw")
         if log_level < logging.INFO
-        else structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S")
+        else structlog.processors.TimeStamper(
+            fmt="%Y-%m-%d %H:%M:%S.%f", key="timestamp_raw"
+        )
     )
 
+    # Processor to convert microseconds to milliseconds
+    def format_timestamp_ms(
+        logger: Any, log_method: str, event_dict: MutableMapping[str, Any]
+    ) -> MutableMapping[str, Any]:
+        """Format timestamp with milliseconds instead of microseconds."""
+        if "timestamp_raw" in event_dict:
+            # Truncate microseconds to milliseconds (6 digits to 3)
+            timestamp_raw = event_dict.pop("timestamp_raw")
+            event_dict["timestamp"] = timestamp_raw[:-3]
+        return event_dict
+
     file_timestamper = structlog.processors.TimeStamper(fmt="iso")
 
     # 4. Setup console handler with ConsoleRenderer
@@ -105,14 +192,16 @@ def setup_logging(
     console_renderer = (
         structlog.processors.JSONRenderer()
         if json_logs
-        else structlog.dev.ConsoleRenderer()
+        else structlog.dev.ConsoleRenderer(
+            exception_formatter=rich_traceback  # structlog.dev.rich_traceback,  # Use rich for better formatting
+        )
     )
 
     # Console gets human-readable timestamps for both structlog and stdlib logs
-    console_processors = shared_processors + [console_timestamper]
+    console_processors = shared_processors + [console_timestamper, format_timestamp_ms]
     console_handler.setFormatter(
         structlog.stdlib.ProcessorFormatter(
-            foreign_pre_chain=console_processors,
+            foreign_pre_chain=console_processors,  # type: ignore[arg-type]
             processor=console_renderer,
         )
     )
@@ -182,6 +271,13 @@ def setup_logging(
         noisy_logger.propagate = True
         noisy_logger.setLevel(noisy_log_level)
 
+    [
+        logging.getLogger(logger_name).setLevel(
+            logging.INFO if log_level <= logging.DEBUG else log_level
+        )  # type: ignore[func-returns-value]
+        for logger_name in suppress_debug
+    ]
+
     return structlog.get_logger()  # type: ignore[no-any-return]
 
 

ccproxy/core/transformers.py

@@ -114,6 +114,11 @@ class BaseTransformer(ABC):
 class RequestTransformer(BaseTransformer):
     """Base class for request transformers."""
 
+    def __init__(self, proxy_mode: str = "full") -> None:
+        """Initialize request transformer with proxy mode."""
+        super().__init__()
+        self.proxy_mode = proxy_mode
+
     async def transform(
         self, request: ProxyRequest, context: TransformContext | None = None
     ) -> ProxyRequest:

ccproxy/models/claude_sdk.py

@@ -338,6 +338,59 @@ SDKContentBlock = Annotated[
 ExtendedContentBlock = SDKContentBlock
 
 
+# SDK Query Message Types
+class SDKMessageContent(BaseModel):
+    """Content structure for SDK query messages."""
+
+    role: Literal["user"] = "user"
+    content: str = Field(..., description="Message text content")
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class SDKMessage(BaseModel):
+    """Message format used to send queries over the Claude SDK.
+
+    This represents the internal message structure expected by the
+    Claude Code SDK client for query operations.
+    """
+
+    type: Literal["user"] = "user"
+    message: SDKMessageContent = Field(
+        ..., description="Message content with role and text"
+    )
+    parent_tool_use_id: str | None = Field(
+        None, description="Optional parent tool use ID"
+    )
+    session_id: str | None = Field(
+        None, description="Optional session ID for conversation continuity"
+    )
+
+    model_config = ConfigDict(extra="forbid")
+
+
+def create_sdk_message(
+    content: str,
+    session_id: str | None = None,
+    parent_tool_use_id: str | None = None,
+) -> SDKMessage:
+    """Create an SDKMessage instance for sending queries to Claude SDK.
+
+    Args:
+        content: The text content to send to Claude
+        session_id: Optional session ID for conversation continuity
+        parent_tool_use_id: Optional parent tool use ID
+
+    Returns:
+        SDKMessage instance ready to send to Claude SDK
+    """
+    return SDKMessage(
+        message=SDKMessageContent(content=content),
+        session_id=session_id,
+        parent_tool_use_id=parent_tool_use_id,
+    )
+
+
 # Conversion Functions
 def convert_sdk_text_block(text_content: str) -> TextBlock:
     """Convert raw text content to TextBlock model."""
@@ -404,6 +457,10 @@ __all__ = [
     "AssistantMessage",
     "SystemMessage",
     "ResultMessage",
+    # SDK Query Messages
+    "SDKMessageContent",
+    "SDKMessage",
+    "create_sdk_message",
     # Custom content blocks
     "SDKMessageMode",
     "ToolUseSDKBlock",

ccproxy/models/detection.py

@@ -0,0 +1,208 @@
+"""Detection models for Claude Code CLI headers and system prompt extraction."""
+
+from __future__ import annotations
+
+from datetime import UTC, datetime
+from typing import Annotated, Any
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class ClaudeCodeHeaders(BaseModel):
+    """Pydantic model for Claude CLI headers extraction with field aliases."""
+
+    anthropic_beta: str = Field(
+        alias="anthropic-beta",
+        description="Anthropic beta features",
+        default="claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14",
+    )
+    anthropic_version: str = Field(
+        alias="anthropic-version",
+        description="Anthropic API version",
+        default="2023-06-01",
+    )
+    anthropic_dangerous_direct_browser_access: str = Field(
+        alias="anthropic-dangerous-direct-browser-access",
+        description="Browser access flag",
+        default="true",
+    )
+    x_app: str = Field(
+        alias="x-app", description="Application identifier", default="cli"
+    )
+    user_agent: str = Field(
+        alias="user-agent",
+        description="User agent string",
+        default="claude-cli/1.0.60 (external, cli)",
+    )
+    x_stainless_lang: str = Field(
+        alias="x-stainless-lang", description="SDK language", default="js"
+    )
+    x_stainless_retry_count: str = Field(
+        alias="x-stainless-retry-count", description="Retry count", default="0"
+    )
+    x_stainless_timeout: str = Field(
+        alias="x-stainless-timeout", description="Request timeout", default="60"
+    )
+    x_stainless_package_version: str = Field(
+        alias="x-stainless-package-version",
+        description="Package version",
+        default="0.55.1",
+    )
+    x_stainless_os: str = Field(
+        alias="x-stainless-os", description="Operating system", default="Linux"
+    )
+    x_stainless_arch: str = Field(
+        alias="x-stainless-arch", description="Architecture", default="x64"
+    )
+    x_stainless_runtime: str = Field(
+        alias="x-stainless-runtime", description="Runtime", default="node"
+    )
+    x_stainless_runtime_version: str = Field(
+        alias="x-stainless-runtime-version",
+        description="Runtime version",
+        default="v24.3.0",
+    )
+
+    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 = {
+            "anthropic_beta": "anthropic-beta",
+            "anthropic_version": "anthropic-version",
+            "anthropic_dangerous_direct_browser_access": "anthropic-dangerous-direct-browser-access",
+            "x_app": "x-app",
+            "user_agent": "User-Agent",
+            "x_stainless_lang": "X-Stainless-Lang",
+            "x_stainless_retry_count": "X-Stainless-Retry-Count",
+            "x_stainless_timeout": "X-Stainless-Timeout",
+            "x_stainless_package_version": "X-Stainless-Package-Version",
+            "x_stainless_os": "X-Stainless-OS",
+            "x_stainless_arch": "X-Stainless-Arch",
+            "x_stainless_runtime": "X-Stainless-Runtime",
+            "x_stainless_runtime_version": "X-Stainless-Runtime-Version",
+        }
+
+        for field_name, header_name in header_mapping.items():
+            value = getattr(self, field_name, None)
+            if value is not None:
+                headers[header_name] = value
+
+        return headers
+
+
+class SystemPromptData(BaseModel):
+    """Extracted system prompt information."""
+
+    system_field: Annotated[
+        str | list[dict[str, Any]],
+        Field(
+            description="Complete system field as detected from Claude CLI, preserving exact structure including type, text, and cache_control"
+        ),
+    ]
+
+    model_config = ConfigDict(extra="forbid")
+
+
+class ClaudeCacheData(BaseModel):
+    """Cached Claude CLI detection data with version tracking."""
+
+    claude_version: Annotated[str, Field(description="Claude CLI version")]
+    headers: Annotated[ClaudeCodeHeaders, Field(description="Extracted headers")]
+    system_prompt: Annotated[
+        SystemPromptData, Field(description="Extracted system prompt")
+    ]
+    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")
+
+
+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

ccproxy/models/responses.py

@@ -252,3 +252,19 @@ class InternalServerError(APIError):
     type: Annotated[
         Literal["internal_server_error"], Field(description="Error type")
     ] = "internal_server_error"
+
+
+class CodexResponse(BaseModel):
+    """OpenAI Codex completion response model."""
+
+    id: Annotated[str, Field(description="Response ID")]
+    model: Annotated[str, Field(description="Model used for completion")]
+    content: Annotated[str, Field(description="Generated content")]
+    finish_reason: Annotated[
+        str | None, Field(description="Reason the response finished")
+    ] = None
+    usage: Annotated[Usage | None, Field(description="Token usage information")] = None
+
+    model_config = ConfigDict(
+        extra="allow"
+    )  # Allow additional fields for compatibility

ccproxy/observability/access_logger.py

@@ -63,20 +63,31 @@ async def log_request_access(
     path = path or ctx_metadata.get("path")
     status_code = status_code or ctx_metadata.get("status_code")
 
-    # Prepare comprehensive log data
+    # Prepare basic log data (always included)
     log_data = {
         "request_id": context.request_id,
         "method": method,
         "path": path,
         "query": query,
-        "status_code": status_code,
         "client_ip": client_ip,
         "user_agent": user_agent,
-        "duration_ms": context.duration_ms,
-        "duration_seconds": context.duration_seconds,
-        "error_message": error_message,
     }
 
+    # Add response-specific fields (only for completed requests)
+    is_streaming = ctx_metadata.get("streaming", False)
+    is_streaming_complete = ctx_metadata.get("event_type", "") == "streaming_complete"
+
+    # Include response fields only if this is not a streaming start
+    if not is_streaming or is_streaming_complete or ctx_metadata.get("error"):
+        log_data.update(
+            {
+                "status_code": status_code,
+                "duration_ms": context.duration_ms,
+                "duration_seconds": context.duration_seconds,
+                "error_message": error_message,
+            }
+        )
+
     # Add token and cost metrics if available
     token_fields = [
         "tokens_input",
@@ -85,6 +96,7 @@ async def log_request_access(
         "cache_write_tokens",
         "cost_usd",
         "cost_sdk_usd",
+        "num_turns",
     ]
 
     for field in token_fields:
@@ -93,18 +105,50 @@ async def log_request_access(
             log_data[field] = value
 
     # Add service and endpoint info
-    service_fields = [
-        "endpoint",
-        "model",
-        "streaming",
-        "service_type",
-    ]
+    service_fields = ["endpoint", "model", "streaming", "service_type", "headers"]
 
     for field in service_fields:
         value = ctx_metadata.get(field)
         if value is not None:
             log_data[field] = value
 
+    # Add session context metadata if available
+    session_fields = [
+        "session_id",
+        "session_type",  # "session_pool" or "direct"
+        "session_status",  # active, idle, connecting, etc.
+        "session_age_seconds",  # how long session has been alive
+        "session_message_count",  # number of messages in session
+        "session_pool_enabled",  # whether session pooling is enabled
+        "session_idle_seconds",  # how long since last activity
+        "session_error_count",  # number of errors in this session
+        "session_is_new",  # whether this is a newly created session
+    ]
+
+    for field in session_fields:
+        value = ctx_metadata.get(field)
+        if value is not None:
+            log_data[field] = value
+
+    # Add rate limit headers if available
+    rate_limit_fields = [
+        "x-ratelimit-limit",
+        "x-ratelimit-remaining",
+        "x-ratelimit-reset",
+        "anthropic-ratelimit-requests-limit",
+        "anthropic-ratelimit-requests-remaining",
+        "anthropic-ratelimit-requests-reset",
+        "anthropic-ratelimit-tokens-limit",
+        "anthropic-ratelimit-tokens-remaining",
+        "anthropic-ratelimit-tokens-reset",
+        "anthropic_request_id",
+    ]
+
+    for field in rate_limit_fields:
+        value = ctx_metadata.get(field)
+        if value is not None:
+            log_data[field] = value
+
     # Add any additional metadata provided
     log_data.update(additional_metadata)
 
@@ -112,15 +156,18 @@ async def log_request_access(
     log_data = {k: v for k, v in log_data.items() if v is not None}
 
     logger = context.logger.bind(**log_data)
-    if not log_data.get("streaming", False):
+
+    if context.metadata.get("error"):
+        logger.warn("access_log", exc_info=context.metadata.get("error"))
+    elif not is_streaming:
         # Log as access_log event (structured logging)
         logger.info("access_log")
-    elif log_data.get("event_type", "") == "streaming_complete":
+    elif is_streaming_complete:
         logger.info("access_log")
     else:
         # if streaming is true, and not streaming_complete log as debug
         # real access_log will come later
-        logger.debug("access_log")
+        logger.info("access_log_streaming_start")
 
     # Store in DuckDB if available
     await _store_access_log(log_data, storage)
@@ -258,6 +305,17 @@ async def _store_access_log(
             "cache_write_tokens": log_data.get("cache_write_tokens", 0),
             "cost_usd": log_data.get("cost_usd", 0.0),
             "cost_sdk_usd": log_data.get("cost_sdk_usd", 0.0),
+            "num_turns": log_data.get("num_turns", 0),
+            # Session context metadata
+            "session_type": log_data.get("session_type", ""),
+            "session_status": log_data.get("session_status", ""),
+            "session_age_seconds": log_data.get("session_age_seconds", 0.0),
+            "session_message_count": log_data.get("session_message_count", 0),
+            "session_client_id": log_data.get("session_client_id", ""),
+            "session_pool_enabled": log_data.get("session_pool_enabled", False),
+            "session_idle_seconds": log_data.get("session_idle_seconds", 0.0),
+            "session_error_count": log_data.get("session_error_count", 0),
+            "session_is_new": log_data.get("session_is_new", True),
         }
 
         # Store asynchronously using queue-based DuckDB (prevents deadlocks)