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

ccproxy/plugins/claude_sdk/health.py

@@ -0,0 +1,113 @@
+"""Health check implementation for Claude SDK plugin."""
+
+from typing import TYPE_CHECKING, Literal, cast
+
+from ccproxy.core.plugins.protocol import HealthCheckResult
+
+
+if TYPE_CHECKING:
+    from .config import ClaudeSDKSettings
+    from .detection_service import ClaudeSDKDetectionService
+
+
+async def claude_sdk_health_check(
+    config: "ClaudeSDKSettings | None",
+    detection_service: "ClaudeSDKDetectionService | None",
+    *,
+    version: str,
+) -> HealthCheckResult:
+    """Perform health check for Claude SDK plugin.
+
+    Args:
+        config: Claude SDK plugin configuration
+        detection_service: Claude CLI detection service
+
+    Returns:
+        HealthCheckResult with plugin status
+    """
+    checks = []
+    status: str = "pass"
+
+    # Check if plugin is enabled
+    if not config or not config.enabled:
+        return HealthCheckResult(
+            status="fail",
+            componentId="plugin-claude_sdk",
+            output="Plugin is disabled",
+            version=version,
+            details={"enabled": False},
+        )
+
+    # Check Claude CLI detection
+    if detection_service:
+        cli_version = detection_service.get_version()
+        cli_path = detection_service.get_cli_path()
+        is_available = detection_service.is_claude_available()
+        cli_info = detection_service.get_cli_health_info()
+
+        if is_available and cli_path:
+            checks.append(f"CLI: {cli_version or 'detected'} at {cli_path}")
+        else:
+            checks.append("CLI: not found")
+            status = "warn"  # CLI not found is a warning, not a failure
+    else:
+        checks.append("CLI: detection service not initialized")
+        status = "warn"
+
+    # Check configuration
+    if config:
+        checks.append(f"Models: {len(config.models_endpoint)} configured")
+        checks.append(
+            f"Session pool: {'enabled' if config.session_pool_enabled else 'disabled'}"
+        )
+        checks.append(
+            f"Streaming: {'enabled' if config.supports_streaming else 'disabled'}"
+        )
+    else:
+        checks.append("Config: not loaded")
+        status = "fail"
+
+    # Standardized details
+    from ccproxy.core.plugins.models import (
+        CLIHealth,
+        ConfigHealth,
+        ProviderHealthDetails,
+    )
+
+    cli_health = None
+    if detection_service:
+        path_list = detection_service.get_cli_path()
+        cli_status = cli_info.status.value if cli_info else "unknown"
+        cli_health = CLIHealth(
+            available=bool(detection_service.is_claude_available()),
+            status=cli_status,
+            version=detection_service.get_version(),
+            path=(path_list[0] if path_list else None),
+        )
+
+    details = ProviderHealthDetails(
+        provider="claude_sdk",
+        enabled=bool(config and config.enabled),
+        base_url=None,
+        cli=cli_health,
+        auth=None,
+        config=ConfigHealth(
+            model_count=len(config.models_endpoint)
+            if config and config.models_endpoint
+            else 0,
+            supports_openai_format=config.supports_streaming if config else None,
+            extra={
+                "session_pool_enabled": bool(config.session_pool_enabled)
+                if config
+                else None
+            },
+        ),
+    ).model_dump()
+
+    return HealthCheckResult(
+        status=cast(Literal["pass", "warn", "fail"], status),
+        componentId="plugin-claude_sdk",
+        output="; ".join(checks),
+        version=version,
+        details=details,
+    )

ccproxy/plugins/claude_sdk/hooks.py

@@ -0,0 +1,115 @@
+"""Hook integration for Claude SDK plugin to emit streaming metrics."""
+
+from __future__ import annotations
+
+from datetime import datetime
+from typing import Any
+
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.plugins.hooks import Hook, HookContext, HookEvent, HookManager
+
+
+logger = get_plugin_logger(__name__)
+
+
+class ClaudeSDKStreamingHook(Hook):
+    """Hook for emitting Claude SDK streaming metrics.
+
+    This hook handles streaming completion events from claude_sdk and emits
+    PROVIDER_STREAM_END events with usage metrics for access logging.
+    """
+
+    name = "claude_sdk_streaming_metrics"
+    events = []  # We'll emit events directly, not listen to them
+    priority = 700  # HookLayer.METRICS
+
+    def __init__(self, hook_manager: HookManager | None = None) -> None:
+        """Initialize the Claude SDK streaming hook.
+
+        Args:
+            hook_manager: Hook manager for emitting events
+        """
+        self.hook_manager = hook_manager
+
+    async def emit_stream_end(
+        self,
+        request_id: str,
+        usage_metrics: dict[str, Any],
+        provider: str = "claude_sdk",
+        url: str = "claude-sdk://direct",
+        method: str = "POST",
+        total_chunks: int = 0,
+        total_bytes: int = 0,
+    ) -> None:
+        """Emit PROVIDER_STREAM_END event with usage metrics.
+
+        Args:
+            request_id: Request ID for correlation
+            usage_metrics: Dictionary containing token counts and costs
+            provider: Provider name (default: claude_sdk)
+            url: URL or endpoint identifier
+            method: HTTP method
+            total_chunks: Number of chunks streamed
+            total_bytes: Total bytes streamed
+        """
+        if not self.hook_manager:
+            logger.debug(
+                "no_hook_manager_for_stream_end",
+                request_id=request_id,
+                provider=provider,
+            )
+            return
+
+        try:
+            # Normalize usage metrics to standard format
+            normalized_metrics = {
+                "input_tokens": usage_metrics.get("tokens_input", 0),
+                "output_tokens": usage_metrics.get("tokens_output", 0),
+                "cache_read_input_tokens": usage_metrics.get("cache_read_tokens", 0),
+                "cache_creation_input_tokens": usage_metrics.get(
+                    "cache_write_tokens", 0
+                ),
+                "cost_usd": usage_metrics.get("cost_usd", 0.0),
+                "model": usage_metrics.get("model", ""),
+            }
+
+            stream_end_context = HookContext(
+                event=HookEvent.PROVIDER_STREAM_END,
+                timestamp=datetime.now(),
+                provider=provider,
+                data={
+                    "url": url,
+                    "method": method,
+                    "request_id": request_id,
+                    "total_chunks": total_chunks,
+                    "total_bytes": total_bytes,
+                    "usage_metrics": normalized_metrics,
+                },
+                metadata={
+                    "request_id": request_id,
+                },
+            )
+
+            await self.hook_manager.emit_with_context(stream_end_context)
+
+            logger.info(
+                "claude_sdk_stream_end_emitted",
+                request_id=request_id,
+                tokens_input=normalized_metrics["input_tokens"],
+                tokens_output=normalized_metrics["output_tokens"],
+                cost_usd=normalized_metrics["cost_usd"],
+                model=normalized_metrics["model"],
+            )
+
+        except Exception as e:
+            logger.error(
+                "claude_sdk_hook_emission_failed",
+                event="PROVIDER_STREAM_END",
+                error=str(e),
+                request_id=request_id,
+                exc_info=e,
+            )
+
+    async def __call__(self, context: HookContext) -> None:
+        """Handle hook events (not used for this hook as we emit directly)."""
+        pass

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

@@ -13,19 +13,20 @@ from collections.abc import Callable
 # Type alias for metrics factory function
 from typing import Any, TypeAlias
 
-import structlog
-from claude_code_sdk import ClaudeCodeOptions
+from claude_agent_sdk import ClaudeAgentOptions
 
-from ccproxy.claude_sdk.session_client import SessionClient
-from ccproxy.claude_sdk.session_pool import SessionPool
-from ccproxy.config.settings import Settings
 from ccproxy.core.errors import ClaudeProxyError
+from ccproxy.core.logging import get_plugin_logger
 
+from .config import ClaudeSDKSettings, SessionPoolSettings
+from .session_client import SessionClient
+from .session_pool import SessionPool
 
-logger = structlog.get_logger(__name__)
 
+# Type alias for metrics factory function
+MetricsFactory: TypeAlias = Callable[[], Any]
 
-MetricsFactory: TypeAlias = Callable[[], Any | None]
+logger = get_plugin_logger()
 
 
 class SessionManager:
@@ -33,21 +34,18 @@ class SessionManager:
 
     def __init__(
         self,
-        settings: Settings,
+        config: ClaudeSDKSettings,
         metrics_factory: MetricsFactory | None = None,
     ) -> None:
         """Initialize SessionManager with optional settings and metrics factory.
 
         Args:
-            settings: Optional settings containing session pool configuration
+            config: Plugin-specific configuration for Claude SDK
             metrics_factory: Optional callable that returns a metrics instance.
                            If None, no metrics will be used.
         """
-        import structlog
-
-        logger = structlog.get_logger(__name__)
 
-        self._settings = settings
+        self.config = config
         self._session_pool: SessionPool | None = None
         self._lock = asyncio.Lock()
         self._metrics_factory = metrics_factory
@@ -56,14 +54,36 @@ class SessionManager:
         session_pool_enabled = self._should_enable_session_pool()
         logger.debug(
             "session_manager_init",
-            has_settings=bool(settings),
+            has_config=bool(config),
             has_metrics_factory=bool(metrics_factory),
             session_pool_enabled=session_pool_enabled,
         )
 
         if session_pool_enabled:
-            self._session_pool = SessionPool(settings.claude.sdk_session_pool)
-            logger.info(
+            # Convert core settings to plugin settings
+            core_pool_settings = self.config.sdk_session_pool
+            if core_pool_settings is None:
+                logger.debug("session_pool_disabled", reason="no_settings")
+                return
+
+            plugin_pool_settings = 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
+                ),
+            )
+            self._session_pool = SessionPool(plugin_pool_settings)
+            logger.debug(
                 "session_manager_session_pool_initialized",
                 session_ttl=self._session_pool.config.session_ttl,
                 max_sessions=self._session_pool.config.max_sessions,
@@ -77,21 +97,12 @@ class SessionManager:
 
     def _should_enable_session_pool(self) -> bool:
         """Check if session pool should be enabled."""
-        import structlog
-
-        logger = structlog.get_logger(__name__)
 
-        if not self._settings:
-            logger.debug("session_pool_check", decision="no_settings", enabled=False)
+        if not self.config:
+            logger.debug("session_pool_check", decision="no_config", enabled=False)
             return False
 
-        if not hasattr(self._settings, "claude"):
-            logger.debug(
-                "session_pool_check", decision="no_claude_settings", enabled=False
-            )
-            return False
-
-        session_pool_settings = getattr(self._settings.claude, "sdk_session_pool", None)
+        session_pool_settings = getattr(self.config, "sdk_session_pool", None)
         if not session_pool_settings:
             logger.debug(
                 "session_pool_check", decision="no_session_pool_settings", enabled=False
@@ -121,11 +132,10 @@ class SessionManager:
     async def get_session_client(
         self,
         session_id: str,
-        options: ClaudeCodeOptions,
+        options: ClaudeAgentOptions,
     ) -> SessionClient:
         """Get session-aware client."""
 
-        logger = structlog.get_logger(__name__)
         logger.debug(
             "session_manager_get_session_client",
             session_id=session_id,
@@ -161,7 +171,7 @@ class SessionManager:
             )
             return False
 
-        logger.info(
+        logger.debug(
             "session_manager_interrupt_session",
             session_id=session_id,
         )
@@ -178,7 +188,7 @@ class SessionManager:
             logger.warning("session_manager_interrupt_all_no_pool")
             return 0
 
-        logger.info("session_manager_interrupt_all_sessions")
+        logger.debug("session_manager_interrupt_all_sessions")
         return await self._session_pool.interrupt_all_sessions()
 
     async def get_session_pool_stats(self) -> dict[str, Any]:

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

@@ -11,10 +11,10 @@ from dataclasses import dataclass, field
 from enum import Enum
 from typing import Any, TypeVar
 
-import structlog
+from ccproxy.core.logging import get_plugin_logger
 
 
-logger = structlog.get_logger(__name__)
+logger = get_plugin_logger()
 
 T = TypeVar("T")
 
@@ -150,7 +150,7 @@ class MessageQueue:
             listener = QueueListener(listener_id)
             self._listeners[listener.listener_id] = listener
 
-            logger.debug(
+            logger.trace(
                 "message_queue_listener_added",
                 listener_id=listener.listener_id,
                 active_listeners=len(self._listeners),
@@ -169,7 +169,7 @@ class MessageQueue:
                 listener = self._listeners.pop(listener_id)
                 listener.close()
 
-                logger.debug(
+                logger.trace(
                     "message_queue_listener_removed",
                     listener_id=listener_id,
                     active_listeners=len(self._listeners),
@@ -242,7 +242,7 @@ class MessageQueue:
             if delivered_count == 0:
                 self._total_messages_discarded += 1
 
-            logger.debug(
+            logger.trace(
                 "message_queue_broadcast",
                 listeners_count=len(self._listeners),
                 delivered_count=delivered_count,
@@ -265,7 +265,7 @@ class MessageQueue:
                     with contextlib.suppress(asyncio.QueueFull):
                         listener._queue.put_nowait(queue_msg)
 
-            logger.debug(
+            logger.trace(
                 "message_queue_broadcast_error",
                 error_type=type(error).__name__,
                 listeners_count=len(self._listeners),
@@ -281,7 +281,7 @@ class MessageQueue:
                     with contextlib.suppress(asyncio.QueueFull):
                         listener._queue.put_nowait(queue_msg)
 
-            logger.debug(
+            logger.trace(
                 "message_queue_broadcast_complete",
                 listeners_count=len(self._listeners),
             )
@@ -296,7 +296,7 @@ class MessageQueue:
                     with contextlib.suppress(asyncio.QueueFull):
                         listener._queue.put_nowait(queue_msg)
 
-            logger.debug(
+            logger.trace(
                 "message_queue_broadcast_shutdown",
                 listeners_count=len(self._listeners),
                 message="Shutdown signal sent to all listeners due to interrupt",

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

@@ -4,7 +4,7 @@ This module provides Pydantic models that mirror the Claude SDK types from the
 official claude-code-sdk-python repository. These models enable strong typing
 throughout the proxy system and provide runtime validation.
 
-Based on: https://github.com/anthropics/claude-code-sdk-python/blob/main/src/claude_code_sdk/types.py
+Based on: https://github.com/anthropics/claude-code-sdk-python/blob/main/src/claude_agent_sdk/types.py
 """
 
 from __future__ import annotations
@@ -12,12 +12,12 @@ from __future__ import annotations
 from typing import Annotated, Any, Literal, TypeVar, cast
 
 # Import Claude SDK types for isinstance checks
-from claude_code_sdk import TextBlock as SDKTextBlock
-from claude_code_sdk import ToolResultBlock as SDKToolResultBlock
-from claude_code_sdk import ToolUseBlock as SDKToolUseBlock
+from claude_agent_sdk import TextBlock as SDKTextBlock
+from claude_agent_sdk import ToolResultBlock as SDKToolResultBlock
+from claude_agent_sdk import ToolUseBlock as SDKToolUseBlock
 from pydantic import BaseModel, ConfigDict, Field, field_validator
 
-from ccproxy.models.requests import Usage
+from ccproxy.llms.models import anthropic as anthropic_models
 
 
 # Type variables for generic functions
@@ -69,7 +69,7 @@ class ToolUseBlock(BaseModel):
             "id": self.id,
             "name": self.name,
             "input": self.input,
-            "source": "claude_code_sdk",
+            "source": "claude_agent_sdk",
         }
 
 
@@ -96,7 +96,7 @@ class ToolResultBlock(BaseModel):
             "tool_use_id": self.tool_use_id,
             "content": self.content,
             "is_error": self.is_error,
-            "source": "claude_code_sdk",
+            "source": "claude_agent_sdk",
         }
 
 
@@ -259,7 +259,6 @@ class ResultMessage(BaseModel):
     )
     result: str | None = Field(None, description="Result string if available")
 
-    # Add computed properties for backward compatibility
     @property
     def stop_reason(self) -> str:
         """Get stop reason from result or default to end_turn."""
@@ -268,11 +267,11 @@ class ResultMessage(BaseModel):
         return "end_turn"
 
     @property
-    def usage_model(self) -> Usage:
-        """Get usage information as a Usage model for backward compatibility."""
+    def usage_model(self) -> anthropic_models.Usage:
+        """Get usage information as a Usage model."""
         if self.usage is None:
-            return Usage()
-        return Usage.model_validate(self.usage)
+            return anthropic_models.Usage(input_tokens=0, output_tokens=0)
+        return anthropic_models.Usage.model_validate(self.usage)
 
     model_config = ConfigDict(extra="allow")
 
@@ -282,7 +281,7 @@ class SDKMessageMode(SystemMessage):
     """Custom content block for system messages with source attribution."""
 
     type: Literal["system_message"] = "system_message"
-    source: str = "claude_code_sdk"
+    source: str = "claude_agent_sdk"
 
     model_config = ConfigDict(extra="allow")
 
@@ -294,7 +293,7 @@ class ToolUseSDKBlock(BaseModel):
     id: str = Field(..., description="Unique identifier for the tool use")
     name: str = Field(..., description="Name of the tool being used")
     input: dict[str, Any] = Field(..., description="Input parameters for the tool")
-    source: str = "claude_code_sdk"
+    source: str = "claude_agent_sdk"
 
 
 class ToolResultSDKBlock(BaseModel):
@@ -310,14 +309,14 @@ class ToolResultSDKBlock(BaseModel):
     is_error: bool | None = Field(
         None, description="Whether this result represents an error"
     )
-    source: str = "claude_code_sdk"
+    source: str = "claude_agent_sdk"
 
 
 class ResultMessageBlock(ResultMessage):
     """Custom content block for result messages with session data."""
 
     type: Literal["result_message"] = "result_message"
-    source: str = "claude_code_sdk"
+    source: str = "claude_agent_sdk"
 
 
 # Union type for all custom content blocks
@@ -337,6 +336,53 @@ SDKContentBlock = Annotated[
 # Extended content block type that includes both SDK and custom blocks
 ExtendedContentBlock = SDKContentBlock
 
+# Union definition moved after imports
+
+
+# Plugin-specific content block union that includes core and SDK-specific types
+# Note: We only include SDK-specific types to avoid discriminator conflicts
+# with core types that have the same discriminator values
+CCProxyContentBlock = Annotated[
+    anthropic_models.RequestContentBlock
+    | SDKMessageMode
+    | ToolUseSDKBlock
+    | ToolResultSDKBlock
+    | ResultMessageBlock,
+    Field(discriminator="type"),
+]
+
+
+# Plugin-specific MessageResponse that uses the extended content block types
+class MessageResponse(BaseModel):
+    """Plugin-specific response model that supports both core and SDK content blocks."""
+
+    id: Annotated[str, Field(description="Unique identifier for the message")]
+    type: Annotated[Literal["message"], Field(description="Response type")] = "message"
+    role: Annotated[Literal["assistant"], Field(description="Message role")] = (
+        "assistant"
+    )
+    content: Annotated[
+        list[CCProxyContentBlock],
+        Field(description="Array of content blocks in the response"),
+    ]
+    model: Annotated[str, Field(description="The model used for the response")]
+    stop_reason: Annotated[
+        str | None, Field(description="Reason why the model stopped generating")
+    ] = None
+    stop_sequence: Annotated[
+        str | None,
+        Field(description="The stop sequence that triggered stopping (if applicable)"),
+    ] = None
+    usage: Annotated[
+        anthropic_models.Usage, Field(description="Token usage information")
+    ]
+    container: Annotated[
+        dict[str, Any] | None,
+        Field(description="Information about container used in the request"),
+    ] = None
+
+    model_config = ConfigDict(extra="forbid", validate_assignment=True)
+
 
 # SDK Query Message Types
 class SDKMessageContent(BaseModel):
@@ -468,6 +514,8 @@ __all__ = [
     "ResultMessageBlock",
     "SDKContentBlock",
     "ExtendedContentBlock",
+    "CCProxyContentBlock",
+    "MessageResponse",
     # Conversion functions
     "convert_sdk_text_block",
     "convert_sdk_tool_use_block",