ccproxy-api 0.1.1__py3-none-any.whl → 0.1.3__py3-none-any.whl

ccproxy/claude_sdk/options.py

@@ -2,25 +2,39 @@
 
 from typing import Any
 
+import structlog
+
+from ccproxy.config.settings import Settings
 from ccproxy.core.async_utils import patched_typing
 
 
 with patched_typing():
     from claude_code_sdk import ClaudeCodeOptions
 
+logger = structlog.get_logger(__name__)
+
 
 class OptionsHandler:
     """
     Handles creation and management of Claude SDK options.
     """
 
-    @staticmethod
+    def __init__(self, settings: Settings | None = None) -> None:
+        """
+        Initialize options handler.
+
+        Args:
+            settings: Application settings containing default Claude options
+        """
+        self.settings = settings
+
     def create_options(
+        self,
         model: str,
         temperature: float | None = None,
         max_tokens: int | None = None,
         system_message: str | None = None,
-        **kwargs: Any,
+        **additional_options: Any,
     ) -> ClaudeCodeOptions:
         """
         Create Claude SDK options from API parameters.
@@ -30,24 +44,79 @@ class OptionsHandler:
             temperature: Temperature for response generation
             max_tokens: Maximum tokens in response
             system_message: System message to include
-            **kwargs: Additional options
+            **additional_options: Additional options to set on the ClaudeCodeOptions instance
 
         Returns:
             Configured ClaudeCodeOptions instance
         """
-        options = ClaudeCodeOptions(model=model)
-
-        if temperature is not None:
-            options.temperature = temperature  # type: ignore[attr-defined]
-
-        if max_tokens is not None:
-            options.max_tokens = max_tokens  # type: ignore[attr-defined]
-
+        # Start with configured defaults if available, otherwise create fresh instance
+        if self.settings and self.settings.claude.code_options:
+            # Use the configured options as base - this preserves all default settings
+            # including complex objects like mcp_servers and permission_prompt_tool_name
+            configured_opts = self.settings.claude.code_options
+
+            # Create a new instance with the same configuration
+            # We need to extract the configuration values properly with type safety
+
+            # Extract configuration values with proper types
+            mcp_servers = (
+                configured_opts.mcp_servers.copy()
+                if configured_opts.mcp_servers
+                else {}
+            )
+            permission_prompt_tool_name = configured_opts.permission_prompt_tool_name
+            max_thinking_tokens = getattr(configured_opts, "max_thinking_tokens", None)
+            allowed_tools = getattr(configured_opts, "allowed_tools", None)
+            disallowed_tools = getattr(configured_opts, "disallowed_tools", None)
+            cwd = getattr(configured_opts, "cwd", None)
+            append_system_prompt = getattr(
+                configured_opts, "append_system_prompt", None
+            )
+            max_turns = getattr(configured_opts, "max_turns", None)
+            continue_conversation = getattr(
+                configured_opts, "continue_conversation", None
+            )
+            permission_mode = getattr(configured_opts, "permission_mode", None)
+
+            # Build ClaudeCodeOptions with proper type handling
+            # Start with a basic instance and set attributes individually for type safety
+            options = ClaudeCodeOptions(
+                mcp_servers=mcp_servers,
+                permission_prompt_tool_name=permission_prompt_tool_name,
+            )
+
+            # Set additional attributes if they exist and are not None
+            if max_thinking_tokens is not None:
+                options.max_thinking_tokens = int(max_thinking_tokens)
+            if allowed_tools is not None:
+                options.allowed_tools = list(allowed_tools)
+            if disallowed_tools is not None:
+                options.disallowed_tools = list(disallowed_tools)
+            if cwd is not None:
+                options.cwd = cwd
+            if append_system_prompt is not None:
+                options.append_system_prompt = append_system_prompt
+            if max_turns is not None:
+                options.max_turns = max_turns
+            if continue_conversation is not None:
+                options.continue_conversation = bool(continue_conversation)
+            if permission_mode is not None:
+                options.permission_mode = permission_mode
+        else:
+            options = ClaudeCodeOptions()
+
+        # Override the model (API parameter takes precedence)
+        options.model = model
+
+        # Apply system message if provided (this is supported by ClaudeCodeOptions)
         if system_message is not None:
             options.system_prompt = system_message
 
-        # Handle other options as needed
-        for key, value in kwargs.items():
+        # Note: temperature and max_tokens are API-level parameters, not ClaudeCodeOptions parameters
+        # These are handled at the API request level, not in the options object
+
+        # Handle additional options as needed
+        for key, value in additional_options.items():
             if hasattr(options, key):
                 setattr(options, key, value)
 
@@ -86,11 +155,11 @@ class OptionsHandler:
             List of supported model names
         """
         # Import here to avoid circular imports
-        from ccproxy.adapters.openai.adapter import OPENAI_TO_CLAUDE_MODEL_MAPPING
+        from ccproxy.utils.model_mapping import get_supported_claude_models
 
-        # Extract unique Claude models from OpenAI mapping
-        claude_models = list(set(OPENAI_TO_CLAUDE_MODEL_MAPPING.values()))
-        return sorted(claude_models)
+        # Get supported Claude models
+        claude_models = get_supported_claude_models()
+        return claude_models
 
     @staticmethod
     def validate_model(model: str) -> bool:
@@ -108,10 +177,10 @@ class OptionsHandler:
     @staticmethod
     def get_default_options() -> dict[str, Any]:
         """
-        Get default options for Claude SDK.
+        Get default options for API parameters.
 
         Returns:
-            Dictionary of default options
+            Dictionary of default API parameter values
         """
         return {
             "model": "claude-3-5-sonnet-20241022",

ccproxy/claude_sdk/parser.py

@@ -0,0 +1,200 @@
+"""Centralized XML parser for Claude SDK formatted content.
+
+This module provides parsing functions for XML-formatted SDK content that appears
+in Claude Code SDK responses. It consolidates the parsing logic that was previously
+duplicated across OpenAI adapter and streaming components.
+
+Currently not usedd but could be useful to rebuild message
+for turn to turn conversation.
+"""
+
+from __future__ import annotations
+
+import json
+import re
+from typing import Any
+
+from ccproxy.adapters.openai.models import format_openai_tool_call
+
+
+def parse_system_message_tags(text: str) -> str:
+    """Parse and format system_message XML tags.
+
+    Args:
+        text: Text content that may contain system_message XML tags
+
+    Returns:
+        Text with system_message tags converted to readable format
+    """
+    system_pattern = r"<system_message>(.*?)</system_message>"
+
+    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")
+            system_text = system_data.get("text", "")
+            return f"[{source}]: {system_text}"
+        except json.JSONDecodeError:
+            # Keep original if parsing fails
+            return match.group(0)
+
+    return re.sub(system_pattern, replace_system_message, text, flags=re.DOTALL)
+
+
+def parse_tool_use_sdk_tags(
+    text: str, collect_tool_calls: bool = False
+) -> tuple[str, list[Any]]:
+    """Parse and format tool_use_sdk XML tags.
+
+    Args:
+        text: Text content that may contain tool_use_sdk XML tags
+        collect_tool_calls: Whether to collect tool calls for OpenAI format conversion
+
+    Returns:
+        Tuple of (processed_text, tool_calls_list)
+    """
+    tool_use_pattern = r"<tool_use_sdk>(.*?)</tool_use_sdk>"
+    tool_calls = []
+
+    def replace_tool_use(match: re.Match[str]) -> str:
+        try:
+            tool_data = json.loads(match.group(1))
+
+            if collect_tool_calls:
+                # For OpenAI adapter: collect tool calls and remove from text
+                tool_call_block = {
+                    "type": "tool_use",
+                    "id": tool_data.get("id", ""),
+                    "name": tool_data.get("name", ""),
+                    "input": tool_data.get("input", {}),
+                }
+                tool_calls.append(format_openai_tool_call(tool_call_block))
+                return ""  # Remove the XML tag from text
+            else:
+                # For streaming: format as readable text
+                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)})"
+        except json.JSONDecodeError:
+            # Keep original if parsing fails
+            return match.group(0)
+
+    processed_text = re.sub(tool_use_pattern, replace_tool_use, text, flags=re.DOTALL)
+    return processed_text, tool_calls
+
+
+def parse_tool_result_sdk_tags(text: str) -> str:
+    """Parse and format tool_result_sdk XML tags.
+
+    Args:
+        text: Text content that may contain tool_result_sdk XML tags
+
+    Returns:
+        Text with tool_result_sdk tags converted to readable format
+    """
+    tool_result_pattern = r"<tool_result_sdk>(.*?)</tool_result_sdk>"
+
+    def replace_tool_result(match: re.Match[str]) -> str:
+        try:
+            result_data = json.loads(match.group(1))
+            tool_use_id = result_data.get("tool_use_id", "")
+            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}"
+        except json.JSONDecodeError:
+            # Keep original if parsing fails
+            return match.group(0)
+
+    return re.sub(tool_result_pattern, replace_tool_result, text, flags=re.DOTALL)
+
+
+def parse_result_message_tags(text: str) -> str:
+    """Parse and format result_message XML tags.
+
+    Args:
+        text: Text content that may contain result_message XML tags
+
+    Returns:
+        Text with result_message tags converted to readable format
+    """
+    result_message_pattern = r"<result_message>(.*?)</result_message>"
+
+    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")
+            session_id = result_data.get("session_id", "")
+            stop_reason = result_data.get("stop_reason", "")
+            usage = result_data.get("usage", {})
+            cost_usd = result_data.get("total_cost_usd")
+
+            formatted_content = f"[{source} result {session_id}]: stop_reason={stop_reason}, usage={usage}"
+            if cost_usd is not None:
+                formatted_content += f", cost_usd={cost_usd}"
+            return formatted_content
+        except json.JSONDecodeError:
+            # Keep original if parsing fails
+            return match.group(0)
+
+    return re.sub(result_message_pattern, replace_result_message, text, flags=re.DOTALL)
+
+
+def parse_text_tags(text: str) -> str:
+    """Parse and extract content from text XML tags.
+
+    Args:
+        text: Text content that may contain text XML tags
+
+    Returns:
+        Text with text tags unwrapped (inner content extracted)
+    """
+    text_pattern = r"<text>\n?(.*?)\n?</text>"
+
+    def replace_text(match: re.Match[str]) -> str:
+        return match.group(1).strip()
+
+    return re.sub(text_pattern, replace_text, text, flags=re.DOTALL)
+
+
+def parse_formatted_sdk_content(
+    text: str, collect_tool_calls: bool = False
+) -> tuple[str, list[Any]]:
+    """Parse XML-formatted SDK content from text blocks.
+
+    This is the main parsing function that handles all types of XML-formatted
+    SDK content by applying the appropriate parsing functions in sequence.
+
+    Args:
+        text: Text content that may contain XML-formatted SDK data
+        collect_tool_calls: Whether to collect tool calls for OpenAI format conversion
+                           (used by OpenAI adapter, not by streaming processor)
+
+    Returns:
+        Tuple of (cleaned_text, tool_calls_list)
+        - cleaned_text: Text with XML-formatted SDK content converted to readable format
+        - tool_calls_list: List of tool calls (empty if collect_tool_calls=False)
+    """
+    if not text:
+        return text, []
+
+    # Apply all parsing functions in sequence
+    cleaned_text = text
+
+    # Parse system messages
+    cleaned_text = parse_system_message_tags(cleaned_text)
+
+    # Parse tool use blocks (may collect tool calls)
+    cleaned_text, tool_calls = parse_tool_use_sdk_tags(cleaned_text, collect_tool_calls)
+
+    # Parse tool result blocks
+    cleaned_text = parse_tool_result_sdk_tags(cleaned_text)
+
+    # Parse result message blocks
+    cleaned_text = parse_result_message_tags(cleaned_text)
+
+    # Parse text tags (unwrap content) - do this last
+    cleaned_text = parse_text_tags(cleaned_text)
+
+    return cleaned_text.strip(), tool_calls

ccproxy/claude_sdk/streaming.py

@@ -0,0 +1,286 @@
+"""Handles processing of Claude SDK streaming responses."""
+
+from collections.abc import AsyncIterator
+from typing import Any
+from uuid import uuid4
+
+import structlog
+
+from ccproxy.claude_sdk.converter import MessageConverter
+from ccproxy.config.claude import SDKMessageMode
+from ccproxy.models import claude_sdk as sdk_models
+from ccproxy.observability.context import RequestContext
+from ccproxy.observability.metrics import PrometheusMetrics
+
+
+logger = structlog.get_logger(__name__)
+
+
+class ClaudeStreamProcessor:
+    """Processes streaming responses from the Claude SDK."""
+
+    def __init__(
+        self,
+        message_converter: MessageConverter,
+        metrics: PrometheusMetrics | None = None,
+    ) -> None:
+        """Initialize the stream processor.
+
+        Args:
+            message_converter: Converter for message formats.
+            metrics: Prometheus metrics instance.
+        """
+        self.message_converter = message_converter
+        self.metrics = metrics
+
+    async def process_stream(
+        self,
+        sdk_stream: AsyncIterator[
+            sdk_models.UserMessage
+            | sdk_models.AssistantMessage
+            | sdk_models.SystemMessage
+            | sdk_models.ResultMessage
+        ],
+        model: str,
+        request_id: str | None,
+        ctx: RequestContext | None,
+        sdk_message_mode: SDKMessageMode,
+        pretty_format: bool,
+    ) -> AsyncIterator[dict[str, Any]]:
+        """Process the SDK stream and yields Anthropic-compatible streaming chunks.
+
+        Args:
+            sdk_stream: The async iterator of Pydantic SDK messages.
+            model: The model name.
+            request_id: The request ID for correlation.
+            ctx: The request context for observability.
+            sdk_message_mode: The mode for handling system messages.
+            pretty_format: Whether to format content prettily.
+
+        Yields:
+            Anthropic-compatible streaming chunks.
+        """
+        message_id = f"msg_{uuid4()}"
+        content_block_index = 0
+        input_tokens = 0  # Will be updated by ResultMessage
+
+        # Yield start chunks
+        start_chunks = self.message_converter.create_streaming_start_chunks(
+            message_id, model, input_tokens
+        )
+        for _, chunk in start_chunks:
+            yield chunk
+
+        async for message in sdk_stream:
+            logger.debug(
+                "sdk_message_received",
+                message_type=type(message).__name__,
+                request_id=request_id,
+                message_content=message.model_dump()
+                if hasattr(message, "model_dump")
+                else str(message)[:200],
+            )
+
+            if isinstance(message, sdk_models.SystemMessage):
+                logger.debug(
+                    "sdk_system_message_processing",
+                    mode=sdk_message_mode.value,
+                    subtype=message.subtype,
+                    request_id=request_id,
+                )
+                if sdk_message_mode != SDKMessageMode.IGNORE:
+                    chunks = self.message_converter._create_sdk_content_block_chunks(
+                        sdk_object=message,
+                        mode=sdk_message_mode,
+                        index=content_block_index,
+                        pretty_format=pretty_format,
+                        xml_tag="system_message",
+                    )
+                    for _, chunk in chunks:
+                        yield chunk
+                    content_block_index += 1
+
+            elif isinstance(message, sdk_models.AssistantMessage):
+                logger.debug(
+                    "sdk_assistant_message_processing",
+                    content_blocks_count=len(message.content),
+                    block_types=[type(block).__name__ for block in message.content],
+                    request_id=request_id,
+                )
+                for block in message.content:
+                    if isinstance(block, sdk_models.TextBlock):
+                        logger.debug(
+                            "sdk_text_block_processing",
+                            text_length=len(block.text),
+                            text_preview=block.text[:50],
+                            block_index=content_block_index,
+                            request_id=request_id,
+                        )
+                        yield {
+                            "type": "content_block_start",
+                            "index": content_block_index,
+                            "content_block": {"type": "text", "text": ""},
+                        }
+                        yield self.message_converter.create_streaming_delta_chunk(
+                            block.text
+                        )[1]
+                        yield {
+                            "type": "content_block_stop",
+                            "index": content_block_index,
+                        }
+                        content_block_index += 1
+                    elif isinstance(block, sdk_models.ToolUseBlock):
+                        logger.debug(
+                            "sdk_tool_use_block_processing",
+                            tool_id=block.id,
+                            tool_name=block.name,
+                            input_keys=list(block.input.keys()) if block.input else [],
+                            block_index=content_block_index,
+                            mode=sdk_message_mode.value,
+                            request_id=request_id,
+                        )
+                        chunks = (
+                            self.message_converter._create_sdk_content_block_chunks(
+                                sdk_object=block,
+                                mode=sdk_message_mode,
+                                index=content_block_index,
+                                pretty_format=pretty_format,
+                                xml_tag="tool_use_sdk",
+                                sdk_block_converter=lambda obj: obj.to_sdk_block(),
+                            )
+                        )
+                        for _, chunk in chunks:
+                            yield chunk
+                        content_block_index += 1
+                    elif isinstance(block, sdk_models.ToolResultBlock):
+                        logger.debug(
+                            "sdk_tool_result_block_processing",
+                            tool_use_id=block.tool_use_id,
+                            is_error=block.is_error,
+                            content_type=type(block.content).__name__
+                            if block.content
+                            else "None",
+                            content_preview=str(block.content)[:100]
+                            if block.content
+                            else None,
+                            block_index=content_block_index,
+                            mode=sdk_message_mode.value,
+                            request_id=request_id,
+                        )
+                        chunks = (
+                            self.message_converter._create_sdk_content_block_chunks(
+                                sdk_object=block,
+                                mode=sdk_message_mode,
+                                index=content_block_index,
+                                pretty_format=pretty_format,
+                                xml_tag="tool_result_sdk",
+                                sdk_block_converter=lambda obj: obj.to_sdk_block(),
+                            )
+                        )
+                        for _, chunk in chunks:
+                            yield chunk
+                        content_block_index += 1
+
+            elif isinstance(message, sdk_models.UserMessage):
+                logger.debug(
+                    "sdk_user_message_processing",
+                    content_blocks_count=len(message.content),
+                    block_types=[type(block).__name__ for block in message.content],
+                    request_id=request_id,
+                )
+                for block in message.content:
+                    if isinstance(block, sdk_models.ToolResultBlock):
+                        logger.debug(
+                            "sdk_tool_result_block_processing",
+                            tool_use_id=block.tool_use_id,
+                            is_error=block.is_error,
+                            content_type=type(block.content).__name__
+                            if block.content
+                            else "None",
+                            content_preview=str(block.content)[:100]
+                            if block.content
+                            else None,
+                            block_index=content_block_index,
+                            mode=sdk_message_mode.value,
+                            request_id=request_id,
+                        )
+                        chunks = (
+                            self.message_converter._create_sdk_content_block_chunks(
+                                sdk_object=block,
+                                mode=sdk_message_mode,
+                                index=content_block_index,
+                                pretty_format=pretty_format,
+                                xml_tag="tool_result_sdk",
+                                sdk_block_converter=lambda obj: obj.to_sdk_block(),
+                            )
+                        )
+                        for _, chunk in chunks:
+                            yield chunk
+                        content_block_index += 1
+                    # Handle other UserMessage content types if needed in the future
+                    else:
+                        logger.debug(
+                            "sdk_user_message_unsupported_block",
+                            block_type=type(block).__name__,
+                            block_index=content_block_index,
+                            request_id=request_id,
+                        )
+
+            elif isinstance(message, sdk_models.ResultMessage):
+                logger.debug(
+                    "sdk_result_message_processing",
+                    session_id=message.session_id,
+                    stop_reason=message.stop_reason,
+                    is_error=message.is_error,
+                    duration_ms=message.duration_ms,
+                    num_turns=message.num_turns,
+                    total_cost_usd=message.total_cost_usd,
+                    usage_available=message.usage is not None,
+                    mode=sdk_message_mode.value,
+                    request_id=request_id,
+                )
+                if sdk_message_mode != SDKMessageMode.IGNORE:
+                    chunks = self.message_converter._create_sdk_content_block_chunks(
+                        sdk_object=message,
+                        mode=sdk_message_mode,
+                        index=content_block_index,
+                        pretty_format=pretty_format,
+                        xml_tag="system_message",
+                    )
+                    for _, chunk in chunks:
+                        yield chunk
+                    content_block_index += 1
+
+                # Final message, contains metrics
+                if ctx:
+                    usage_model = message.usage_model
+                    ctx.add_metadata(
+                        status_code=200,
+                        tokens_input=usage_model.input_tokens,
+                        tokens_output=usage_model.output_tokens,
+                        cache_read_tokens=usage_model.cache_read_input_tokens,
+                        cache_write_tokens=usage_model.cache_creation_input_tokens,
+                        cost_usd=message.total_cost_usd,
+                    )
+
+                end_chunks = self.message_converter.create_streaming_end_chunks(
+                    stop_reason=message.stop_reason
+                )
+                # Update usage in the delta chunk
+                delta_chunk = end_chunks[0][1]
+                delta_chunk["usage"] = {
+                    "output_tokens": message.usage_model.output_tokens
+                }
+
+                yield delta_chunk
+                yield end_chunks[1][1]  # message_stop
+                break  # End of stream
+            else:
+                logger.warning(  # type: ignore[unreachable]
+                    "sdk_unknown_message_type",
+                    message_type=type(message).__name__,
+                    message_content=str(message)[:200],
+                    request_id=request_id,
+                )
+
+        logger.debug("claude_sdk_stream_processing_completed", request_id=request_id)

ccproxy/cli/commands/__init__.py

@@ -5,4 +5,8 @@ from .config import app as config_app
 from .serve import api
 
 
-__all__ = ["api", "auth_app", "config_app"]
+__all__ = [
+    "api",
+    "auth_app",
+    "config_app",
+]

ccproxy/cli/commands/auth.py

@@ -1,10 +1,9 @@
 """Authentication and credential management commands."""
 
 import asyncio
-import json
-from datetime import UTC, datetime, timezone
+from datetime import UTC, datetime
 from pathlib import Path
-from typing import Annotated, Optional
+from typing import Annotated
 
 import typer
 from rich import box
@@ -12,7 +11,6 @@ from rich.console import Console
 from rich.table import Table
 from structlog import get_logger
 
-from ccproxy.auth.models import ValidationResult
 from ccproxy.cli.helpers import get_rich_toolkit
 from ccproxy.config.settings import get_settings
 from ccproxy.core.async_utils import get_claude_docker_home_dir