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

ccproxy/{services/claude_sdk_service.py → plugins/claude_sdk/handler.py}

@@ -1,90 +1,96 @@
-"""Claude SDK service orchestration for business logic."""
+"""Claude SDK handler for orchestrating SDK operations.
+
+This module contains the core business logic migrated from claude_sdk_service.py,
+handling SDK operations while maintaining clean separation of concerns.
+"""
 
 from collections.abc import AsyncIterator
 from typing import Any
+from uuid import uuid4
 
-import structlog
-from claude_code_sdk import ClaudeCodeOptions
+from claude_agent_sdk import ClaudeAgentOptions
 
 from ccproxy.auth.manager import AuthManager
-from ccproxy.claude_sdk.client import ClaudeSDKClient
-from ccproxy.claude_sdk.converter import MessageConverter
-from ccproxy.claude_sdk.exceptions import StreamTimeoutError
-from ccproxy.claude_sdk.manager import SessionManager
-from ccproxy.claude_sdk.options import OptionsHandler
-from ccproxy.claude_sdk.streaming import ClaudeStreamProcessor
-from ccproxy.config.claude import SDKMessageMode
-from ccproxy.config.settings import Settings
-from ccproxy.core.errors import (
-    ClaudeProxyError,
-    ServiceUnavailableError,
-)
-from ccproxy.models import claude_sdk as sdk_models
-from ccproxy.models.claude_sdk import SDKMessage, create_sdk_message
-from ccproxy.models.messages import MessageResponse
-from ccproxy.observability.context import RequestContext
-from ccproxy.observability.metrics import PrometheusMetrics
-from ccproxy.utils.model_mapping import map_model_to_claude
-from ccproxy.utils.simple_request_logger import write_request_log
-
-
-logger = structlog.get_logger(__name__)
-
-
-class ClaudeSDKService:
+from ccproxy.core.errors import ClaudeProxyError, ServiceUnavailableError
+from ccproxy.core.logging import get_plugin_logger
+from ccproxy.core.request_context import RequestContext
+from ccproxy.llms.models import anthropic as anthropic_models
+
+# from ccproxy.observability.metrics import  # Metrics moved to plugin PrometheusMetrics
+from ccproxy.utils.model_mapper import ModelMapper, add_model_alias
+
+from . import models as sdk_models
+from .client import ClaudeSDKClient
+from .config import ClaudeSDKSettings, SDKMessageMode
+from .converter import MessageConverter
+from .exceptions import StreamTimeoutError
+from .hooks import ClaudeSDKStreamingHook
+from .manager import SessionManager
+from .models import MessageResponse, SDKMessage, create_sdk_message
+from .options import OptionsHandler
+from .streaming import ClaudeStreamProcessor
+
+
+logger = get_plugin_logger()
+
+
+def _convert_sdk_message_mode(core_mode: Any) -> SDKMessageMode:
+    """Convert core SDKMessageMode to plugin SDKMessageMode."""
+    if hasattr(core_mode, "value"):
+        # Convert enum value to plugin enum
+        if core_mode.value == "forward":
+            return SDKMessageMode.FORWARD
+        elif core_mode.value == "ignore":
+            return SDKMessageMode.IGNORE
+        elif core_mode.value == "formatted":
+            return SDKMessageMode.FORMATTED
+    return SDKMessageMode.FORWARD  # Default fallback
+
+
+class ClaudeSDKHandler:
     """
-    Service layer for Claude SDK operations orchestration.
+    Handler for Claude SDK operations orchestration.
 
-    This class handles business logic coordination between the pure SDK client,
-    authentication, metrics, and format conversion while maintaining clean
-    separation of concerns.
+    This class encapsulates the business logic for SDK operations,
+    migrated from the original claude_sdk_service.py.
     """
 
     def __init__(
         self,
+        config: ClaudeSDKSettings,
         sdk_client: ClaudeSDKClient | None = None,
         auth_manager: AuthManager | None = None,
-        metrics: PrometheusMetrics | None = None,
-        settings: Settings | None = None,
+        metrics: Any | None = None,  # Metrics now handled by metrics plugin
         session_manager: SessionManager | None = None,
+        hook_manager: Any | None = None,  # HookManager for emitting events
     ) -> None:
-        """
-        Initialize Claude SDK service.
-
-        Args:
-            sdk_client: Claude SDK client instance
-            auth_manager: Authentication manager (optional)
-            metrics: Prometheus metrics instance (optional)
-            settings: Application settings (optional)
-            session_manager: Session manager for dependency injection (optional)
-        """
+        """Initialize Claude SDK handler."""
+        self.config = config
         self.sdk_client = sdk_client or ClaudeSDKClient(
-            settings=settings, session_manager=session_manager
+            config=config, session_manager=session_manager
         )
         self.auth_manager = auth_manager
         self.metrics = metrics
-        self.settings = settings
+        self.hook_manager = hook_manager
         self.message_converter = MessageConverter()
-        self.options_handler = OptionsHandler(settings=settings)
+        self.options_handler = OptionsHandler(config=config)
+        self.model_mapper = ModelMapper(config.model_mappings)
+
+        # Create streaming hook if hook_manager is available
+        streaming_hook = None
+        if hook_manager:
+            streaming_hook = ClaudeSDKStreamingHook(hook_manager=hook_manager)
+
         self.stream_processor = ClaudeStreamProcessor(
             message_converter=self.message_converter,
             metrics=self.metrics,
+            streaming_hook=streaming_hook,
         )
 
     def _convert_messages_to_sdk_message(
         self, messages: list[dict[str, Any]], session_id: str | None = None
-    ) -> "SDKMessage":
-        """Convert list of Anthropic messages to single SDKMessage.
-
-        Takes the last user message from the list and converts it to SDKMessage format.
-
-        Args:
-            messages: List of Anthropic API messages
-            session_id: Optional session ID for conversation continuity
-
-        Returns:
-            SDKMessage ready to send to Claude SDK
-        """
+    ) -> SDKMessage:
+        """Convert list of Anthropic messages to single SDKMessage."""
         # Find the last user message
         last_user_message = None
         for msg in reversed(messages):
@@ -117,15 +123,9 @@ class ClaudeSDKService:
         self,
         ctx: RequestContext,
         session_id: str | None,
-        options: "ClaudeCodeOptions",
+        options: ClaudeAgentOptions,
     ) -> None:
-        """Capture session metadata for access logging.
-
-        Args:
-            ctx: Request context to add metadata to
-            session_id: Optional session ID
-            options: Claude Code options
-        """
+        """Capture session metadata for access logging."""
         if (
             session_id
             and hasattr(self.sdk_client, "_session_manager")
@@ -167,13 +167,14 @@ class ClaudeSDKService:
                     "failed_to_capture_session_metadata",
                     session_id=session_id,
                     error=str(e),
+                    exc_info=e,
                 )
         else:
-            # Add basic session metadata for direct connections (no session pool)
+            # Add basic session metadata for direct connections
             ctx.add_metadata(
                 session_type="direct",
                 session_pool_enabled=False,
-                session_is_new=True,  # Direct connections are always new
+                session_is_new=True,
             )
 
     async def create_completion(
@@ -187,32 +188,19 @@ class ClaudeSDKService:
         session_id: str | None = None,
         **kwargs: Any,
     ) -> MessageResponse | AsyncIterator[dict[str, Any]]:
-        """
-        Create a completion using Claude SDK with business logic orchestration.
-
-        Args:
-            messages: List of messages in Anthropic format
-            model: The model to use
-            temperature: Temperature for response generation
-            max_tokens: Maximum tokens in response
-            stream: Whether to stream responses
-            session_id: Optional session ID for Claude SDK integration
-            request_context: Existing request context to use instead of creating new one
-            **kwargs: Additional arguments
-
-        Returns:
-            Response dict or async iterator of response chunks if streaming
-
-        Raises:
-            ClaudeProxyError: If request fails
-            ServiceUnavailableError: If service is unavailable
-        """
-
+        """Create a completion using Claude SDK with business logic orchestration."""
         # Extract system message and create options
         system_message = self.options_handler.extract_system_message(messages)
 
-        # Map model to Claude model
-        model = map_model_to_claude(model)
+        if isinstance(request_context, RequestContext):
+            metadata = request_context.metadata
+        else:
+            metadata = None
+
+        match = self.model_mapper.map(model)
+        if match.mapped != match.original and isinstance(metadata, dict):
+            add_model_alias(metadata, match.original, match.mapped)
+        model = match.mapped
 
         options = self.options_handler.create_options(
             model=model,
@@ -223,9 +211,7 @@ class ClaudeSDKService:
             **kwargs,
         )
 
-        # Messages will be converted to SDK format in the client layer
-
-        # Use existing context, but update metadata for this service (preserve original service_type)
+        # Use existing context
         ctx = request_context
         metadata = {
             "endpoint": "messages",
@@ -235,19 +221,13 @@ class ClaudeSDKService:
         if session_id:
             metadata["session_id"] = session_id
         ctx.add_metadata(**metadata)
-        # Use existing request ID from context
         request_id = ctx.request_id
 
         try:
-            # Log SDK request parameters
+            # Removed SDK request logging (simple_request_logger removed)
             timestamp = ctx.get_log_timestamp_prefix() if ctx else None
-            await self._log_sdk_request(
-                request_id, messages, options, model, stream, session_id, timestamp
-            )
 
             if stream:
-                # For streaming, return the async iterator directly
-                # Access logging will be handled by the stream processor when ResultMessage is received
                 return self._stream_completion(
                     ctx, messages, options, model, session_id, timestamp
                 )
@@ -257,7 +237,6 @@ class ClaudeSDKService:
                 )
                 return result
         except (ClaudeProxyError, ServiceUnavailableError) as e:
-            # Add error info to context for automatic access logging
             ctx.add_metadata(error_message=str(e), error_type=type(e).__name__)
             raise
 
@@ -265,27 +244,14 @@ class ClaudeSDKService:
         self,
         ctx: RequestContext,
         messages: list[dict[str, Any]],
-        options: "ClaudeCodeOptions",
+        options: ClaudeAgentOptions,
         model: str,
         session_id: str | None = None,
         timestamp: str | None = None,
     ) -> MessageResponse:
-        """
-        Complete a non-streaming request with business logic.
-
-        Args:
-            prompt: The formatted prompt
-            options: Claude SDK options
-            model: The model being used
-
-        Returns:
-            Response in Anthropic format
-
-        Raises:
-            ClaudeProxyError: If completion fails
-        """
+        """Complete a non-streaming request with business logic."""
         request_id = ctx.request_id
-        logger.debug("claude_sdk_completion_start", request_id=request_id)
+        logger.debug("completion_start", request_id=request_id)
 
         # Convert messages to single SDKMessage
         sdk_message = self._convert_messages_to_sdk_message(messages, session_id)
@@ -295,7 +261,7 @@ class ClaudeSDKService:
             sdk_message, options, request_id, session_id
         )
 
-        # Capture session metadata for access logging
+        # Capture session metadata
         await self._capture_session_metadata(ctx, session_id, options)
 
         # Create a listener and collect all messages
@@ -325,13 +291,13 @@ class ClaudeSDKService:
                 status_code=500,
             )
 
-        logger.debug("claude_sdk_completion_received")
+        logger.debug("completion_received")
         mode = (
-            self.settings.claude.sdk_message_mode
-            if self.settings
+            _convert_sdk_message_mode(self.config.sdk_message_mode)
+            if self.config
             else SDKMessageMode.FORWARD
         )
-        pretty_format = self.settings.claude.pretty_format if self.settings else True
+        pretty_format = self.config.pretty_format if self.config else True
 
         response = self.message_converter.convert_to_anthropic_response(
             assistant_message, result_message, model, mode, pretty_format
@@ -358,19 +324,19 @@ class ClaudeSDKService:
                         },
                     )
                     if content_block:
-                        # Only validate as SDKMessageMode if it's a system_message type
                         if content_block.get("type") == "system_message":
                             response.content.append(
                                 sdk_models.SDKMessageMode.model_validate(content_block)
                             )
                         else:
-                            # For other types (like text blocks in FORMATTED mode), create appropriate content block
                             if content_block.get("type") == "text":
+                                # Convert SDK TextBlock to core TextContentBlock
                                 response.content.append(
-                                    sdk_models.TextBlock.model_validate(content_block)
+                                    anthropic_models.TextBlock(
+                                        type="text", text=content_block["text"]
+                                    )
                                 )
                             else:
-                                # Fallback for other content block types
                                 logger.warning(
                                     "unknown_content_block_type",
                                     content_block_type=content_block.get("type"),
@@ -378,14 +344,20 @@ class ClaudeSDKService:
                 elif isinstance(message, sdk_models.UserMessage):
                     for block in message.content:
                         if isinstance(block, sdk_models.ToolResultBlock):
-                            response.content.append(block)
+                            # Convert SDK ToolResultBlock to ToolResultSDKBlock
+                            response.content.append(
+                                sdk_models.ToolResultSDKBlock(
+                                    type="tool_result_sdk",
+                                    tool_use_id=block.tool_use_id,
+                                    content=block.content,
+                                    is_error=block.is_error,
+                                    source="claude_agent_sdk",
+                                )
+                            )
 
         cost_usd = result_message.total_cost_usd
         usage = result_message.usage_model
 
-        # if cost_usd is not None and response.usage:
-        #     response.usage.cost_usd = cost_usd
-
         logger.debug(
             "claude_sdk_completion_completed",
             model=model,
@@ -407,12 +379,6 @@ class ClaudeSDKService:
             session_id=result_message.session_id,
             num_turns=result_message.num_turns,
         )
-        # Add success status to context for automatic access logging
-        ctx.add_metadata(status_code=200)
-
-        # Log SDK response
-        if request_id:
-            await self._log_sdk_response(request_id, response, timestamp)
 
         return response
 
@@ -420,40 +386,29 @@ class ClaudeSDKService:
         self,
         ctx: RequestContext,
         messages: list[dict[str, Any]],
-        options: "ClaudeCodeOptions",
+        options: ClaudeAgentOptions,
         model: str,
         session_id: str | None = None,
         timestamp: str | None = None,
     ) -> AsyncIterator[dict[str, Any]]:
-        """
-        Stream completion responses with business logic.
-
-        Args:
-            prompt: The formatted prompt
-            options: Claude SDK options
-            model: The model being used
-            ctx: Optional request context for metrics
-
-        Yields:
-            Response chunks in Anthropic format
-        """
+        """Stream completion responses with business logic."""
         request_id = ctx.request_id
         sdk_message_mode = (
-            self.settings.claude.sdk_message_mode
-            if self.settings
+            _convert_sdk_message_mode(self.config.sdk_message_mode)
+            if self.config
             else SDKMessageMode.FORWARD
         )
-        pretty_format = self.settings.claude.pretty_format if self.settings else True
+        pretty_format = self.config.pretty_format if self.config else True
 
         # Convert messages to single SDKMessage
         sdk_message = self._convert_messages_to_sdk_message(messages, session_id)
 
-        # Get stream handle instead of direct iterator
+        # Get stream handle
         stream_handle = await self.sdk_client.query_completion(
             sdk_message, options, request_id, session_id
         )
 
-        # Store handle in session client if available for cleanup
+        # Store handle in session client if available
         if (
             session_id
             and hasattr(self.sdk_client, "_session_manager")
@@ -472,9 +427,10 @@ class ClaudeSDKService:
                     "failed_to_store_stream_handle",
                     session_id=session_id,
                     error=str(e),
+                    exc_info=e,
                 )
 
-        # Capture session metadata for access logging
+        # Capture session metadata
         await self._capture_session_metadata(ctx, session_id, options)
 
         # Create a listener for this stream
@@ -489,19 +445,13 @@ class ClaudeSDKService:
                 sdk_message_mode=sdk_message_mode,
                 pretty_format=pretty_format,
             ):
-                # Log streaming chunk
-                if request_id:
-                    await self._log_sdk_streaming_chunk(request_id, chunk, timestamp)
                 yield chunk
         except GeneratorExit:
-            # Client disconnected - log and re-raise to propagate to create_listener()
-            logger.info(
-                "claude_sdk_service_client_disconnected",
+            logger.debug(
+                "claude_sdk_handler_client_disconnected",
                 request_id=request_id,
                 session_id=session_id,
-                message="Client disconnected from SDK service stream, propagating to stream handle",
             )
-            # CRITICAL: Re-raise GeneratorExit to trigger interrupt in create_listener()
             raise
         except StreamTimeoutError as e:
             # Send error events to the client
@@ -513,12 +463,9 @@ class ClaudeSDKService:
                 request_id=request_id,
             )
 
-            # Create a unique message ID for the error response
-            from uuid import uuid4
-
             error_message_id = f"msg_error_{uuid4()}"
 
-            # Yield message_start event
+            # Yield error events
             yield {
                 "type": "message_start",
                 "message": {
@@ -533,14 +480,12 @@ class ClaudeSDKService:
                 },
             }
 
-            # Yield content_block_start for error message
             yield {
                 "type": "content_block_start",
                 "index": 0,
                 "content_block": {"type": "text", "text": ""},
             }
 
-            # Yield error text delta
             error_text = f"Error: {e}"
             yield {
                 "type": "content_block_delta",
@@ -548,136 +493,25 @@ class ClaudeSDKService:
                 "delta": {"type": "text_delta", "text": error_text},
             }
 
-            # Yield content_block_stop
-            yield {
-                "type": "content_block_stop",
-                "index": 0,
-            }
+            yield {"type": "content_block_stop", "index": 0}
 
-            # Yield message_delta with stop reason
             yield {
                 "type": "message_delta",
                 "delta": {"stop_reason": "error", "stop_sequence": None},
                 "usage": {"output_tokens": len(error_text.split())},
             }
 
-            # Yield message_stop
-            yield {
-                "type": "message_stop",
-            }
+            yield {"type": "message_stop"}
 
-            # Update context with error status
             ctx.add_metadata(
-                status_code=504,  # Gateway Timeout
+                status_code=504,
                 error_message=str(e),
                 error_type="stream_timeout",
                 session_id=e.session_id,
             )
 
-    async def _log_sdk_request(
-        self,
-        request_id: str,
-        messages: list[dict[str, Any]],
-        options: "ClaudeCodeOptions",
-        model: str,
-        stream: bool,
-        session_id: str | None = None,
-        timestamp: str | None = None,
-    ) -> None:
-        """Log SDK input parameters as JSON dump.
-
-        Args:
-            request_id: Request identifier
-            messages: List of Anthropic API messages
-            options: Claude SDK options
-            model: The model being used
-            stream: Whether streaming is enabled
-            session_id: Optional session ID for Claude SDK integration
-            timestamp: Optional timestamp prefix
-        """
-        # timestamp is already provided from context, no need for fallback
-
-        # JSON dump of the parameters passed to SDK completion
-        sdk_request_data = {
-            "messages": messages,
-            "options": options,
-            "stream": stream,
-            "request_id": request_id,
-        }
-        if session_id:
-            sdk_request_data["session_id"] = session_id
-
-        await write_request_log(
-            request_id=request_id,
-            log_type="sdk_request",
-            data=sdk_request_data,
-            timestamp=timestamp,
-        )
-
-    async def _log_sdk_response(
-        self,
-        request_id: str,
-        result: Any,
-        timestamp: str | None = None,
-    ) -> None:
-        """Log SDK response result as JSON dump.
-
-        Args:
-            request_id: Request identifier
-            result: The result from _complete_non_streaming
-            timestamp: Optional timestamp prefix
-        """
-        # timestamp is already provided from context, no need for fallback
-
-        # JSON dump of the result from _complete_non_streaming
-        sdk_response_data = {
-            "result": result.model_dump()
-            if hasattr(result, "model_dump")
-            else str(result),
-        }
-
-        await write_request_log(
-            request_id=request_id,
-            log_type="sdk_response",
-            data=sdk_response_data,
-            timestamp=timestamp,
-        )
-
-    async def _log_sdk_streaming_chunk(
-        self,
-        request_id: str,
-        chunk: dict[str, Any],
-        timestamp: str | None = None,
-    ) -> None:
-        """Log streaming chunk as JSON dump.
-
-        Args:
-            request_id: Request identifier
-            chunk: The streaming chunk from process_stream
-            timestamp: Optional timestamp prefix
-        """
-        # timestamp is already provided from context, no need for fallback
-
-        # Append streaming chunk as JSON to raw file
-        import json
-
-        from ccproxy.utils.simple_request_logger import append_streaming_log
-
-        chunk_data = json.dumps(chunk, default=str) + "\n"
-        await append_streaming_log(
-            request_id=request_id,
-            log_type="sdk_streaming",
-            data=chunk_data.encode("utf-8"),
-            timestamp=timestamp,
-        )
-
     async def validate_health(self) -> bool:
-        """
-        Validate that the service is healthy.
-
-        Returns:
-            True if healthy, False otherwise
-        """
+        """Validate that the handler is healthy."""
         try:
             return await self.sdk_client.validate_health()
         except Exception as e:
@@ -685,29 +519,14 @@ class ClaudeSDKService:
                 "health_check_failed",
                 error=str(e),
                 error_type=type(e).__name__,
-                exc_info=True,
+                exc_info=e,
             )
             return False
 
     async def interrupt_session(self, session_id: str) -> bool:
-        """Interrupt a Claude session due to client disconnection.
-
-        Args:
-            session_id: The session ID to interrupt
-
-        Returns:
-            True if session was found and interrupted, False otherwise
-        """
+        """Interrupt a Claude session due to client disconnection."""
         return await self.sdk_client.interrupt_session(session_id)
 
     async def close(self) -> None:
-        """Close the service and cleanup resources."""
+        """Close the handler and cleanup resources."""
         await self.sdk_client.close()
-
-    async def __aenter__(self) -> "ClaudeSDKService":
-        """Async context manager entry."""
-        return self
-
-    async def __aexit__(self, exc_type: Any, exc_val: Any, exc_tb: Any) -> None:
-        """Async context manager exit."""
-        await self.close()