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

ccproxy/config/claude.py

@@ -7,7 +7,7 @@ from pathlib import Path
 from typing import Any
 
 import structlog
-from pydantic import BaseModel, Field, field_validator
+from pydantic import BaseModel, Field, field_validator, model_validator
 
 from ccproxy.core.async_utils import get_package_dir, patched_typing
 
@@ -19,14 +19,29 @@ with patched_typing():
 logger = structlog.get_logger(__name__)
 
 
-def _create_default_claude_code_options() -> ClaudeCodeOptions:
-    """Create ClaudeCodeOptions with default values."""
-    return ClaudeCodeOptions(
-        mcp_servers={
-            "confirmation": {"type": "sse", "url": "http://127.0.0.1:8000/mcp"}
-        },
-        permission_prompt_tool_name="mcp__confirmation__check_permission",
-    )
+def _create_default_claude_code_options(
+    builtin_permissions: bool = True,
+    continue_conversation: bool = False,
+) -> ClaudeCodeOptions:
+    """Create ClaudeCodeOptions with default values.
+
+    Args:
+        builtin_permissions: Whether to include built-in permission handling defaults
+    """
+    if builtin_permissions:
+        return ClaudeCodeOptions(
+            continue_conversation=continue_conversation,
+            mcp_servers={
+                "confirmation": {"type": "sse", "url": "http://127.0.0.1:8000/mcp"}
+            },
+            permission_prompt_tool_name="mcp__confirmation__check_permission",
+        )
+    else:
+        return ClaudeCodeOptions(
+            mcp_servers={},
+            permission_prompt_tool_name=None,
+            continue_conversation=continue_conversation,
+        )
 
 
 class SDKMessageMode(str, Enum):
@@ -42,6 +57,94 @@ class SDKMessageMode(str, Enum):
     FORMATTED = "formatted"
 
 
+class SystemPromptInjectionMode(str, Enum):
+    """Modes for system prompt injection.
+
+    - minimal: Only inject Claude Code identification prompt
+    - full: Inject all detected system messages from Claude CLI
+    """
+
+    MINIMAL = "minimal"
+    FULL = "full"
+
+
+class SessionPoolSettings(BaseModel):
+    """Session pool configuration settings."""
+
+    enabled: bool = Field(
+        default=True, description="Enable session-aware persistent pooling"
+    )
+
+    session_ttl: int = Field(
+        default=3600,
+        ge=60,
+        le=86400,
+        description="Session time-to-live in seconds (1 minute to 24 hours)",
+    )
+
+    max_sessions: int = Field(
+        default=1000,
+        ge=1,
+        le=10000,
+        description="Maximum number of concurrent sessions",
+    )
+
+    cleanup_interval: int = Field(
+        default=300,
+        ge=30,
+        le=3600,
+        description="Session cleanup interval in seconds (30 seconds to 1 hour)",
+    )
+
+    idle_threshold: int = Field(
+        default=600,
+        ge=60,
+        le=7200,
+        description="Session idle threshold in seconds (1 minute to 2 hours)",
+    )
+
+    connection_recovery: bool = Field(
+        default=True,
+        description="Enable automatic connection recovery for unhealthy sessions",
+    )
+
+    stream_first_chunk_timeout: int = Field(
+        default=3,
+        ge=1,
+        le=30,
+        description="Stream first chunk timeout in seconds (1-30 seconds)",
+    )
+
+    stream_ongoing_timeout: int = Field(
+        default=60,
+        ge=10,
+        le=600,
+        description="Stream ongoing timeout in seconds after first chunk (10 seconds to 10 minutes)",
+    )
+
+    stream_interrupt_timeout: int = Field(
+        default=10,
+        ge=2,
+        le=60,
+        description="Stream interrupt timeout in seconds for SDK and worker operations (2-60 seconds)",
+    )
+
+    @model_validator(mode="after")
+    def validate_timeout_hierarchy(self) -> "SessionPoolSettings":
+        """Ensure stream timeouts are less than session TTL."""
+        if self.stream_ongoing_timeout >= self.session_ttl:
+            raise ValueError(
+                f"stream_ongoing_timeout ({self.stream_ongoing_timeout}s) must be less than session_ttl ({self.session_ttl}s)"
+            )
+
+        if self.stream_first_chunk_timeout >= self.stream_ongoing_timeout:
+            raise ValueError(
+                f"stream_first_chunk_timeout ({self.stream_first_chunk_timeout}s) must be less than stream_ongoing_timeout ({self.stream_ongoing_timeout}s)"
+            )
+
+        return self
+
+
 class ClaudeSettings(BaseModel):
     """Claude-specific configuration settings."""
 
@@ -50,8 +153,13 @@ class ClaudeSettings(BaseModel):
         description="Path to Claude CLI executable",
     )
 
-    code_options: ClaudeCodeOptions = Field(
-        default_factory=_create_default_claude_code_options,
+    builtin_permissions: bool = Field(
+        default=True,
+        description="Whether to enable built-in permission handling infrastructure (MCP server and SSE endpoints). When disabled, users can still configure custom MCP servers and permission tools.",
+    )
+
+    code_options: ClaudeCodeOptions | None = Field(
+        default=None,
         description="Claude Code SDK options configuration",
     )
 
@@ -60,11 +168,21 @@ class ClaudeSettings(BaseModel):
         description="Mode for handling SDK messages from Claude SDK. Options: forward (direct SDK blocks), ignore (skip blocks), formatted (XML tags with JSON data)",
     )
 
+    system_prompt_injection_mode: SystemPromptInjectionMode = Field(
+        default=SystemPromptInjectionMode.MINIMAL,
+        description="Mode for system prompt injection. Options: minimal (Claude Code ID only), full (all detected system messages)",
+    )
+
     pretty_format: bool = Field(
         default=True,
         description="Whether to use pretty formatting (indented JSON, newlines after XML tags, unescaped content). When false: compact JSON, no newlines, escaped content between XML tags",
     )
 
+    sdk_session_pool: SessionPoolSettings = Field(
+        default_factory=SessionPoolSettings,
+        description="Configuration settings for session-aware SDK client pooling",
+    )
+
     @field_validator("cli_path")
     @classmethod
     def validate_claude_cli_path(cls, v: str | None) -> str | None:
@@ -81,11 +199,16 @@ class ClaudeSettings(BaseModel):
 
     @field_validator("code_options", mode="before")
     @classmethod
-    def validate_claude_code_options(cls, v: Any) -> Any:
+    def validate_claude_code_options(cls, v: Any, info: Any) -> Any:
         """Validate and convert Claude Code options."""
+        # Get builtin_permissions setting from the model data
+        builtin_permissions = True  # default
+        if info.data and "builtin_permissions" in info.data:
+            builtin_permissions = info.data["builtin_permissions"]
+
         if v is None:
-            # Create instance with default values (same as default_factory)
-            return _create_default_claude_code_options()
+            # Create instance with default values based on builtin_permissions
+            return _create_default_claude_code_options(builtin_permissions)
 
         # If it's already a ClaudeCodeOptions instance, return as-is
         if isinstance(v, ClaudeCodeOptions):
@@ -93,16 +216,18 @@ class ClaudeSettings(BaseModel):
 
         # If it's an empty dict, treat it like None and use defaults
         if isinstance(v, dict) and not v:
-            return _create_default_claude_code_options()
+            return _create_default_claude_code_options(builtin_permissions)
 
         # For non-empty dicts, merge with defaults instead of replacing them
         if isinstance(v, dict):
-            # Start with default values
-            defaults = _create_default_claude_code_options()
+            # Start with default values based on builtin_permissions
+            defaults = _create_default_claude_code_options(builtin_permissions)
 
             # Extract default values as a dict for merging
             default_values = {
-                "mcp_servers": defaults.mcp_servers.copy(),
+                "mcp_servers": dict(defaults.mcp_servers)
+                if isinstance(defaults.mcp_servers, dict)
+                else {},
                 "permission_prompt_tool_name": defaults.permission_prompt_tool_name,
             }
 
@@ -124,18 +249,41 @@ class ClaudeSettings(BaseModel):
                     if default_value is not None:
                         default_values[attr] = default_value
 
+            # Handle MCP server merging when builtin_permissions is enabled
+            if builtin_permissions and "mcp_servers" in v:
+                user_mcp_servers = v["mcp_servers"]
+                if isinstance(user_mcp_servers, dict):
+                    # Merge user MCP servers with built-in ones (user takes precedence)
+                    default_mcp = default_values["mcp_servers"]
+                    if isinstance(default_mcp, dict):
+                        merged_mcp_servers = {
+                            **default_mcp,
+                            **user_mcp_servers,
+                        }
+                        v = {**v, "mcp_servers": merged_mcp_servers}
+
             # Merge CLI overrides with defaults (CLI overrides take precedence)
             merged_values = {**default_values, **v}
 
             return ClaudeCodeOptions(**merged_values)
 
-        # Try to convert to dict if possible
+        # Try to convert to ClaudeCodeOptions if possible
         if hasattr(v, "model_dump"):
-            return v.model_dump()
+            return ClaudeCodeOptions(**v.model_dump())
         elif hasattr(v, "__dict__"):
-            return v.__dict__
-
-        return v
+            return ClaudeCodeOptions(**v.__dict__)
+
+        # Fallback: use default values
+        return _create_default_claude_code_options(builtin_permissions)
+
+    @model_validator(mode="after")
+    def validate_code_options_after(self) -> "ClaudeSettings":
+        """Ensure code_options is properly initialized after field validation."""
+        if self.code_options is None:
+            self.code_options = _create_default_claude_code_options(
+                self.builtin_permissions
+            )
+        return self
 
     def find_claude_cli(self) -> tuple[str | None, bool]:
         """Find Claude CLI executable in PATH or specified location.

ccproxy/config/codex.py

@@ -0,0 +1,100 @@
+"""OpenAI Codex-specific configuration settings."""
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class OAuthSettings(BaseModel):
+    """OAuth configuration for OpenAI authentication."""
+
+    base_url: str = Field(
+        default="https://auth.openai.com",
+        description="OpenAI OAuth base URL",
+    )
+
+    client_id: str = Field(
+        default="app_EMoamEEZ73f0CkXaXp7hrann",
+        description="OpenAI OAuth client ID",
+    )
+
+    scopes: list[str] = Field(
+        default_factory=lambda: ["openid", "profile", "email", "offline_access"],
+        description="OAuth scopes to request",
+    )
+
+    @field_validator("base_url")
+    @classmethod
+    def validate_base_url(cls, v: str) -> str:
+        """Validate OAuth base URL format."""
+        if not v.startswith(("http://", "https://")):
+            raise ValueError("OAuth base URL must start with http:// or https://")
+        return v.rstrip("/")
+
+
+class CodexSettings(BaseModel):
+    """OpenAI Codex-specific configuration settings."""
+
+    enabled: bool = Field(
+        default=True,
+        description="Enable OpenAI Codex provider support",
+    )
+
+    base_url: str = Field(
+        default="https://chatgpt.com/backend-api/codex",
+        description="OpenAI Codex API base URL",
+    )
+
+    oauth: OAuthSettings = Field(
+        default_factory=OAuthSettings,
+        description="OAuth configuration settings",
+    )
+
+    callback_port: int = Field(
+        default=1455,
+        ge=1024,
+        le=65535,
+        description="Port for OAuth callback server (1024-65535)",
+    )
+
+    redirect_uri: str = Field(
+        default="http://localhost:1455/auth/callback",
+        description="OAuth redirect URI (auto-generated from callback_port if not set)",
+    )
+
+    verbose_logging: bool = Field(
+        default=False,
+        description="Enable verbose logging for Codex operations",
+    )
+
+    @field_validator("base_url")
+    @classmethod
+    def validate_base_url(cls, v: str) -> str:
+        """Validate Codex base URL format."""
+        if not v.startswith(("http://", "https://")):
+            raise ValueError("Codex base URL must start with http:// or https://")
+        return v.rstrip("/")
+
+    @field_validator("redirect_uri")
+    @classmethod
+    def validate_redirect_uri(cls, v: str) -> str:
+        """Validate redirect URI format."""
+        if not v.startswith(("http://", "https://")):
+            raise ValueError("Redirect URI must start with http:// or https://")
+        return v
+
+    @field_validator("callback_port")
+    @classmethod
+    def validate_callback_port(cls, v: int) -> int:
+        """Validate callback port range."""
+        if not (1024 <= v <= 65535):
+            raise ValueError("Callback port must be between 1024 and 65535")
+        return v
+
+    def get_redirect_uri(self) -> str:
+        """Get the redirect URI, auto-generating if needed."""
+        if (
+            self.redirect_uri
+            and self.redirect_uri
+            != f"http://localhost:{self.callback_port}/auth/callback"
+        ):
+            return self.redirect_uri
+        return f"http://localhost:{self.callback_port}/auth/callback"

ccproxy/config/discovery.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-from ccproxy.core.system import get_xdg_config_home
+from ccproxy.core.system import get_xdg_cache_home, get_xdg_config_home
 
 
 def find_toml_config_file() -> Path | None:
@@ -84,3 +84,12 @@ def get_claude_docker_home_dir() -> Path:
         Path to the Claude Docker home directory within XDG_DATA_HOME.
     """
     return get_ccproxy_config_dir() / "home"
+
+
+def get_ccproxy_cache_dir() -> Path:
+    """Get the ccproxy cache directory.
+
+    Returns:
+        Path to the ccproxy cache directory within XDG_CACHE_HOME.
+    """
+    return get_xdg_cache_home() / "ccproxy"

ccproxy/config/scheduler.py

@@ -35,7 +35,7 @@ class SchedulerSettings(BaseSettings):
     # Pricing updater task settings
     pricing_update_enabled: bool = Field(
         default=True,
-        description="Whether pricing cache update task is enabled",
+        description="Whether pricing cache update task is enabled. Enabled by default for privacy - downloads from GitHub when enabled",
     )
 
     pricing_update_interval_hours: int = Field(
@@ -85,7 +85,7 @@ class SchedulerSettings(BaseSettings):
     # Version checking task settings
     version_check_enabled: bool = Field(
         default=True,
-        description="Whether version update checking is enabled",
+        description="Whether version update checking is enabled. Enabled by default for privacy - checks GitHub API when enabled",
     )
 
     version_check_interval_hours: int = Field(

ccproxy/config/settings.py

@@ -15,6 +15,7 @@ from ccproxy.config.discovery import find_toml_config_file
 
 from .auth import AuthSettings
 from .claude import ClaudeSettings
+from .codex import CodexSettings
 from .cors import CORSSettings
 from .docker_settings import DockerSettings
 from .observability import ObservabilitySettings
@@ -85,6 +86,12 @@ class Settings(BaseSettings):
         description="Claude-specific configuration settings",
     )
 
+    # Codex-specific settings
+    codex: CodexSettings = Field(
+        default_factory=CodexSettings,
+        description="OpenAI Codex-specific configuration settings",
+    )
+
     # Proxy and authentication
     reverse_proxy: ReverseProxySettings = Field(
         default_factory=ReverseProxySettings,
@@ -168,6 +175,18 @@ class Settings(BaseSettings):
             return ClaudeSettings(**v)
         return v
 
+    @field_validator("codex", mode="before")
+    @classmethod
+    def validate_codex(cls, v: Any) -> Any:
+        """Validate and convert Codex settings."""
+        if v is None:
+            return CodexSettings()
+        if isinstance(v, CodexSettings):
+            return v
+        if isinstance(v, dict):
+            return CodexSettings(**v)
+        return v
+
     @field_validator("reverse_proxy", mode="before")
     @classmethod
     def validate_reverse_proxy(cls, v: Any) -> Any:
@@ -462,10 +481,28 @@ class ConfigurationManager:
             claude_settings["cli_path"] = cli_args["claude_cli_path"]
 
         # Direct Claude settings (not nested in code_options)
-        for key in ["sdk_message_mode"]:
+        for key in [
+            "sdk_message_mode",
+            "system_prompt_injection_mode",
+            "builtin_permissions",
+        ]:
             if cli_args.get(key) is not None:
                 claude_settings[key] = cli_args[key]
 
+        # Handle pool configuration
+        if cli_args.get("sdk_pool") is not None:
+            claude_settings["sdk_pool"] = {"enabled": cli_args["sdk_pool"]}
+
+        if cli_args.get("sdk_pool_size") is not None:
+            if "sdk_pool" not in claude_settings:
+                claude_settings["sdk_pool"] = {}
+            claude_settings["sdk_pool"]["pool_size"] = cli_args["sdk_pool_size"]
+
+        if cli_args.get("sdk_session_pool") is not None:
+            claude_settings["sdk_session_pool"] = {
+                "enabled": cli_args["sdk_session_pool"]
+            }
+
         # Claude Code options
         claude_opts = {}
         for key in [