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

ccproxy/plugins/claude_api/plugin.py

@@ -0,0 +1,298 @@
+"""Claude API plugin implementation."""
+
+from typing import Any
+
+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.llms.streaming.accumulators import ClaudeAccumulator
+from ccproxy.plugins.oauth_claude.manager import ClaudeApiTokenManager
+
+from .adapter import ClaudeAPIAdapter
+from .config import ClaudeAPISettings
+from .detection_service import ClaudeAPIDetectionService
+from .health import claude_api_health_check
+from .routes import router as claude_api_router
+from .tasks import ClaudeAPIDetectionRefreshTask
+
+
+logger = get_plugin_logger()
+
+
+class ClaudeAPIRuntime(ProviderPluginRuntime):
+    """Runtime for Claude API plugin."""
+
+    def __init__(self, manifest: PluginManifest):
+        """Initialize runtime."""
+        self.credential_manager: ClaudeApiTokenManager | None = None
+        super().__init__(manifest)
+        self.config: ClaudeAPISettings | None = None
+
+    async def _on_initialize(self) -> None:
+        """Initialize the Claude API plugin."""
+        if not self.context:
+            raise RuntimeError("Context not set")
+
+        # Call parent initialization first
+        await super()._on_initialize()
+
+        # Get configuration
+        try:
+            config = self.context.get(ClaudeAPISettings)
+        except ValueError:
+            logger.warning("plugin_no_config")
+            # Use default config if none provided
+            config = ClaudeAPISettings()
+            logger.debug("plugin_using_default_config", category="plugin")
+        self.config = config
+
+        # Register streaming metrics hook
+        await self._register_streaming_metrics_hook()
+
+        # Initialize detection service to populate cached data
+        if self.detection_service:
+            try:
+                # This will detect headers and system prompt
+                await self.detection_service.initialize_detection()
+                version = self.detection_service.get_version()
+                cli_path = self.detection_service.get_cli_path()
+
+                if not cli_path:
+                    logger.warning(
+                        "cli_detection_completed",
+                        cli_available=False,
+                        version=None,
+                        cli_path=None,
+                        source="unknown",
+                    )
+            except Exception as e:
+                logger.error(
+                    "claude_detection_initialization_failed",
+                    error=str(e),
+                    exc_info=e,
+                )
+
+        # Get CLI info for consolidated logging (only for successful detection)
+        cli_info = {}
+        if self.detection_service and self.detection_service.get_cli_path():
+            cli_info.update(
+                {
+                    "cli_available": True,
+                    "cli_version": self.detection_service.get_version(),
+                    "cli_path": self.detection_service.get_cli_path(),
+                    "cli_source": "package_manager",
+                }
+            )
+
+        logger.debug(
+            "plugin_initialized",
+            plugin="claude_api",
+            version=self.manifest.version,
+            status="initialized",
+            has_credentials=self.credentials_manager is not None,
+            base_url=self.config.base_url,
+            models_count=len(self.config.models_endpoint)
+            if self.config.models_endpoint
+            else 0,
+            has_adapter=self.adapter is not None,
+            **cli_info,
+        )
+
+    async def _get_health_details(self) -> dict[str, Any]:
+        """Get health check details."""
+        details = await super()._get_health_details()
+
+        # Add claude-api specific health check
+        if self.config and self.detection_service and self.credentials_manager:
+            try:
+                health_result = await claude_api_health_check(
+                    self.config,
+                    self.detection_service,
+                    self.credentials_manager,
+                    version=self.manifest.version,
+                )
+                details.update(
+                    {
+                        "health_check_status": health_result.status,
+                        "health_check_detail": health_result.details,
+                    }
+                )
+            except Exception as e:
+                details["health_check_error"] = str(e)
+
+        return details
+
+    async def _register_streaming_metrics_hook(self) -> None:
+        """Register the streaming metrics extraction hook."""
+        try:
+            if not self.context:
+                logger.warning(
+                    "streaming_metrics_hook_not_registered",
+                    reason="no_context",
+                    plugin="claude_api",
+                )
+                return
+            # Debug: Log context details
+            logger.debug(
+                "streaming_metrics_hook_context_check",
+                plugin="claude_api",
+                has_context=self.context is not None,
+                context_type=type(self.context).__name__ if self.context else None,
+                context_keys=list(self.context.keys()) if self.context else [],
+                has_hook_registry="hook_registry" in (self.context or {}),
+                has_plugin_registry="plugin_registry" in (self.context or {}),
+            )
+
+            # Get hook registry from context
+            from ccproxy.core.plugins.hooks.registry import HookRegistry
+
+            try:
+                hook_registry = self.context.get(HookRegistry)
+            except ValueError:
+                logger.warning(
+                    "streaming_metrics_hook_not_registered",
+                    reason="no_hook_registry",
+                    plugin="claude_api",
+                    context_keys=list(self.context.keys()) if self.context else [],
+                )
+                return
+
+            # Get pricing service from plugin registry if available
+            pricing_service = None
+            if "plugin_registry" in self.context:
+                try:
+                    from ccproxy.plugins.pricing.service import PricingService
+
+                    plugin_registry = self.context["plugin_registry"]
+                    logger.debug(
+                        "getting_pricing_service",
+                        plugin="claude_api",
+                        registry_type=type(plugin_registry).__name__,
+                    )
+                    pricing_service = plugin_registry.get_service(
+                        "pricing", PricingService
+                    )
+                    logger.debug(
+                        "pricing_service_obtained",
+                        plugin="claude_api",
+                        service_type=type(pricing_service).__name__
+                        if pricing_service
+                        else None,
+                        is_none=pricing_service is None,
+                    )
+                except Exception as e:
+                    logger.debug(
+                        "pricing_service_not_available_for_hook",
+                        plugin="claude_api",
+                        error=str(e),
+                        error_type=type(e).__name__,
+                    )
+            else:
+                logger.debug(
+                    "plugin_registry_not_in_context",
+                    plugin="claude_api",
+                    context_keys=list(self.context.keys()) if self.context else [],
+                )
+
+            # Create and register the hook
+            from .hooks import ClaudeAPIStreamingMetricsHook
+
+            # Pass both pricing_service (if available now) and plugin_registry (for lazy loading)
+            metrics_hook = ClaudeAPIStreamingMetricsHook(
+                pricing_service=pricing_service,
+                plugin_registry=self.context.get("plugin_registry"),
+            )
+            hook_registry.register(metrics_hook)
+
+            logger.debug(
+                "streaming_metrics_hook_registered",
+                plugin="claude_api",
+                hook_name=metrics_hook.name,
+                priority=metrics_hook.priority,
+                has_pricing=pricing_service is not None,
+                pricing_service_type=type(pricing_service).__name__
+                if pricing_service
+                else "None",
+            )
+
+        except Exception as e:
+            logger.error(
+                "streaming_metrics_hook_registration_failed",
+                plugin="claude_api",
+                error=str(e),
+                exc_info=e,
+            )
+
+
+class ClaudeAPIFactory(BaseProviderPluginFactory):
+    """Factory for Claude API plugin."""
+
+    cli_safe = False  # Heavy provider plugin - not safe for CLI
+
+    # Plugin configuration via class attributes
+    plugin_name = "claude_api"
+    plugin_description = "Claude API provider plugin with support for both native Anthropic format and OpenAI-compatible format"
+    runtime_class = ClaudeAPIRuntime
+    adapter_class = ClaudeAPIAdapter
+    detection_service_class = ClaudeAPIDetectionService
+    config_class = ClaudeAPISettings
+    # String-based auth manager reference
+    auth_manager_name = "oauth_claude"
+    credentials_manager_class = ClaudeApiTokenManager
+    routers = [
+        RouterSpec(router=claude_api_router, prefix="/claude", tags=["claude-api"]),
+    ]
+    # OAuth provider is optional because the token manager can operate
+    # without a globally-registered auth provider. When present, it enables
+    # first-class OAuth flows in the UI.
+    dependencies = ["oauth_claude"]
+    optional_requires = ["pricing"]
+
+    # No format adapters needed - core provides all required conversions
+    format_adapters: list[FormatAdapterSpec] = []
+
+    # Define requirements for adapters this plugin needs
+    requires_format_adapters: list[FormatPair] = [
+        # Core-provided adapters handle remaining dependencies
+    ]
+    tasks = [
+        TaskSpec(
+            task_name="claude_api_detection_refresh",
+            task_type="claude_api_detection_refresh",
+            task_class=ClaudeAPIDetectionRefreshTask,
+            interval_seconds=3600,
+            enabled=True,
+            kwargs={"skip_initial_run": True},
+        )
+    ]
+    tool_accumulator_class = ClaudeAccumulator
+
+    def create_detection_service(self, context: PluginContext) -> Any:
+        """Create detection service and inject it into task kwargs.
+
+        Ensures the scheduled detection-refresh task uses the same instance
+        that the runtime receives via context.
+        """
+        detection_service = super().create_detection_service(context)
+
+        if self.manifest.tasks and detection_service is not None:
+            for task_spec in self.manifest.tasks:
+                if task_spec.task_name == "claude_api_detection_refresh":
+                    task_spec.kwargs["detection_service"] = detection_service
+
+        return detection_service
+
+
+# Create factory instance for plugin discovery
+# Note: This follows the existing pattern but creates a singleton
+factory = ClaudeAPIFactory()
+
+__all__ = ["ClaudeAPIFactory", "ClaudeAPIRuntime", "factory"]

ccproxy/plugins/claude_api/routes.py

@@ -0,0 +1,118 @@
+"""API routes for Claude API plugin."""
+
+import uuid
+from typing import TYPE_CHECKING, Annotated, Any, cast
+
+from fastapi import APIRouter, Depends, Request
+from fastapi.responses import Response, StreamingResponse
+
+from ccproxy.api.decorators import with_format_chain
+from ccproxy.api.dependencies import (
+    get_plugin_adapter,
+    get_provider_config_dependency,
+)
+from ccproxy.auth.dependencies import ConditionalAuthDep
+from ccproxy.core.constants import (
+    FORMAT_ANTHROPIC_MESSAGES,
+    FORMAT_OPENAI_CHAT,
+    FORMAT_OPENAI_RESPONSES,
+    UPSTREAM_ENDPOINT_ANTHROPIC_MESSAGES,
+)
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.llms.models import anthropic as anthropic_models
+from ccproxy.llms.models import openai as openai_models
+from ccproxy.streaming import DeferredStreaming
+
+from .config import ClaudeAPISettings
+
+
+if TYPE_CHECKING:
+    pass
+
+logger = get_plugin_logger()
+
+ClaudeAPIAdapterDep = Annotated[Any, Depends(get_plugin_adapter("claude_api"))]
+ClaudeAPIConfigDep = Annotated[
+    ClaudeAPISettings,
+    Depends(get_provider_config_dependency("claude_api", ClaudeAPISettings)),
+]
+
+APIResponse = Response | StreamingResponse | DeferredStreaming
+
+# Main API Router - Core Claude API endpoints
+router = APIRouter()
+
+
+def _cast_result(result: object) -> APIResponse:
+    return cast(APIResponse, result)
+
+
+async def _handle_adapter_request(
+    request: Request,
+    adapter: Any,
+) -> APIResponse:
+    result = await adapter.handle_request(request)
+    return _cast_result(result)
+
+
+@router.post(
+    "/v1/messages",
+    response_model=anthropic_models.MessageResponse | anthropic_models.APIError,
+)
+@with_format_chain(
+    [FORMAT_ANTHROPIC_MESSAGES], endpoint=UPSTREAM_ENDPOINT_ANTHROPIC_MESSAGES
+)
+async def create_anthropic_message(
+    request: Request,
+    _: anthropic_models.CreateMessageRequest,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeAPIAdapterDep,
+) -> APIResponse:
+    """Create a message using Claude AI with native Anthropic format."""
+    return await _handle_adapter_request(request, adapter)
+
+
+@router.post(
+    "/v1/chat/completions",
+    response_model=openai_models.ChatCompletionResponse | openai_models.ErrorResponse,
+)
+@with_format_chain(
+    [FORMAT_OPENAI_CHAT, FORMAT_ANTHROPIC_MESSAGES],
+    endpoint=UPSTREAM_ENDPOINT_ANTHROPIC_MESSAGES,
+)
+async def create_openai_chat_completion(
+    request: Request,
+    _: openai_models.ChatCompletionRequest,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeAPIAdapterDep,
+) -> APIResponse:
+    """Create a chat completion using Claude AI with OpenAI-compatible format."""
+    return await _handle_adapter_request(request, adapter)
+
+
+@router.post("/v1/responses", response_model=None)
+@with_format_chain(
+    [FORMAT_OPENAI_RESPONSES, FORMAT_ANTHROPIC_MESSAGES],
+    endpoint=UPSTREAM_ENDPOINT_ANTHROPIC_MESSAGES,
+)
+async def claude_v1_responses(
+    request: Request,
+    auth: ConditionalAuthDep,
+    adapter: ClaudeAPIAdapterDep,
+) -> APIResponse:
+    """Response API compatible endpoint using Claude backend."""
+    # Ensure format chain is present for request/response conversion
+    # format chain and endpoint set by decorator
+    session_id = request.headers.get("session_id") or str(uuid.uuid4())
+    return await _handle_adapter_request(request, adapter)
+
+
+@router.get("/v1/models", response_model=openai_models.ModelList)
+async def list_models(
+    request: Request,
+    auth: ConditionalAuthDep,
+    config: ClaudeAPIConfigDep,
+) -> dict[str, Any]:
+    """List available Claude models from configuration."""
+    models = [card.model_dump(mode="json") for card in config.models_endpoint]
+    return {"object": "list", "data": models}

ccproxy/plugins/claude_api/streaming_metrics.py

@@ -0,0 +1,68 @@
+"""Claude API streaming metrics extraction utilities.
+
+This module provides utilities for extracting token usage from
+Anthropic streaming responses.
+"""
+
+from typing import Any, TypedDict
+
+
+class UsageData(TypedDict, total=False):
+    """Token usage data extracted from streaming or non-streaming responses."""
+
+    input_tokens: int | None
+    output_tokens: int | None
+    cache_read_input_tokens: int | None
+    cache_creation_input_tokens: int | None
+    event_type: str | None  # Extra field for tracking event source
+    model: str | None  # Extra field for model information
+
+
+def extract_usage_from_streaming_chunk(chunk_data: Any) -> UsageData | None:
+    """Extract usage information from Anthropic streaming response chunk.
+
+    This function looks for usage information in both message_start and message_delta events
+    from Anthropic's streaming API responses. message_start contains initial input tokens,
+    message_delta contains final output tokens.
+
+    Args:
+        chunk_data: Streaming response chunk dictionary
+
+    Returns:
+        UsageData with token counts or None if no usage found
+    """
+    if not isinstance(chunk_data, dict):
+        return None
+
+    chunk_type = chunk_data.get("type")
+
+    # Look for message_start events with initial usage (input tokens)
+    if chunk_type == "message_start" and "message" in chunk_data:
+        message = chunk_data["message"]
+        # Extract model name if present
+        model = message.get("model")
+        if "usage" in message:
+            usage = message["usage"]
+            return UsageData(
+                input_tokens=usage.get("input_tokens"),
+                output_tokens=usage.get(
+                    "output_tokens"
+                ),  # Initial output tokens (usually small)
+                cache_read_input_tokens=usage.get("cache_read_input_tokens"),
+                cache_creation_input_tokens=usage.get("cache_creation_input_tokens"),
+                event_type="message_start",
+                model=model,  # Include model in usage data
+            )
+
+    # Look for message_delta events with final usage (output tokens)
+    elif chunk_type == "message_delta" and "usage" in chunk_data:
+        usage = chunk_data["usage"]
+        return UsageData(
+            input_tokens=usage.get("input_tokens"),  # Usually None in delta
+            output_tokens=usage.get("output_tokens"),  # Final output token count
+            cache_read_input_tokens=usage.get("cache_read_input_tokens"),
+            cache_creation_input_tokens=usage.get("cache_creation_input_tokens"),
+            event_type="message_delta",
+        )
+
+    return None

ccproxy/plugins/claude_api/tasks.py

@@ -0,0 +1,84 @@
+"""Scheduled tasks for Claude API plugin."""
+
+from typing import TYPE_CHECKING, Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.scheduler.tasks import BaseScheduledTask
+
+
+if TYPE_CHECKING:
+    from .detection_service import ClaudeAPIDetectionService
+
+
+logger = get_plugin_logger()
+
+
+class ClaudeAPIDetectionRefreshTask(BaseScheduledTask):
+    """Task to periodically refresh Claude CLI detection headers."""
+
+    def __init__(
+        self,
+        name: str,
+        interval_seconds: float,
+        detection_service: "ClaudeAPIDetectionService",
+        enabled: bool = True,
+        skip_initial_run: bool = True,
+        **kwargs: Any,
+    ):
+        super().__init__(
+            name=name,
+            interval_seconds=interval_seconds,
+            enabled=enabled,
+            **kwargs,
+        )
+        self.detection_service = detection_service
+        self.skip_initial_run = skip_initial_run
+        self._first_run = True
+
+    async def run(self) -> bool:
+        """Execute the detection refresh."""
+        if self._first_run and self.skip_initial_run:
+            self._first_run = False
+            logger.debug(
+                "claude_api_detection_refresh_skipped_initial",
+                task_name=self.name,
+            )
+            return True
+
+        self._first_run = False
+
+        try:
+            logger.info(
+                "claude_api_detection_refresh_starting",
+                task_name=self.name,
+            )
+            detection_data = await self.detection_service.initialize_detection()
+
+            logger.info(
+                "claude_api_detection_refresh_completed",
+                task_name=self.name,
+                version=detection_data.claude_version if detection_data else "unknown",
+            )
+            return True
+
+        except Exception as e:
+            logger.error(
+                "claude_api_detection_refresh_failed",
+                task_name=self.name,
+                error=str(e),
+            )
+            return False
+
+    async def setup(self) -> None:
+        """Setup before task execution starts."""
+        logger.debug(
+            "claude_api_detection_refresh_setup",
+            task_name=self.name,
+        )
+
+    async def cleanup(self) -> None:
+        """Cleanup after task execution stops."""
+        logger.info(
+            "claude_api_detection_refresh_cleanup",
+            task_name=self.name,
+        )

ccproxy/plugins/claude_sdk/README.md

@@ -0,0 +1,35 @@
+# Claude SDK Plugin
+
+Runs Claude through the local Claude Code SDK and CLI with session management.
+
+## Highlights
+- Wraps the SDK adapter with reusable session and streaming support
+- Validates CLI availability via the detection service and refresh task
+- Shares the Claude accumulator to emit streaming metrics comparable to the API
+
+## Configuration
+- `ClaudeSDKSettings` covers CLI discovery, auth, and session pooling options
+- Requires the Claude CLI to be installed and reachable on `PATH`
+- Generate defaults with `python3 scripts/generate_config_from_model.py \
+  --format toml --plugin claude_sdk --config-class ClaudeSDKSettings`
+
+```toml
+[plugins.claude_sdk]
+# enabled = true
+# base_url = "claude-sdk://local"
+# session_pool_enabled = false
+# session_pool_size = 5
+# include_system_messages_in_stream = true
+# sdk_message_mode = "formatted"
+
+[plugins.claude_sdk.sdk_session_pool]
+# enabled = true
+# session_ttl = 3600
+# max_sessions = 1000
+# cleanup_interval = 300
+```
+
+## Related Components
+- `adapter.py`: bridge between CCProxy requests and the SDK client
+- `tasks.py`: periodic detection refresh for CLI state
+- `routes.py`: FastAPI router served under `/claude/sdk`

ccproxy/plugins/claude_sdk/__init__.py

@@ -0,0 +1,80 @@
+"""Claude SDK integration module."""
+
+from .client import ClaudeSDKClient
+from .exceptions import ClaudeSDKError, StreamTimeoutError
+from .models import (
+    AssistantMessage,
+    ContentBlock,
+    ExtendedContentBlock,
+    ResultMessage,
+    ResultMessageBlock,
+    SDKContentBlock,
+    SDKMessage,
+    SDKMessageContent,
+    SDKMessageMode,
+    SystemMessage,
+    TextBlock,
+    ThinkingBlock,
+    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,
+    create_sdk_message,
+    to_sdk_variant,
+)
+from .options import OptionsHandler
+
+
+# Lazy import to avoid circular dependency
+def __getattr__(name: str) -> object:
+    if name == "MessageConverter":
+        from .converter import MessageConverter
+
+        return MessageConverter
+    if name == "parse_formatted_sdk_content":
+        from .parser import parse_formatted_sdk_content
+
+        return parse_formatted_sdk_content
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")
+
+
+__all__ = [
+    # Session Context will be imported here once created
+    "ClaudeSDKClient",
+    "ClaudeSDKError",
+    "StreamTimeoutError",
+    "MessageConverter",  # Lazy loaded
+    "OptionsHandler",
+    "parse_formatted_sdk_content",  # Lazy loaded
+    # Re-export SDK models from core adapter
+    "AssistantMessage",
+    "ContentBlock",
+    "ExtendedContentBlock",
+    "ResultMessage",
+    "ResultMessageBlock",
+    "SDKContentBlock",
+    "SDKMessage",
+    "SDKMessageContent",
+    "SDKMessageMode",
+    "SystemMessage",
+    "TextBlock",
+    "ThinkingBlock",
+    "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",
+    "create_sdk_message",
+    "to_sdk_variant",
+]