ccproxy-api 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

ccproxy/core/errors.py

@@ -1,6 +1,6 @@
 """Core error types for the proxy system."""
 
-from typing import Any, Optional
+from typing import Any
 
 from fastapi import HTTPException
 
@@ -234,6 +234,45 @@ class DockerError(ClaudeProxyError):
         )
 
 
+class PermissionRequestError(ClaudeProxyError):
+    """Base exception for permission request-related errors."""
+
+    pass
+
+
+class PermissionNotFoundError(PermissionRequestError):
+    """Raised when permission request is not found."""
+
+    def __init__(self, confirmation_id: str) -> None:
+        super().__init__(
+            message=f"Permission request '{confirmation_id}' not found",
+            error_type="not_found_error",
+            status_code=404,
+        )
+
+
+class PermissionExpiredError(PermissionRequestError):
+    """Raised when permission request has expired."""
+
+    def __init__(self, confirmation_id: str) -> None:
+        super().__init__(
+            message=f"Permission request '{confirmation_id}' has expired",
+            error_type="expired_error",
+            status_code=410,
+        )
+
+
+class PermissionAlreadyResolvedError(PermissionRequestError):
+    """Raised when trying to resolve an already resolved request."""
+
+    def __init__(self, confirmation_id: str, status: str) -> None:
+        super().__init__(
+            message=f"Permission request '{confirmation_id}' already resolved with status: {status}",
+            error_type="conflict_error",
+            status_code=409,
+        )
+
+
 __all__ = [
     # Core proxy errors
     "ProxyError",
@@ -253,4 +292,9 @@ __all__ = [
     "TimeoutError",
     "ServiceUnavailableError",
     "DockerError",
+    # Permission errors
+    "PermissionRequestError",
+    "PermissionNotFoundError",
+    "PermissionExpiredError",
+    "PermissionAlreadyResolvedError",
 ]

ccproxy/core/http_transformers.py

@@ -1,6 +1,5 @@
 """HTTP-level transformers for proxy service."""
 
-import json
 from typing import TYPE_CHECKING, Any
 
 import structlog
@@ -18,6 +17,8 @@ logger = structlog.get_logger(__name__)
 # Claude Code system prompt constants
 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."""
@@ -179,7 +180,7 @@ class HTTPRequestTransformer(RequestTransformer):
 
         # Claude CLI identity headers
         proxy_headers["x-app"] = "cli"
-        proxy_headers["User-Agent"] = "claude-cli/1.0.43 (external, cli)"
+        proxy_headers["User-Agent"] = "claude-cli/1.0.60 (external, cli)"
 
         # Stainless SDK compatibility headers
         proxy_headers["X-Stainless-Lang"] = "js"
@@ -189,7 +190,7 @@ class HTTPRequestTransformer(RequestTransformer):
         proxy_headers["X-Stainless-OS"] = "Linux"
         proxy_headers["X-Stainless-Arch"] = "x64"
         proxy_headers["X-Stainless-Runtime"] = "node"
-        proxy_headers["X-Stainless-Runtime-Version"] = "v22.14.0"
+        proxy_headers["X-Stainless-Runtime-Version"] = "v24.3.0"
 
         # Standard HTTP headers for proper API interaction
         proxy_headers["accept-language"] = "*"

ccproxy/core/interfaces.py

@@ -6,10 +6,10 @@ providing a single location for defining contracts and protocols.
 
 from abc import ABC, abstractmethod
 from collections.abc import AsyncIterator
-from typing import Any, Optional, Protocol, TypeVar, runtime_checkable
+from typing import Any, Protocol, TypeVar, runtime_checkable
 
 from ccproxy.auth.models import ClaudeCredentials
-from ccproxy.core.types import ProxyRequest, ProxyResponse, TransformContext
+from ccproxy.core.types import TransformContext
 
 
 __all__ = [

ccproxy/core/logging.py

@@ -1,45 +1,25 @@
 import logging
 import sys
-from collections.abc import MutableMapping
-from typing import Any
+from pathlib import Path
 
 import structlog
 from structlog.stdlib import BoundLogger
 from structlog.typing import Processor
 
 
-def configure_structlog(json_logs: bool = False, log_level: str = "INFO") -> None:
-    """Configure structlog with your preferred processors."""
-    # Use different timestamp format based on log level
-    # Dev mode (DEBUG): only hours without microseconds
-    # Info mode: full date without microseconds
-    if log_level.upper() == "DEBUG":
-        timestamper = structlog.processors.TimeStamper(fmt="%H:%M:%S")
-    else:
-        timestamper = structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S")
-
-    # Processors that will be used for structlog loggers
+def configure_structlog(log_level: int = logging.INFO) -> None:
+    """Configure structlog with shared processors following canonical pattern."""
+    # Shared processors for all structlog loggers
     processors: list[Processor] = [
+        structlog.contextvars.merge_contextvars,  # For request context in web apps
         structlog.stdlib.filter_by_level,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
     ]
 
-    # Only add logger name if NOT in INFO mode
-    if log_level.upper() != "INFO":
-        processors.append(structlog.stdlib.add_logger_name)
-
-    processors.extend(
-        [
-            structlog.stdlib.add_log_level,
-            structlog.stdlib.PositionalArgumentsFormatter(),
-            timestamper,
-            structlog.processors.StackInfoRenderer(),
-            structlog.processors.format_exc_info,
-            structlog.processors.UnicodeDecoder(),
-        ]
-    )
-
-    # Only add CallsiteParameterAdder if NOT in INFO mode
-    if log_level.upper() != "INFO":
+    # Add debug-specific processors
+    if log_level < logging.INFO:
+        # Dev mode (DEBUG): add callsite information
         processors.append(
             structlog.processors.CallsiteParameterAdder(
                 parameters=[
@@ -49,92 +29,115 @@ def configure_structlog(json_logs: bool = False, log_level: str = "INFO") -> Non
             )
         )
 
-    # This wrapper passes the event dictionary to the ProcessorFormatter
-    # so we don't double-render
-    processors.append(structlog.stdlib.ProcessorFormatter.wrap_for_formatter)
+    # Common processors for all log levels
+    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"
+            ),
+            structlog.processors.StackInfoRenderer(),
+            structlog.dev.set_exc_info,  # Handle exceptions properly
+            # This MUST be the last processor - allows different renderers per handler
+            structlog.stdlib.ProcessorFormatter.wrap_for_formatter,
+        ]
+    )
 
     structlog.configure(
         processors=processors,
         context_class=dict,
         logger_factory=structlog.stdlib.LoggerFactory(),
         wrapper_class=structlog.stdlib.BoundLogger,
-        cache_logger_on_first_use=False,  # Don't cache to allow reconfiguration
+        cache_logger_on_first_use=True,  # Cache for performance
     )
 
 
 def setup_logging(
-    json_logs: bool = False, log_level: str = "INFO", 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 including uvicorn and fastapi.
+    Setup logging for the entire application using canonical structlog pattern.
     Returns a structlog logger instance.
     """
-    # Set the log level for the root logger first so structlog can see it
+    log_level = getattr(logging, log_level_name.upper(), logging.INFO)
+
+    # Get root logger and set level BEFORE configuring structlog
     root_logger = logging.getLogger()
-    root_logger.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+    root_logger.setLevel(log_level)
 
-    # Configure structlog after setting the log level
-    configure_structlog(json_logs=json_logs, log_level=log_level)
+    # 1. Configure structlog with shared processors
+    configure_structlog(log_level=log_level)
 
-    # Create a handler that will format stdlib logs through structlog
-    handler = logging.StreamHandler(sys.stdout)
-    handler.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+    # 2. Setup root logger handlers
+    root_logger.handlers = []  # Clear any existing handlers
 
-    # Use the appropriate renderer based on json_logs setting
-    renderer = (
-        structlog.processors.JSONRenderer()
-        if json_logs
-        else structlog.dev.ConsoleRenderer()
-    )
+    # 3. Create shared processors for foreign (stdlib) logs
+    shared_processors = [
+        structlog.contextvars.merge_contextvars,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.add_logger_name,
+        structlog.dev.set_exc_info,
+    ]
 
-    # Use ProcessorFormatter to handle both structlog and stdlib logs
-    # Use the same timestamp format for foreign logs
-    if log_level.upper() == "DEBUG":
-        foreign_timestamper = structlog.processors.TimeStamper(fmt="%H:%M:%S")
-    else:
-        foreign_timestamper = structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S")
+    # Add debug processors if needed
+    if log_level < logging.INFO:
+        shared_processors.append(
+            structlog.processors.CallsiteParameterAdder(  # type: ignore[arg-type]
+                parameters=[
+                    structlog.processors.CallsiteParameter.FILENAME,
+                    structlog.processors.CallsiteParameter.LINENO,
+                ]
+            )
+        )
 
-    # Build foreign_pre_chain conditionally
-    foreign_pre_chain: list[Processor] = [structlog.stdlib.add_log_level]
+    # Add appropriate timestamper for console vs file
+    console_timestamper = (
+        structlog.processors.TimeStamper(fmt="%H:%M:%S")
+        if log_level < logging.INFO
+        else structlog.processors.TimeStamper(fmt="%Y-%m-%d %H:%M:%S")
+    )
 
-    # Only add logger name if NOT in INFO mode
-    if log_level.upper() != "INFO":
-        foreign_pre_chain.append(structlog.stdlib.add_logger_name)
+    file_timestamper = structlog.processors.TimeStamper(fmt="iso")
 
-    foreign_pre_chain.append(foreign_timestamper)
+    # 4. Setup console handler with ConsoleRenderer
+    console_handler = logging.StreamHandler(sys.stdout)
+    console_handler.setLevel(log_level)
+    console_renderer = (
+        structlog.processors.JSONRenderer()
+        if json_logs
+        else structlog.dev.ConsoleRenderer()
+    )
 
-    handler.setFormatter(
+    # Console gets human-readable timestamps for both structlog and stdlib logs
+    console_processors = shared_processors + [console_timestamper]
+    console_handler.setFormatter(
         structlog.stdlib.ProcessorFormatter(
-            processor=renderer,
-            foreign_pre_chain=foreign_pre_chain,
+            foreign_pre_chain=console_processors,
+            processor=console_renderer,
         )
     )
+    root_logger.addHandler(console_handler)
 
-    # Configure root logger (level already set above)
-    handlers: list[logging.Handler] = [handler]
-
-    # Add file handler if log_file is specified
+    # 5. Setup file handler with JSONRenderer (if log_file provided)
     if log_file:
-        from pathlib import Path
-
         # Ensure parent directory exists
         log_path = Path(log_file)
         log_path.parent.mkdir(parents=True, exist_ok=True)
 
-        # Create a file handler that always outputs JSON
-        file_handler = logging.FileHandler(log_file, encoding="utf-8")
-        file_handler.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+        file_handler = logging.FileHandler(log_file, encoding="utf-8", delay=True)
+        file_handler.setLevel(log_level)
+
+        # File gets ISO timestamps for both structlog and stdlib logs
+        file_processors = shared_processors + [file_timestamper]
         file_handler.setFormatter(
             structlog.stdlib.ProcessorFormatter(
+                foreign_pre_chain=file_processors,
                 processor=structlog.processors.JSONRenderer(),
-                foreign_pre_chain=foreign_pre_chain,
             )
         )
-        handlers.append(file_handler)
+        root_logger.addHandler(file_handler)
 
-    root_logger.handlers = handlers
-
-    # Make sure uvicorn and fastapi loggers use our configuration
+    # 6. Configure stdlib loggers to propagate to our handlers
     for logger_name in [
         "uvicorn",
         "uvicorn.access",
@@ -146,27 +149,23 @@ def setup_logging(
         logger.handlers = []  # Remove default handlers
         logger.propagate = True  # Use root logger's handlers
 
-        # Set uvicorn loggers to WARNING when app log level is INFO to reduce noise
-        if logger_name.startswith("uvicorn") and log_level.upper() == "INFO":
+        # In DEBUG mode, let all logs through at DEBUG level
+        # Otherwise, reduce uvicorn noise by setting to WARNING
+        if log_level == logging.DEBUG:
+            logger.setLevel(logging.DEBUG)
+        elif logger_name.startswith("uvicorn"):
             logger.setLevel(logging.WARNING)
         else:
-            logger.setLevel(getattr(logging, log_level.upper(), logging.INFO))
+            logger.setLevel(log_level)
 
     # Configure httpx logger separately - INFO when app is DEBUG, WARNING otherwise
     httpx_logger = logging.getLogger("httpx")
-    httpx_logger.handlers = []  # Remove default handlers
-    httpx_logger.propagate = True  # Use root logger's handlers
-    if log_level.upper() == "DEBUG":
-        httpx_logger.setLevel(logging.INFO)
-    else:
-        httpx_logger.setLevel(logging.WARNING)
-
-    # Set noisy HTTP-related loggers to WARNING when app log level >= WARNING, else use app log level
-    app_log_level = getattr(logging, log_level.upper(), logging.INFO)
-    noisy_log_level = (
-        logging.WARNING if app_log_level <= logging.WARNING else app_log_level
-    )
+    httpx_logger.handlers = []
+    httpx_logger.propagate = True
+    httpx_logger.setLevel(logging.INFO if log_level < logging.INFO else logging.WARNING)
 
+    # Set noisy HTTP-related loggers to WARNING
+    noisy_log_level = logging.WARNING if log_level <= logging.WARNING else log_level
     for noisy_logger_name in [
         "urllib3",
         "urllib3.connectionpool",
@@ -174,10 +173,13 @@ def setup_logging(
         "aiohttp",
         "httpcore",
         "httpcore.http11",
+        "fastapi_mcp",
+        "sse_starlette",
+        "mcp",
     ]:
         noisy_logger = logging.getLogger(noisy_logger_name)
-        noisy_logger.handlers = []  # Remove default handlers
-        noisy_logger.propagate = True  # Use root logger's handlers
+        noisy_logger.handlers = []
+        noisy_logger.propagate = True
         noisy_logger.setLevel(noisy_log_level)
 
     return structlog.get_logger()  # type: ignore[no-any-return]

ccproxy/core/middleware.py

@@ -2,7 +2,7 @@
 
 from abc import ABC, abstractmethod
 from collections.abc import Awaitable, Callable
-from typing import Any, Optional, Protocol, runtime_checkable
+from typing import Protocol, runtime_checkable
 
 from ccproxy.core.types import ProxyRequest, ProxyResponse
 

ccproxy/core/proxy.py

@@ -1,7 +1,7 @@
 """Core proxy abstractions for handling HTTP and WebSocket connections."""
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Optional, Protocol, runtime_checkable
+from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
 from ccproxy.core.types import ProxyRequest, ProxyResponse
 

ccproxy/core/transformers.py

@@ -1,7 +1,7 @@
 """Core transformer abstractions for request/response transformation."""
 
 from abc import ABC, abstractmethod
-from typing import TYPE_CHECKING, Any, Optional, Protocol, TypeVar, runtime_checkable
+from typing import TYPE_CHECKING, Any, Protocol, TypeVar, runtime_checkable
 
 from structlog import get_logger
 

ccproxy/core/types.py

@@ -2,7 +2,7 @@
 
 from dataclasses import dataclass, field
 from enum import Enum
-from typing import Any, Optional, Union
+from typing import Any
 
 from pydantic import BaseModel, ConfigDict, Field
 

ccproxy/docker/models.py

@@ -3,7 +3,7 @@
 import os
 import platform
 from pathlib import Path
-from typing import ClassVar, Literal
+from typing import ClassVar
 
 from pydantic import BaseModel, Field, field_validator
 

ccproxy/docker/protocol.py

@@ -3,11 +3,8 @@
 from collections.abc import Awaitable
 from pathlib import Path
 from typing import (
-    TYPE_CHECKING,
-    Any,
     Protocol,
     TypeAlias,
-    TypeVar,
     runtime_checkable,
 )
 

ccproxy/models/__init__.py

@@ -1,5 +1,26 @@
 """Pydantic models for Claude Proxy API Server."""
 
+from .claude_sdk import (
+    AssistantMessage,
+    ContentBlock,
+    ExtendedContentBlock,
+    ResultMessage,
+    ResultMessageBlock,
+    SDKContentBlock,
+    SDKMessageMode,
+    TextBlock,
+    ToolResultBlock,
+    ToolResultSDKBlock,
+    ToolUseBlock,
+    ToolUseSDKBlock,
+    UserMessage,
+    convert_sdk_result_message,
+    convert_sdk_system_message,
+    convert_sdk_text_block,
+    convert_sdk_tool_result_block,
+    convert_sdk_tool_use_block,
+    to_sdk_variant,
+)
 from .messages import (
     MessageContentBlock,
     MessageCreateParams,
@@ -67,6 +88,26 @@ __all__ = [
     "StreamEventType",
     "ToolChoiceType",
     "ToolType",
+    # Claude SDK models
+    "AssistantMessage",
+    "ContentBlock",
+    "ExtendedContentBlock",
+    "ResultMessage",
+    "ResultMessageBlock",
+    "SDKContentBlock",
+    "SDKMessageMode",
+    "TextBlock",
+    "ToolResultBlock",
+    "ToolResultSDKBlock",
+    "ToolUseBlock",
+    "ToolUseSDKBlock",
+    "UserMessage",
+    "convert_sdk_result_message",
+    "convert_sdk_system_message",
+    "convert_sdk_text_block",
+    "convert_sdk_tool_result_block",
+    "convert_sdk_tool_use_block",
+    "to_sdk_variant",
     # Message models
     "MessageContentBlock",
     "MessageCreateParams",