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

ccproxy/plugins/claude_sdk/auth.py

@@ -0,0 +1,57 @@
+"""No-op auth manager for Claude SDK plugin."""
+
+from typing import Any
+
+from pydantic import SecretStr
+
+from ccproxy.auth.oauth.protocol import StandardProfileFields
+from ccproxy.plugins.oauth_claude.models import ClaudeCredentials, ClaudeOAuthToken
+
+
+class NoOpAuthManager:
+    """No-operation auth manager for Claude SDK.
+
+    The SDK handles authentication internally through the CLI,
+    so we don't need to manage auth headers.
+    """
+
+    async def get_access_token(self) -> str:
+        """Return empty token since SDK handles auth internally."""
+        return ""
+
+    async def get_credentials(self) -> ClaudeCredentials:
+        """Return dummy credentials since SDK handles auth internally."""
+        # Create minimal credentials object with OAuthToken
+
+        oauth_token = ClaudeOAuthToken(
+            accessToken=SecretStr("sdk-managed"),
+            refreshToken=SecretStr("sdk-managed"),
+            expiresAt=None,
+            scopes=[],
+            subscriptionType="sdk",
+        )
+        return ClaudeCredentials(claudeAiOauth=oauth_token)
+
+    async def is_authenticated(self) -> bool:
+        """Always return True since SDK handles auth internally."""
+        return True
+
+    async def get_user_profile(self) -> StandardProfileFields | None:
+        """Return ``None`` because the SDK does not surface profile metadata."""
+        return None
+
+    async def __aenter__(self) -> "NoOpAuthManager":
+        """Async context manager entry."""
+        return self
+
+    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
+        """No cleanup needed."""
+        pass
+
+    async def validate_credentials(self) -> bool:
+        """Always return True since SDK handles auth internally."""
+        return True
+
+    def get_provider_name(self) -> str:
+        """Get the provider name for logging."""
+        return "claude-sdk"

ccproxy/{claude_sdk → plugins/claude_sdk}/client.py

@@ -5,46 +5,47 @@ import contextlib
 from collections.abc import AsyncIterator
 from typing import Any, TypeVar, cast
 
-import structlog
 from pydantic import BaseModel
 
-from ccproxy.claude_sdk.exceptions import ClaudeSDKError, StreamTimeoutError
-from ccproxy.claude_sdk.manager import SessionManager
-from ccproxy.claude_sdk.stream_handle import StreamHandle
-from ccproxy.config.settings import Settings
 from ccproxy.core.async_utils import patched_typing
 from ccproxy.core.errors import ClaudeProxyError, ServiceUnavailableError
-from ccproxy.models import claude_sdk as sdk_models
-from ccproxy.models.claude_sdk import SDKMessage
-from ccproxy.observability import timed_operation
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.request_context import timed_operation
+
+from . import models as sdk_models
+from .config import ClaudeSDKSettings, SessionPoolSettings
+from .exceptions import ClaudeSDKError, StreamTimeoutError
+from .manager import SessionManager
+from .models import SDKMessage
+from .stream_handle import StreamHandle
 
 
 with patched_typing():
-    from claude_code_sdk import (
+    from claude_agent_sdk import (
         AssistantMessage as SDKAssistantMessage,
     )
-    from claude_code_sdk import (
-        ClaudeCodeOptions,
+    from claude_agent_sdk import (
+        ClaudeAgentOptions,
         CLIConnectionError,
         CLIJSONDecodeError,
         CLINotFoundError,
         ProcessError,
     )
-    from claude_code_sdk import (
+    from claude_agent_sdk import (
         ClaudeSDKClient as ImportedClaudeSDKClient,
     )
-    from claude_code_sdk import (
+    from claude_agent_sdk import (
         ResultMessage as SDKResultMessage,
     )
-    from claude_code_sdk import (
+    from claude_agent_sdk import (
         SystemMessage as SDKSystemMessage,
     )
-    from claude_code_sdk import (
+    from claude_agent_sdk import (
         UserMessage as SDKUserMessage,
     )
 
 
-logger = structlog.get_logger(__name__)
+logger = get_plugin_logger()
 
 T = TypeVar("T", bound=BaseModel)
 
@@ -69,17 +70,17 @@ class ClaudeSDKClient:
 
     def __init__(
         self,
-        settings: Settings | None = None,
+        config: ClaudeSDKSettings,
         session_manager: SessionManager | None = None,
     ) -> None:
         """Initialize the Claude SDK client.
 
         Args:
-            settings: Application settings for session pool configuration
+            config: Plugin-specific configuration for Claude SDK
             session_manager: Optional SessionManager instance for dependency injection
         """
         self._last_api_call_time_ms: float = 0.0
-        self._settings = settings
+        self.config = config
         self._session_manager = session_manager
 
     @contextlib.asynccontextmanager
@@ -121,6 +122,7 @@ class ClaudeSDKClient:
                 error_type=type(e).__name__,
                 operation=operation,
                 request_id=request_id,
+                exc_info=e,
             )
             raise ClaudeProxyError(
                 message=f"Unexpected error: {str(e)}",
@@ -230,14 +232,10 @@ class ClaudeSDKClient:
             return False
 
         # Check settings using safe attribute chaining
-        if not self._settings:
-            return False
-
-        claude_settings = getattr(self._settings, "claude", None)
-        if not claude_settings:
+        if not self.config:
             return False
 
-        pool_settings = getattr(claude_settings, "sdk_session_pool", None)
+        pool_settings = getattr(self.config, "sdk_session_pool", None)
         if not pool_settings:
             return False
 
@@ -246,7 +244,7 @@ class ClaudeSDKClient:
     async def query_completion(
         self,
         message: SDKMessage,
-        options: ClaudeCodeOptions,
+        options: ClaudeAgentOptions,
         request_id: str | None = None,
         session_id: str | None = None,
     ) -> StreamHandle:
@@ -278,27 +276,46 @@ class ClaudeSDKClient:
     async def _create_direct_stream_handle(
         self,
         message: SDKMessage,
-        options: ClaudeCodeOptions,
+        options: ClaudeAgentOptions,
         request_id: str | None = None,
         session_id: str | None = None,
     ) -> StreamHandle:
         """Create stream handle for direct query (no session pool)."""
         message_iterator = self._query(message, options, request_id, session_id)
 
+        # Convert core settings to plugin settings if available
+        plugin_session_config = None
+        if self.config and self.config.sdk_session_pool:
+            core_pool_settings = self.config.sdk_session_pool
+            plugin_session_config = SessionPoolSettings(
+                enabled=core_pool_settings.enabled,
+                session_ttl=core_pool_settings.session_ttl,
+                max_sessions=core_pool_settings.max_sessions,
+                cleanup_interval=getattr(core_pool_settings, "cleanup_interval", 300),
+                idle_threshold=getattr(core_pool_settings, "idle_threshold", 300),
+                connection_recovery=getattr(
+                    core_pool_settings, "connection_recovery", True
+                ),
+                stream_first_chunk_timeout=getattr(
+                    core_pool_settings, "stream_first_chunk_timeout", 8
+                ),
+                stream_ongoing_timeout=getattr(
+                    core_pool_settings, "stream_ongoing_timeout", 60
+                ),
+            )
+
         return StreamHandle(
             message_iterator=message_iterator,
             session_id=session_id,
             request_id=request_id,
             session_client=None,
-            session_config=self._settings.claude.sdk_session_pool
-            if self._settings
-            else None,  # StreamHandle will use defaults
+            session_config=plugin_session_config,  # StreamHandle will use defaults if None
         )
 
     async def _create_session_pool_stream_handle(
         self,
         message: SDKMessage,
-        options: ClaudeCodeOptions,
+        options: ClaudeAgentOptions,
         request_id: str | None = None,
         session_id: str | None = None,
     ) -> StreamHandle:
@@ -343,7 +360,7 @@ class ClaudeSDKClient:
     async def _query(
         self,
         message: SDKMessage,
-        options: ClaudeCodeOptions,
+        options: ClaudeAgentOptions,
         request_id: str | None = None,
         session_id: str | None = None,
     ) -> AsyncIterator[
@@ -380,12 +397,13 @@ class ClaudeSDKClient:
                         "claude_sdk_disconnect_failed",
                         error=str(e),
                         request_id=request_id,
+                        exc_info=e,
                     )
 
     async def _query_with_session_pool(
         self,
         message: SDKMessage,
-        options: ClaudeCodeOptions,
+        options: ClaudeAgentOptions,
         request_id: str | None = None,
         session_id: str | None = None,
     ) -> AsyncIterator[
@@ -487,10 +505,10 @@ class ClaudeSDKClient:
                     error=str(e),
                     error_type=type(e).__name__,
                     session_id=session_id,
-                    exc_info=True,
+                    exc_info=e,
                 )
                 # Fall back to direct query
-                logger.info(
+                logger.debug(
                     "claude_sdk_fallback_to_direct_query", session_id=session_id
                 )
                 async for msg in self._query(message, options, request_id, session_id):
@@ -520,7 +538,9 @@ class ClaudeSDKClient:
         """
         try:
             # Wait for the first chunk with timeout - don't care about message type
-            logger.debug("waiting_for_first_chunk", timeout=timeout_seconds)
+            logger.debug(
+                "waiting_for_first_chunk", timeout=timeout_seconds, category="streaming"
+            )
             first_message = await asyncio.wait_for(
                 anext(message_iterator), timeout=timeout_seconds
             )
@@ -556,6 +576,7 @@ class ClaudeSDKClient:
                             "failed_to_interrupt_stuck_session",
                             session_id=session_id,
                             error=str(e),
+                            exc_info=e,
                         )
 
             # Raise a custom exception with error details
@@ -627,6 +648,7 @@ class ClaudeSDKClient:
                             error=str(e),
                             request_id=request_id,
                             session_id=session_id,
+                            exc_info=e,
                         )
                     break
             else:
@@ -659,7 +681,7 @@ class ClaudeSDKClient:
 
         async def drain_stream() -> None:
             try:
-                logger.info(
+                logger.trace(
                     "claude_sdk_starting_stream_drain",
                     session_id=session_id,
                     request_id=request_id,
@@ -675,7 +697,7 @@ class ClaudeSDKClient:
                 ):
                     message_count += 1
 
-                logger.info(
+                logger.trace(
                     "claude_sdk_stream_drained",
                     session_id=session_id,
                     request_id=request_id,
@@ -688,6 +710,7 @@ class ClaudeSDKClient:
                     request_id=request_id,
                     error=str(e),
                     error_type=type(e).__name__,
+                    exc_info=e,
                 )
             finally:
                 if session_client:
@@ -749,6 +772,7 @@ class ClaudeSDKClient:
                 component="claude_sdk",
                 error=str(e),
                 error_type=type(e).__name__,
+                exc_info=e,
             )
             return False
 
@@ -763,7 +787,7 @@ class ClaudeSDKClient:
         """
         logger.debug("sdk_client_interrupt_session_started", session_id=session_id)
         if self._session_manager:
-            logger.info(
+            logger.debug(
                 "client_interrupt_session_requested",
                 session_id=session_id,
                 has_session_manager=True,

ccproxy/plugins/claude_sdk/config.py

@@ -0,0 +1,210 @@
+"""Configuration for Claude SDK plugin."""
+
+from enum import Enum
+from typing import Any
+
+from claude_agent_sdk import ClaudeAgentOptions
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from ccproxy.models.provider import ModelCard, ModelMappingRule, ProviderConfig
+from ccproxy.plugins.claude_shared.model_defaults import (
+    DEFAULT_CLAUDE_MODEL_CARDS,
+    DEFAULT_CLAUDE_MODEL_MAPPINGS,
+)
+
+
+def _create_default_claude_code_options(
+    builtin_permissions: bool = True,
+    continue_conversation: bool = False,
+) -> ClaudeAgentOptions:
+    """Create ClaudeAgentOptions with default values.
+
+    Args:
+        builtin_permissions: Whether to include built-in permission handling defaults
+    """
+    if builtin_permissions:
+        return ClaudeAgentOptions(
+            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 ClaudeAgentOptions(
+            mcp_servers={},
+            permission_prompt_tool_name=None,
+            continue_conversation=continue_conversation,
+        )
+
+
+class SDKMessageMode(str, Enum):
+    """Modes for handling SDK messages from Claude SDK.
+
+    - forward: Forward SDK content blocks directly with original types and metadata
+    - ignore: Skip SDK messages and blocks completely
+    - formatted: Format as XML tags with JSON data in text deltas
+    """
+
+    FORWARD = "forward"
+    IGNORE = "ignore"
+    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 ClaudeSDKSettings(ProviderConfig):
+    """Claude SDK specific configuration."""
+
+    # Base required fields for ProviderConfig
+    name: str = "claude_sdk"
+    base_url: str = "claude-sdk://local"  # Special URL for SDK
+    supports_streaming: bool = True
+    requires_auth: bool = False  # SDK handles auth internally
+    auth_type: str | None = None
+    model_mappings: list[ModelMappingRule] = Field(
+        default_factory=lambda: [
+            rule.model_copy(deep=True) for rule in DEFAULT_CLAUDE_MODEL_MAPPINGS
+        ]
+    )
+    models_endpoint: list[ModelCard] = Field(
+        default_factory=lambda: [
+            card.model_copy(deep=True) for card in DEFAULT_CLAUDE_MODEL_CARDS
+        ]
+    )
+
+    # Plugin lifecycle settings
+    enabled: bool = True
+    priority: int = 0
+
+    # Claude SDK specific settings
+    cli_path: str | None = None
+    builtin_permissions: bool = True
+    session_pool_enabled: bool = False
+    session_pool_size: int = 5
+    session_timeout_seconds: int = 300
+
+    # SDK behavior settings
+    include_system_messages_in_stream: bool = True
+    pretty_format: bool = True
+    sdk_message_mode: SDKMessageMode = SDKMessageMode.FORMATTED
+
+    # Performance settings
+    max_tokens_default: int = 4096
+    temperature_default: float = 0.7
+
+    # Additional fields from ClaudeSettings to prevent validation errors
+    # Use Any to avoid Pydantic schema generation on external TypedDicts (Py<3.12)
+    code_options: Any | None = None
+    system_prompt_injection_mode: SystemPromptInjectionMode = (
+        SystemPromptInjectionMode.MINIMAL
+    )
+    sdk_session_pool: SessionPoolSettings | None = None
+
+    # Default session configuration
+    default_session_id: str | None = Field(
+        default=None,
+        description="Default session ID to use when none is provided. "
+        "Useful for single-user setups or development environments.",
+    )
+    auto_generate_default_session: bool = Field(
+        default=False,
+        description="Automatically generate a random default session ID at startup. "
+        "Overrides default_session_id if enabled. Useful for single-user "
+        "setups where you want session persistence during runtime.",
+    )
+
+    @model_validator(mode="after")
+    def ensure_session_pool_settings(self) -> "ClaudeSDKSettings":
+        """Ensure sdk_session_pool is initialized."""
+        if self.sdk_session_pool is None:
+            self.sdk_session_pool = SessionPoolSettings()
+        return self
+
+    model_config = ConfigDict(extra="allow")

ccproxy/{claude_sdk → plugins/claude_sdk}/converter.py

@@ -5,15 +5,15 @@ import json
 from collections.abc import Callable
 from typing import Any
 
-import structlog
-
-from ccproxy.config.claude import SDKMessageMode
 from ccproxy.core.async_utils import patched_typing
-from ccproxy.models import claude_sdk as sdk_models
-from ccproxy.models.messages import MessageResponse
+from ccproxy.core.logging import get_plugin_logger
+
+from . import models as sdk_models
+from .config import SDKMessageMode
+from .models import MessageResponse
 
 
-logger = structlog.get_logger(__name__)
+logger = get_plugin_logger()
 
 with patched_typing():
     pass