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

ccproxy/core/http_transformers.py

@@ -3,6 +3,7 @@
 from typing import TYPE_CHECKING, Any
 
 import structlog
+from typing_extensions import TypedDict
 
 from ccproxy.core.transformers import RequestTransformer, ResponseTransformer
 from ccproxy.core.types import ProxyRequest, ProxyResponse, TransformContext
@@ -20,13 +21,64 @@ claude_code_prompt = "You are Claude Code, Anthropic's official CLI for Claude."
 # claude_code_prompt = "<system-reminder>\nAs you answer the user's questions, you can use the following context:\n# important-instruction-reminders\nDo what has been asked; nothing more, nothing less.\nNEVER create files unless they're absolutely necessary for achieving your goal.\nALWAYS prefer editing an existing file to creating a new one.\nNEVER proactively create documentation files (*.md) or README files. Only create documentation files if explicitly requested by the User.\n\n      \n      IMPORTANT: this context may or may not be relevant to your tasks. You should not respond to this context unless it is highly relevant to your task.\n</system-reminder>\n"
 
 
-def get_claude_code_prompt() -> dict[str, Any]:
-    """Get the Claude Code system prompt with cache control."""
-    return {
-        "type": "text",
-        "text": claude_code_prompt,
-        "cache_control": {"type": "ephemeral"},
-    }
+def get_detected_system_field(
+    app_state: Any = None, injection_mode: str = "minimal"
+) -> Any:
+    """Get the detected system field for injection.
+
+    Args:
+        app_state: App state containing detection data
+        injection_mode: 'minimal' or 'full' mode
+
+    Returns:
+        The system field to inject (preserving exact Claude CLI structure), or None if no detection data available
+    """
+    if not app_state or not hasattr(app_state, "claude_detection_data"):
+        return None
+
+    claude_data = app_state.claude_detection_data
+    detected_system = claude_data.system_prompt.system_field
+
+    if injection_mode == "full":
+        # Return the complete detected system field exactly as Claude CLI sent it
+        return detected_system
+    else:
+        # Minimal mode: extract just the first system message, preserving its structure
+        if isinstance(detected_system, str):
+            return detected_system
+        elif isinstance(detected_system, list) and detected_system:
+            # Return only the first message object with its complete structure (type, text, cache_control)
+            return [detected_system[0]]
+
+    return None
+
+
+def get_fallback_system_field() -> list[dict[str, Any]]:
+    """Get fallback system field when no detection data is available."""
+    return [
+        {
+            "type": "text",
+            "text": claude_code_prompt,
+            "cache_control": {"type": "ephemeral"},
+        }
+    ]
+
+
+class RequestData(TypedDict):
+    """Typed structure for transformed request data."""
+
+    method: str
+    url: str
+    headers: dict[str, str]
+    body: bytes | None
+
+
+class ResponseData(TypedDict):
+    """Typed structure for transformed response data."""
+
+    status_code: int
+    headers: dict[str, str]
+    body: bytes
 
 
 class HTTPRequestTransformer(RequestTransformer):
@@ -73,24 +125,39 @@ class HTTPRequestTransformer(RequestTransformer):
         elif context and isinstance(context, dict):
             access_token = context.get("access_token", "")
 
-        transformed_headers = self.create_proxy_headers(request.headers, access_token)
+        # Extract app_state from context if available
+        app_state = None
+        if context and hasattr(context, "app_state"):
+            app_state = context.app_state
+        elif context and isinstance(context, dict):
+            app_state = context.get("app_state")
+
+        transformed_headers = self.create_proxy_headers(
+            request.headers, access_token, self.proxy_mode, app_state
+        )
 
         # Transform body
         transformed_body = request.body
         if request.body:
             if isinstance(request.body, bytes):
                 transformed_body = self.transform_request_body(
-                    request.body, transformed_path
+                    request.body, transformed_path, self.proxy_mode, app_state
                 )
             elif isinstance(request.body, str):
                 transformed_body = self.transform_request_body(
-                    request.body.encode("utf-8"), transformed_path
+                    request.body.encode("utf-8"),
+                    transformed_path,
+                    self.proxy_mode,
+                    app_state,
                 )
             elif isinstance(request.body, dict):
                 import json
 
                 transformed_body = self.transform_request_body(
-                    json.dumps(request.body).encode("utf-8"), transformed_path
+                    json.dumps(request.body).encode("utf-8"),
+                    transformed_path,
+                    self.proxy_mode,
+                    app_state,
                 )
 
         # Create new transformed request
@@ -105,6 +172,88 @@ class HTTPRequestTransformer(RequestTransformer):
             metadata=request.metadata,
         )
 
+    async def transform_proxy_request(
+        self,
+        method: str,
+        path: str,
+        headers: dict[str, str],
+        body: bytes | None,
+        query_params: dict[str, str | list[str]] | None,
+        access_token: str,
+        target_base_url: str = "https://api.anthropic.com",
+        app_state: Any = None,
+        injection_mode: str = "minimal",
+    ) -> RequestData:
+        """Transform request using direct parameters from ProxyService.
+
+        This method provides the same functionality as ProxyService._transform_request()
+        but is properly located in the transformer layer.
+
+        Args:
+            method: HTTP method
+            path: Request path
+            headers: Request headers
+            body: Request body
+            query_params: Query parameters
+            access_token: OAuth access token
+            target_base_url: Base URL for the target API
+            app_state: Optional app state containing detection data
+            injection_mode: System prompt injection mode
+
+        Returns:
+            Dictionary with transformed request data (method, url, headers, body)
+        """
+        import urllib.parse
+
+        # Transform path
+        transformed_path = self.transform_path(path, self.proxy_mode)
+        target_url = f"{target_base_url.rstrip('/')}{transformed_path}"
+
+        # Add beta=true query parameter for /v1/messages requests if not already present
+        if transformed_path == "/v1/messages":
+            if query_params is None:
+                query_params = {}
+            elif "beta" not in query_params:
+                query_params = dict(query_params)  # Make a copy
+
+            if "beta" not in query_params:
+                query_params["beta"] = "true"
+
+        # Transform body first (as it might change size)
+        proxy_body = None
+        if body:
+            proxy_body = self.transform_request_body(
+                body, path, self.proxy_mode, app_state, injection_mode
+            )
+
+        # Transform headers (and update Content-Length if body changed)
+        proxy_headers = self.create_proxy_headers(
+            headers, access_token, self.proxy_mode, app_state
+        )
+
+        # Update Content-Length if body was transformed and size changed
+        if proxy_body and body and len(proxy_body) != len(body):
+            # Remove any existing content-length headers (case-insensitive)
+            proxy_headers = {
+                k: v for k, v in proxy_headers.items() if k.lower() != "content-length"
+            }
+            proxy_headers["Content-Length"] = str(len(proxy_body))
+        elif proxy_body and not body:
+            # New body was created where none existed
+            proxy_headers["Content-Length"] = str(len(proxy_body))
+
+        # Add query parameters to URL if present
+        if query_params:
+            query_string = urllib.parse.urlencode(query_params)
+            target_url = f"{target_url}?{query_string}"
+
+        return RequestData(
+            method=method,
+            url=target_url,
+            headers=proxy_headers,
+            body=proxy_body,
+        )
+
     def transform_path(self, path: str, proxy_mode: str = "full") -> str:
         """Transform request path."""
         # Remove /api prefix if present (for new proxy endpoints)
@@ -122,7 +271,11 @@ class HTTPRequestTransformer(RequestTransformer):
         return path
 
     def create_proxy_headers(
-        self, headers: dict[str, str], access_token: str, proxy_mode: str = "full"
+        self,
+        headers: dict[str, str],
+        access_token: str,
+        proxy_mode: str = "full",
+        app_state: Any = None,
     ) -> dict[str, str]:
         """Create proxy headers from original headers with Claude CLI identity."""
         proxy_headers = {}
@@ -170,27 +323,35 @@ class HTTPRequestTransformer(RequestTransformer):
         if "connection" not in [k.lower() for k in proxy_headers]:
             proxy_headers["Connection"] = "keep-alive"
 
-        # Critical Claude/Anthropic headers for tools and beta features
-        proxy_headers["anthropic-beta"] = (
-            "claude-code-20250219,oauth-2025-04-20,"
-            "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
-        )
-        proxy_headers["anthropic-version"] = "2023-06-01"
-        proxy_headers["anthropic-dangerous-direct-browser-access"] = "true"
-
-        # Claude CLI identity headers
-        proxy_headers["x-app"] = "cli"
-        proxy_headers["User-Agent"] = "claude-cli/1.0.60 (external, cli)"
-
-        # Stainless SDK compatibility headers
-        proxy_headers["X-Stainless-Lang"] = "js"
-        proxy_headers["X-Stainless-Retry-Count"] = "0"
-        proxy_headers["X-Stainless-Timeout"] = "60"
-        proxy_headers["X-Stainless-Package-Version"] = "0.55.1"
-        proxy_headers["X-Stainless-OS"] = "Linux"
-        proxy_headers["X-Stainless-Arch"] = "x64"
-        proxy_headers["X-Stainless-Runtime"] = "node"
-        proxy_headers["X-Stainless-Runtime-Version"] = "v24.3.0"
+        # Use detected Claude CLI headers when available
+        if app_state and hasattr(app_state, "claude_detection_data"):
+            claude_data = app_state.claude_detection_data
+            detected_headers = claude_data.headers.to_headers_dict()
+            proxy_headers.update(detected_headers)
+            logger.debug("using_detected_headers", version=claude_data.claude_version)
+        else:
+            # Fallback to hardcoded Claude/Anthropic headers
+            proxy_headers["anthropic-beta"] = (
+                "claude-code-20250219,oauth-2025-04-20,"
+                "interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14"
+            )
+            proxy_headers["anthropic-version"] = "2023-06-01"
+            proxy_headers["anthropic-dangerous-direct-browser-access"] = "true"
+
+            # Claude CLI identity headers
+            proxy_headers["x-app"] = "cli"
+            proxy_headers["User-Agent"] = "claude-cli/1.0.60 (external, cli)"
+
+            # Stainless SDK compatibility headers
+            proxy_headers["X-Stainless-Lang"] = "js"
+            proxy_headers["X-Stainless-Retry-Count"] = "0"
+            proxy_headers["X-Stainless-Timeout"] = "60"
+            proxy_headers["X-Stainless-Package-Version"] = "0.55.1"
+            proxy_headers["X-Stainless-OS"] = "Linux"
+            proxy_headers["X-Stainless-Arch"] = "x64"
+            proxy_headers["X-Stainless-Runtime"] = "node"
+            proxy_headers["X-Stainless-Runtime-Version"] = "v24.3.0"
+            logger.debug("using_fallback_headers")
 
         # Standard HTTP headers for proper API interaction
         proxy_headers["accept-language"] = "*"
@@ -201,7 +362,12 @@ class HTTPRequestTransformer(RequestTransformer):
         return proxy_headers
 
     def transform_request_body(
-        self, body: bytes, path: str, proxy_mode: str = "full"
+        self,
+        body: bytes,
+        path: str,
+        proxy_mode: str = "full",
+        app_state: Any = None,
+        injection_mode: str = "minimal",
     ) -> bytes:
         """Transform request body."""
         if not body:
@@ -213,16 +379,20 @@ class HTTPRequestTransformer(RequestTransformer):
             body = self._transform_openai_to_anthropic(body)
 
         # Apply system prompt transformation for Claude Code identity
-        return self.transform_system_prompt(body)
+        return self.transform_system_prompt(body, app_state, injection_mode)
 
-    def transform_system_prompt(self, body: bytes) -> bytes:
-        """Transform system prompt to ensure Claude Code identification comes first.
+    def transform_system_prompt(
+        self, body: bytes, app_state: Any = None, injection_mode: str = "minimal"
+    ) -> bytes:
+        """Transform system prompt based on injection mode.
 
         Args:
             body: Original request body as bytes
+            app_state: Optional app state containing detection data
+            injection_mode: System prompt injection mode ('minimal' or 'full')
 
         Returns:
-            Transformed request body as bytes with Claude Code system prompt
+            Transformed request body as bytes with system prompt injection
         """
         try:
             import json
@@ -232,41 +402,43 @@ class HTTPRequestTransformer(RequestTransformer):
             # Return original if not valid JSON
             return body
 
-        # Check if request has a system prompt
-        if "system" not in data or (
-            isinstance(data["system"], str) and data["system"] == claude_code_prompt
-        ):
-            # No system prompt, inject Claude Code identification
-            data["system"] = [get_claude_code_prompt()]
-            return json.dumps(data).encode("utf-8")
-
-        system = data["system"]
-
-        if isinstance(system, str):
-            # Handle string system prompt
-            if system == claude_code_prompt:
-                # Already correct, convert to proper array format
-                data["system"] = [get_claude_code_prompt()]
-                return json.dumps(data).encode("utf-8")
-
-            # Prepend Claude Code prompt to existing string
-            data["system"] = [
-                get_claude_code_prompt(),
-                {"type": "text", "text": system},
-            ]
-
-        elif isinstance(system, list):
-            # Handle array system prompt
-            if len(system) > 0:
-                # Check if first element has correct text
-                first = system[0]
-                if isinstance(first, dict) and first.get("text") == claude_code_prompt:
-                    # Already has Claude Code first, ensure it has cache_control
-                    data["system"][0] = get_claude_code_prompt()
-                    return json.dumps(data).encode("utf-8")
-
-            # Prepend Claude Code prompt
-            data["system"] = [get_claude_code_prompt()] + system
+        # Get the system field to inject
+        detected_system = get_detected_system_field(app_state, injection_mode)
+        if detected_system is None:
+            # No detection data, use fallback
+            detected_system = get_fallback_system_field()
+
+        # Always inject the system prompt (detected or fallback)
+        if "system" not in data:
+            # No existing system prompt, inject the detected/fallback one
+            data["system"] = detected_system
+        else:
+            # Request has existing system prompt, prepend the detected/fallback one
+            existing_system = data["system"]
+
+            if isinstance(detected_system, str):
+                # Detected system is a string
+                if isinstance(existing_system, str):
+                    # Both are strings, convert to list format
+                    data["system"] = [
+                        {"type": "text", "text": detected_system},
+                        {"type": "text", "text": existing_system},
+                    ]
+                elif isinstance(existing_system, list):
+                    # Detected is string, existing is list
+                    data["system"] = [
+                        {"type": "text", "text": detected_system}
+                    ] + existing_system
+            elif isinstance(detected_system, list):
+                # Detected system is a list
+                if isinstance(existing_system, str):
+                    # Detected is list, existing is string
+                    data["system"] = detected_system + [
+                        {"type": "text", "text": existing_system}
+                    ]
+                elif isinstance(existing_system, list):
+                    # Both are lists, concatenate
+                    data["system"] = detected_system + existing_system
 
         return json.dumps(data).encode("utf-8")
 
@@ -387,6 +559,65 @@ class HTTPResponseTransformer(ResponseTransformer):
             metadata=response.metadata,
         )
 
+    async def transform_proxy_response(
+        self,
+        status_code: int,
+        headers: dict[str, str],
+        body: bytes,
+        original_path: str,
+        proxy_mode: str = "full",
+    ) -> ResponseData:
+        """Transform response using direct parameters from ProxyService.
+
+        This method provides the same functionality as ProxyService._transform_response()
+        but is properly located in the transformer layer.
+
+        Args:
+            status_code: HTTP status code
+            headers: Response headers
+            body: Response body
+            original_path: Original request path for context
+            proxy_mode: Proxy transformation mode
+
+        Returns:
+            Dictionary with transformed response data (status_code, headers, body)
+        """
+        # For error responses, handle OpenAI transformation if needed
+        if status_code >= 400:
+            transformed_error_body = body
+            if self._is_openai_request(original_path):
+                try:
+                    import json
+
+                    from ccproxy.adapters.openai.adapter import OpenAIAdapter
+
+                    error_data = json.loads(body.decode("utf-8"))
+                    openai_adapter = OpenAIAdapter()
+                    openai_error = openai_adapter.adapt_error(error_data)
+                    transformed_error_body = json.dumps(openai_error).encode("utf-8")
+                except (json.JSONDecodeError, UnicodeDecodeError):
+                    # Keep original error if parsing fails
+                    pass
+
+            return ResponseData(
+                status_code=status_code,
+                headers=headers,
+                body=transformed_error_body,
+            )
+
+        # For successful responses, transform normally
+        transformed_body = self.transform_response_body(body, original_path, proxy_mode)
+
+        transformed_headers = self.transform_response_headers(
+            headers, original_path, len(transformed_body), proxy_mode
+        )
+
+        return ResponseData(
+            status_code=status_code,
+            headers=transformed_headers,
+            body=transformed_body,
+        )
+
     def transform_response_body(
         self, body: bytes, path: str, proxy_mode: str = "full"
     ) -> bytes:
@@ -411,6 +642,7 @@ class HTTPResponseTransformer(ResponseTransformer):
                 "content-length",
                 "transfer-encoding",
                 "content-encoding",
+                "date",  # Remove upstream date header to avoid conflicts
             ]:
                 transformed_headers[key] = value
 

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: