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

ccproxy/config/__init__.py

@@ -2,7 +2,6 @@
 
 from .auth import AuthSettings, CredentialStorageSettings, OAuthSettings
 from .docker_settings import DockerSettings
-from .loader import ConfigLoader, load_config
 from .reverse_proxy import ReverseProxySettings
 from .settings import Settings, get_settings
 from .validators import (
@@ -26,8 +25,6 @@ __all__ = [
     "CredentialStorageSettings",
     "ReverseProxySettings",
     "DockerSettings",
-    "ConfigLoader",
-    "load_config",
     "ConfigValidationError",
     "validate_config_dict",
     "validate_cors_origins",

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 defaults.mcp_servers
+                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/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

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

ccproxy/config/settings.py

@@ -462,10 +462,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 [