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

ccproxy/plugins/claude_sdk/options.py

@@ -0,0 +1,154 @@
+"""Options handling for Claude SDK interactions."""
+
+from typing import Any
+
+from claude_agent_sdk import ClaudeAgentOptions
+
+from .config import ClaudeSDKSettings
+
+
+class OptionsHandler:
+    """
+    Handles creation and management of Claude SDK options.
+    """
+
+    def __init__(self, config: ClaudeSDKSettings) -> None:
+        """
+        Initialize options handler.
+
+        Args:
+            config: Plugin-specific configuration for Claude SDK
+        """
+        self.config = config
+
+    def create_options(
+        self,
+        model: str,
+        temperature: float | None = None,
+        max_tokens: int | None = None,
+        system_message: str | None = None,
+        **additional_options: Any,
+    ) -> ClaudeAgentOptions:
+        """
+        Create Claude SDK options from API parameters.
+
+        Args:
+            model: The model name
+            temperature: Temperature for response generation
+            max_tokens: Maximum tokens in response
+            system_message: System message to include
+            **additional_options: Additional options to set on the ClaudeAgentOptions instance
+
+        Returns:
+            Configured ClaudeAgentOptions instance
+        """
+        # Start with configured defaults if available, otherwise create fresh instance
+        if self.config and self.config.code_options:
+            configured_opts = self.config.code_options
+            options = ClaudeAgentOptions()
+
+            # Copy all attributes from configured defaults
+            for attr in dir(configured_opts):
+                if not attr.startswith("_"):
+                    configured_value = getattr(configured_opts, attr)
+                    if configured_value is not None and hasattr(options, attr):
+                        # Special handling for mcp_servers to ensure we copy the dict
+                        if attr == "mcp_servers" and isinstance(configured_value, dict):
+                            setattr(options, attr, configured_value.copy())
+                        else:
+                            setattr(options, attr, configured_value)
+        else:
+            options = ClaudeAgentOptions()
+
+        # Override the model (API parameter takes precedence)
+        options.model = model
+
+        # Apply system message if provided (this is supported by ClaudeAgentOptions)
+        if system_message is not None:
+            options.system_prompt = system_message
+
+        # If session_id is provided via additional_options, enable continue_conversation
+        if additional_options.get("session_id"):
+            options.continue_conversation = True
+
+        # Automatically map additional_options to ClaudeAgentOptions attributes
+        for key, value in additional_options.items():
+            if hasattr(options, key):
+                try:
+                    # Attempt type conversion if the attribute already exists
+                    attr_type = type(getattr(options, key))
+                    # Only convert if the attribute is not None
+                    if getattr(options, key) is not None:
+                        setattr(options, key, attr_type(value))
+                    else:
+                        setattr(options, key, value)
+                except Exception:
+                    # Fallback to direct assignment if conversion fails
+                    setattr(options, key, value)
+
+        return options
+
+    @staticmethod
+    def extract_system_message(messages: list[dict[str, Any]]) -> str | None:
+        """
+        Extract system message from Anthropic messages format.
+
+        Args:
+            messages: List of messages in Anthropic format
+
+        Returns:
+            System message content if found, None otherwise
+        """
+        for message in messages:
+            if message.get("role") == "system":
+                content = message.get("content", "")
+                if isinstance(content, list):
+                    # Handle content blocks
+                    text_parts = []
+                    for block in content:
+                        if block.get("type") == "text":
+                            text_parts.append(block.get("text", ""))
+                    return " ".join(text_parts)
+                return str(content)
+        return None
+
+    @staticmethod
+    def get_supported_models() -> list[str]:
+        """
+        Get list of supported Claude models.
+
+        Returns:
+            List of supported model names
+        """
+        from ccproxy.plugins.claude_shared.model_defaults import (
+            DEFAULT_CLAUDE_MODEL_CARDS,
+        )
+
+        return [card.id for card in DEFAULT_CLAUDE_MODEL_CARDS]
+
+    @staticmethod
+    def validate_model(model: str) -> bool:
+        """
+        Validate if a model is supported.
+
+        Args:
+            model: The model name to validate
+
+        Returns:
+            True if supported, False otherwise
+        """
+        return model in OptionsHandler.get_supported_models()
+
+    @staticmethod
+    def get_default_options() -> dict[str, Any]:
+        """
+        Get default options for API parameters.
+
+        Returns:
+            Dictionary of default API parameter values
+        """
+        return {
+            "model": "claude-3-5-sonnet-20241022",
+            "temperature": 0.7,
+            "max_tokens": 4000,
+        }

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

@@ -14,7 +14,25 @@ import json
 import re
 from typing import Any
 
-from ccproxy.adapters.openai.models import format_openai_tool_call
+from ccproxy.llms.models import openai as openai_models
+
+
+def format_openai_tool_call(tool_use: dict[str, Any]) -> openai_models.ToolCall:
+    """Convert Anthropic tool use to OpenAI tool call format."""
+    tool_input = tool_use.get("input", {})
+    if isinstance(tool_input, dict):
+        arguments_str = json.dumps(tool_input)
+    else:
+        arguments_str = str(tool_input)
+
+    return openai_models.ToolCall(
+        id=tool_use.get("id", ""),
+        type="function",
+        function=openai_models.FunctionCall(
+            name=tool_use.get("name", ""),
+            arguments=arguments_str,
+        ),
+    )
 
 
 def parse_system_message_tags(text: str) -> str:
@@ -31,7 +49,7 @@ def parse_system_message_tags(text: str) -> str:
     def replace_system_message(match: re.Match[str]) -> str:
         try:
             system_data = json.loads(match.group(1))
-            source = system_data.get("source", "claude_code_sdk")
+            source = system_data.get("source", "claude_agent_sdk")
             system_text = system_data.get("text", "")
             return f"[{source}]: {system_text}"
         except json.JSONDecodeError:
@@ -75,7 +93,7 @@ def parse_tool_use_sdk_tags(
                 tool_id = tool_data.get("id", "")
                 tool_name = tool_data.get("name", "")
                 tool_input = tool_data.get("input", {})
-                return f"[claude_code_sdk tool_use {tool_id}]: {tool_name}({json.dumps(tool_input)})"
+                return f"[claude_agent_sdk tool_use {tool_id}]: {tool_name}({json.dumps(tool_input)})"
         except json.JSONDecodeError:
             # Keep original if parsing fails
             return match.group(0)
@@ -102,7 +120,7 @@ def parse_tool_result_sdk_tags(text: str) -> str:
             result_content = result_data.get("content", "")
             is_error = result_data.get("is_error", False)
             error_indicator = " (ERROR)" if is_error else ""
-            return f"[claude_code_sdk tool_result {tool_use_id}{error_indicator}]: {result_content}"
+            return f"[claude_agent_sdk tool_result {tool_use_id}{error_indicator}]: {result_content}"
         except json.JSONDecodeError:
             # Keep original if parsing fails
             return match.group(0)
@@ -124,7 +142,7 @@ def parse_result_message_tags(text: str) -> str:
     def replace_result_message(match: re.Match[str]) -> str:
         try:
             result_data = json.loads(match.group(1))
-            source = result_data.get("source", "claude_code_sdk")
+            source = result_data.get("source", "claude_agent_sdk")
             session_id = result_data.get("session_id", "")
             stop_reason = result_data.get("stop_reason", "")
             usage = result_data.get("usage", {})

ccproxy/plugins/claude_sdk/plugin.py

@@ -0,0 +1,269 @@
+"""Claude SDK plugin v2 implementation."""
+
+from typing import Any, cast
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins import (
+    BaseProviderPluginFactory,
+    FormatAdapterSpec,
+    FormatPair,
+    PluginContext,
+    PluginManifest,
+    ProviderPluginRuntime,
+    TaskSpec,
+)
+from ccproxy.core.plugins.declaration import RouterSpec
+from ccproxy.core.plugins.interfaces import DetectionServiceProtocol
+from ccproxy.llms.streaming.accumulators import ClaudeAccumulator
+from ccproxy.services.adapters.base import BaseAdapter
+
+from .adapter import ClaudeSDKAdapter
+from .config import ClaudeSDKSettings
+from .detection_service import ClaudeSDKDetectionService
+from .routes import router
+from .tasks import ClaudeSDKDetectionRefreshTask
+
+
+logger = get_plugin_logger()
+
+
+class ClaudeSDKRuntime(ProviderPluginRuntime):
+    """Runtime for Claude SDK plugin."""
+
+    def __init__(self, manifest: PluginManifest):
+        """Initialize runtime."""
+        super().__init__(manifest)
+        self.session_manager: Any | None = None
+
+    async def _on_initialize(self) -> None:
+        """Initialize the Claude SDK plugin."""
+        # Call parent initialization to set up adapter, detection_service, etc.
+        await super()._on_initialize()
+
+        if not self.context:
+            raise RuntimeError("Context not set")
+
+        # Get configuration
+        config = self.context.get("config")
+        if not isinstance(config, ClaudeSDKSettings):
+            logger.debug("plugin_no_config")
+            # Use default config if none provided
+            config = ClaudeSDKSettings()
+            logger.debug("plugin_using_default_config")
+
+        # Initialize adapter with session manager if enabled
+        if self.adapter and hasattr(self.adapter, "session_manager"):
+            self.session_manager = self.adapter.session_manager
+            if self.session_manager:
+                await self.session_manager.start()
+                logger.debug("session_manager_started")
+
+        # Initialize detection service if present
+        if self.detection_service and hasattr(
+            self.detection_service, "initialize_detection"
+        ):
+            await self.detection_service.initialize_detection()
+
+            # Check CLI status
+            version = self.detection_service.get_version()
+            cli_path = self.detection_service.get_cli_path()
+
+            if cli_path:
+                # Single consolidated log message with both CLI detection and plugin initialization status
+                logger.debug(
+                    "plugin_initialized",
+                    plugin="claude_sdk",
+                    version="0.1.0",
+                    status="initialized",
+                    has_credentials=True,  # SDK handles its own auth
+                    cli_available=True,
+                    cli_version=version,
+                    cli_path=cli_path,
+                    cli_source="package_manager",
+                    has_adapter=self.adapter is not None,
+                    has_session_manager=self.session_manager is not None,
+                )
+            else:
+                error_msg = "Claude CLI not found in PATH or common locations - SDK plugin requires installed CLI"
+                logger.error(
+                    "plugin_initialization_failed",
+                    status="failed",
+                    error=error_msg,
+                )
+                raise RuntimeError(error_msg)
+
+    async def _on_shutdown(self) -> None:
+        """Cleanup on shutdown."""
+        # Shutdown session manager first
+        if self.session_manager:
+            await self.session_manager.shutdown()
+            logger.debug("session_manager_shutdown")
+
+        # Call parent shutdown which handles adapter cleanup
+        await super()._on_shutdown()
+
+    async def _get_health_details(self) -> dict[str, Any]:
+        """Get health check details."""
+        details = await super()._get_health_details()
+
+        # Add SDK-specific health info
+        details.update(
+            {
+                "has_session_manager": self.session_manager is not None,
+            }
+        )
+
+        # Add CLI information if available
+        if self.detection_service:
+            details.update(
+                {
+                    "cli_available": self.detection_service.is_claude_available(),
+                    "cli_version": self.detection_service.get_version(),
+                    "cli_path": self.detection_service.get_cli_path(),
+                }
+            )
+
+        return details
+
+
+class ClaudeSDKFactory(BaseProviderPluginFactory):
+    """Factory for Claude SDK plugin."""
+
+    # Plugin configuration via class attributes
+    plugin_name = "claude_sdk"
+    plugin_description = (
+        "Claude SDK plugin providing access to Claude through the Claude Code SDK"
+    )
+    runtime_class = ClaudeSDKRuntime
+    adapter_class = ClaudeSDKAdapter
+    detection_service_class = ClaudeSDKDetectionService
+    config_class = ClaudeSDKSettings
+    routers = [
+        RouterSpec(router=router, prefix="/claude/sdk"),
+    ]
+    optional_requires = ["pricing"]
+
+    # No format adapters needed - core provides all required conversions
+    format_adapters: list[FormatAdapterSpec] = []
+
+    # Dependencies: All required adapters now provided by core
+    requires_format_adapters: list[FormatPair] = []
+
+    tasks = [
+        TaskSpec(
+            task_name="claude_sdk_detection_refresh",
+            task_type="claude_sdk_detection_refresh",
+            task_class=ClaudeSDKDetectionRefreshTask,
+            interval_seconds=3600,
+            enabled=True,
+            kwargs={"skip_initial_run": True},
+        )
+    ]
+    tool_accumulator_class = ClaudeAccumulator
+
+    async def create_adapter(self, context: PluginContext) -> BaseAdapter:
+        """Create the Claude SDK adapter.
+
+        This method overrides the base implementation because Claude SDK
+        has different dependencies than HTTP-based adapters.
+
+        Args:
+            context: Plugin context
+
+        Returns:
+            ClaudeSDKAdapter instance
+        """
+        config = context.get("config")
+        if not isinstance(config, ClaudeSDKSettings):
+            raise RuntimeError("No configuration provided for Claude SDK adapter")
+
+        # Get optional dependencies
+        metrics = context.get("metrics")
+
+        # Try to get hook_manager from context (provided by core services)
+        hook_manager = context.get("hook_manager")
+        if not hook_manager:
+            # Try to get from app state as fallback
+            app = context.get("app")
+            if app and hasattr(app, "state") and hasattr(app.state, "hook_manager"):
+                hook_manager = app.state.hook_manager
+
+        if hook_manager:
+            logger.debug("claude_sdk_hook_manager_found", source="context_or_app")
+
+        # Create adapter with config and optional dependencies
+        # Note: ClaudeSDKAdapter doesn't use an HTTP client, but it still
+        #       needs access to the shared format registry so it can
+        #       compose request/response converters declared by the core.
+        format_registry = None
+        service_container = context.get("service_container")
+        if service_container:
+            try:
+                format_registry = service_container.get_format_registry()
+            except Exception as exc:  # pragma: no cover - defensive logging
+                logger.warning(
+                    "claude_sdk_format_registry_unavailable",
+                    error=str(exc),
+                    category="format",
+                )
+
+        adapter = ClaudeSDKAdapter(
+            config=config,
+            metrics=metrics,
+            hook_manager=hook_manager,
+            format_registry=format_registry,
+            context=context,
+        )
+
+        return adapter
+
+    def create_detection_service(
+        self, context: PluginContext
+    ) -> DetectionServiceProtocol:
+        """Create the Claude SDK detection service with validation.
+
+        Args:
+            context: Plugin context
+
+        Returns:
+            ClaudeSDKDetectionService instance
+        """
+        settings = context.get("settings")
+        if not settings:
+            raise RuntimeError("No settings provided for Claude SDK detection service")
+
+        cli_service = context.get("cli_detection_service")
+        service = ClaudeSDKDetectionService(settings, cli_service)
+        return cast(DetectionServiceProtocol, service)
+
+    async def create_credentials_manager(self, context: PluginContext) -> None:
+        """Create the credentials manager for Claude SDK.
+
+        Args:
+            context: Plugin context
+
+        Returns:
+            None - Claude SDK uses its own authentication mechanism
+        """
+        # Claude SDK doesn't use a traditional credentials manager
+        # It uses the built-in CLI authentication
+        return None
+
+    def create_context(self, core_services: Any) -> PluginContext:
+        """Create context and set up detection service in tasks."""
+        # Get base context
+        context = super().create_context(core_services)
+
+        # Create detection service early so it can be passed to tasks
+        detection_service = self.create_detection_service(context)
+
+        # Update task kwargs with detection service
+        for task_spec in self.manifest.tasks:
+            if task_spec.task_name == "claude_sdk_detection_refresh":
+                task_spec.kwargs["detection_service"] = detection_service
+
+        return context
+
+
+# Export the factory instance
+factory = ClaudeSDKFactory()

ccproxy/plugins/claude_sdk/routes.py

@@ -0,0 +1,104 @@
+"""Routes for Claude SDK plugin."""
+
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, Request
+from starlette.responses import Response, StreamingResponse
+
+from ccproxy.api.decorators import with_format_chain
+from ccproxy.api.dependencies import get_plugin_adapter
+from ccproxy.auth.dependencies import ConditionalAuthDep
+from ccproxy.core.constants import (
+    FORMAT_ANTHROPIC_MESSAGES,
+    FORMAT_OPENAI_CHAT,
+    FORMAT_OPENAI_RESPONSES,
+)
+from ccproxy.plugins.claude_sdk.adapter import ClaudeSDKAdapter
+from ccproxy.streaming import DeferredStreaming
+
+
+ClaudeSDKAdapterDep = Annotated[Any, Depends(get_plugin_adapter("claude_sdk"))]
+router = APIRouter()
+
+ResponseType = Response | StreamingResponse | DeferredStreaming
+
+
+async def _handle_claude_sdk_request(
+    request: Request,
+    adapter: ClaudeSDKAdapter,
+) -> ResponseType:
+    return await adapter.handle_request(request)
+
+
+@router.post("/v1/messages", response_model=None)
+@with_format_chain([FORMAT_ANTHROPIC_MESSAGES])
+async def claude_sdk_messages(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeSDKAdapterDep,
+) -> ResponseType:
+    return await _handle_claude_sdk_request(request, adapter)
+
+
+@router.post("/v1/chat/completions", response_model=None)
+@with_format_chain(
+    [
+        FORMAT_OPENAI_CHAT,
+        FORMAT_ANTHROPIC_MESSAGES,
+    ]
+)
+async def claude_sdk_chat_completions(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeSDKAdapterDep,
+) -> ResponseType:
+    return await _handle_claude_sdk_request(request, adapter)
+
+
+@router.post("/v1/responses", response_model=None)
+@with_format_chain([FORMAT_OPENAI_RESPONSES, FORMAT_ANTHROPIC_MESSAGES])
+async def claude_sdk_responses(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeSDKAdapterDep,
+) -> ResponseType:
+    return await _handle_claude_sdk_request(request, adapter)
+
+
+@router.post("/{session_id}/v1/messages", response_model=None)
+@with_format_chain([FORMAT_ANTHROPIC_MESSAGES])
+async def claude_sdk_messages_with_session(
+    request: Request,
+    session_id: str,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeSDKAdapterDep,
+) -> ResponseType:
+    request.state.session_id = session_id
+    return await _handle_claude_sdk_request(request, adapter)
+
+
+@router.post("/{session_id}/v1/chat/completions", response_model=None)
+@with_format_chain(
+    [
+        FORMAT_OPENAI_CHAT,
+        FORMAT_ANTHROPIC_MESSAGES,
+    ]
+)
+async def claude_sdk_chat_completions_with_session(
+    request: Request,
+    session_id: str,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeSDKAdapterDep,
+) -> ResponseType:
+    request.state.session_id = session_id
+    return await _handle_claude_sdk_request(request, adapter)
+
+
+@router.post("/{session_id}/v1/responses", response_model=None)
+@with_format_chain([FORMAT_OPENAI_RESPONSES, FORMAT_ANTHROPIC_MESSAGES])
+async def claude_sdk_responses_with_session(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeSDKAdapterDep,
+) -> ResponseType:
+    return await _handle_claude_sdk_request(request, adapter)