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

ccproxy/_version.py

@@ -17,5 +17,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '0.1.2'
-__version_tuple__ = version_tuple = (0, 1, 2)
+__version__ = version = '0.1.3'
+__version_tuple__ = version_tuple = (0, 1, 3)

ccproxy/adapters/openai/__init__.py

@@ -4,7 +4,7 @@ This module provides the OpenAI adapter implementation for converting
 between OpenAI and Anthropic API formats.
 """
 
-from .adapter import OpenAIAdapter, map_openai_model_to_claude
+from .adapter import OpenAIAdapter
 from .models import (
     OpenAIChatCompletionResponse,
     OpenAIChoice,
@@ -24,7 +24,6 @@ from .streaming import OpenAISSEFormatter, OpenAIStreamProcessor
 __all__ = [
     # Adapter
     "OpenAIAdapter",
-    "map_openai_model_to_claude",
     # Models
     "OpenAIMessage",
     "OpenAIMessageContent",

ccproxy/adapters/openai/adapter.py

@@ -9,14 +9,14 @@ from __future__ import annotations
 import json
 import re
 import time
-import uuid
 from collections.abc import AsyncIterator
-from inspect import signature
 from typing import Any, Literal, cast
 
 import structlog
+from pydantic import ValidationError
 
 from ccproxy.core.interfaces import APIAdapter
+from ccproxy.utils.model_mapping import map_model_to_claude
 
 from .models import (
     OpenAIChatCompletionRequest,
@@ -34,81 +34,12 @@ from .streaming import OpenAIStreamProcessor
 logger = structlog.get_logger(__name__)
 
 
-# Model mapping from OpenAI to Claude
-OPENAI_TO_CLAUDE_MODEL_MAPPING: dict[str, str] = {
-    # GPT-4 models -> Claude 3.5 Sonnet (most comparable)
-    "gpt-4": "claude-3-5-sonnet-20241022",
-    "gpt-4-turbo": "claude-3-5-sonnet-20241022",
-    "gpt-4-turbo-preview": "claude-3-5-sonnet-20241022",
-    "gpt-4-1106-preview": "claude-3-5-sonnet-20241022",
-    "gpt-4-0125-preview": "claude-3-5-sonnet-20241022",
-    "gpt-4-turbo-2024-04-09": "claude-3-5-sonnet-20241022",
-    "gpt-4o": "claude-3-7-sonnet-20250219",
-    "gpt-4o-2024-05-13": "claude-3-7-sonnet-20250219",
-    "gpt-4o-2024-08-06": "claude-3-7-sonnet-20250219",
-    "gpt-4o-2024-11-20": "claude-3-7-sonnet-20250219",
-    "gpt-4o-mini": "claude-3-5-haiku-latest",
-    "gpt-4o-mini-2024-07-18": "claude-3-5-haiku-latest",
-    # o1 models -> Claude models that support thinking
-    "o1": "claude-opus-4-20250514",
-    "o1-preview": "claude-opus-4-20250514",
-    "o1-mini": "claude-sonnet-4-20250514",
-    # o3 models -> Claude Opus 4
-    "o3-mini": "claude-opus-4-20250514",
-    # GPT-3.5 models -> Claude 3.5 Haiku (faster, cheaper)
-    "gpt-3.5-turbo": "claude-3-5-haiku-20241022",
-    "gpt-3.5-turbo-16k": "claude-3-5-haiku-20241022",
-    "gpt-3.5-turbo-1106": "claude-3-5-haiku-20241022",
-    "gpt-3.5-turbo-0125": "claude-3-5-haiku-20241022",
-    # Generic fallback
-    "text-davinci-003": "claude-3-5-sonnet-20241022",
-    "text-davinci-002": "claude-3-5-sonnet-20241022",
-}
-
-
-def map_openai_model_to_claude(openai_model: str) -> str:
-    """Map OpenAI model name to Claude model name.
-
-    Args:
-        openai_model: OpenAI model identifier
-
-    Returns:
-        Claude model identifier
-    """
-    # Direct mapping first
-    claude_model = OPENAI_TO_CLAUDE_MODEL_MAPPING.get(openai_model)
-    if claude_model:
-        return claude_model
-
-    # Pattern matching for versioned models
-    if openai_model.startswith("gpt-4o-mini"):
-        return "claude-3-5-haiku-latest"
-    elif openai_model.startswith("gpt-4o") or openai_model.startswith("gpt-4"):
-        return "claude-3-7-sonnet-20250219"
-    elif openai_model.startswith("gpt-3.5"):
-        return "claude-3-5-haiku-latest"
-    elif openai_model.startswith("o1"):
-        return "claude-sonnet-4-20250514"
-    elif openai_model.startswith("o3"):
-        return "claude-opus-4-20250514"
-    elif openai_model.startswith("gpt"):
-        return "claude-sonnet-4-20250514"
-
-    # If it's already a Claude model, pass through unchanged
-    if openai_model.startswith("claude-"):
-        return openai_model
-
-    # For unknown models, pass through unchanged we may change
-    # this to a default model in the future
-    return openai_model
-
-
 class OpenAIAdapter(APIAdapter):
     """OpenAI API adapter for converting between OpenAI and Anthropic formats."""
 
-    def __init__(self) -> None:
+    def __init__(self, include_sdk_content_as_xml: bool = False) -> None:
         """Initialize the OpenAI adapter."""
-        pass
+        self.include_sdk_content_as_xml = include_sdk_content_as_xml
 
     def adapt_request(self, request: dict[str, Any]) -> dict[str, Any]:
         """Convert OpenAI request format to Anthropic format.
@@ -125,18 +56,18 @@ class OpenAIAdapter(APIAdapter):
         try:
             # Parse OpenAI request
             openai_req = OpenAIChatCompletionRequest(**request)
-        except Exception as e:
+        except ValidationError as e:
             raise ValueError(f"Invalid OpenAI request format: {e}") from e
 
         # Map OpenAI model to Claude model
-        model = map_openai_model_to_claude(openai_req.model)
+        model = map_model_to_claude(openai_req.model)
 
         # Convert messages
         messages, system_prompt = self._convert_messages_to_anthropic(
             openai_req.messages
         )
 
-        # Build Anthropic request
+        # Build base Anthropic request
         anthropic_request = {
             "model": model,
             "messages": messages,
@@ -148,6 +79,44 @@ class OpenAIAdapter(APIAdapter):
             anthropic_request["system"] = system_prompt
 
         # Add optional parameters
+        self._handle_optional_parameters(openai_req, anthropic_request)
+
+        # Handle metadata
+        self._handle_metadata(openai_req, anthropic_request)
+
+        # Handle response format
+        anthropic_request = self._handle_response_format(openai_req, anthropic_request)
+
+        # Handle thinking configuration
+        anthropic_request = self._handle_thinking_parameters(
+            openai_req, anthropic_request
+        )
+
+        # Log unsupported parameters
+        self._log_unsupported_parameters(openai_req)
+
+        # Handle tools and tool choice
+        self._handle_tools(openai_req, anthropic_request)
+
+        logger.debug(
+            "format_conversion_completed",
+            from_format="openai",
+            to_format="anthropic",
+            original_model=openai_req.model,
+            anthropic_model=anthropic_request.get("model"),
+            has_tools=bool(anthropic_request.get("tools")),
+            has_system=bool(anthropic_request.get("system")),
+            message_count=len(cast(list[Any], anthropic_request["messages"])),
+            operation="adapt_request",
+        )
+        return anthropic_request
+
+    def _handle_optional_parameters(
+        self,
+        openai_req: OpenAIChatCompletionRequest,
+        anthropic_request: dict[str, Any],
+    ) -> None:
+        """Handle optional parameters like temperature, top_p, stream, and stop."""
         if openai_req.temperature is not None:
             anthropic_request["temperature"] = openai_req.temperature
 
@@ -163,7 +132,12 @@ class OpenAIAdapter(APIAdapter):
             else:
                 anthropic_request["stop_sequences"] = openai_req.stop
 
-        # Handle metadata - combine user field and metadata
+    def _handle_metadata(
+        self,
+        openai_req: OpenAIChatCompletionRequest,
+        anthropic_request: dict[str, Any],
+    ) -> None:
+        """Handle metadata and user field combination."""
         metadata = {}
         if openai_req.user:
             metadata["user_id"] = openai_req.user
@@ -172,11 +146,17 @@ class OpenAIAdapter(APIAdapter):
         if metadata:
             anthropic_request["metadata"] = metadata
 
-        # Handle response format - add to system prompt for JSON mode
+    def _handle_response_format(
+        self,
+        openai_req: OpenAIChatCompletionRequest,
+        anthropic_request: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Handle response format by modifying system prompt for JSON mode."""
         if openai_req.response_format:
             format_type = (
                 openai_req.response_format.type if openai_req.response_format else None
             )
+            system_prompt = anthropic_request.get("system")
 
             if format_type == "json_object" and system_prompt is not None:
                 system_prompt += "\nYou must respond with valid JSON only."
@@ -189,7 +169,14 @@ class OpenAIAdapter(APIAdapter):
                     system_prompt += f"\nYou must respond with valid JSON that conforms to this schema: {openai_req.response_format.json_schema}"
                 anthropic_request["system"] = system_prompt
 
-        # Handle reasoning_effort (o1 models) -> thinking configuration
+        return anthropic_request
+
+    def _handle_thinking_parameters(
+        self,
+        openai_req: OpenAIChatCompletionRequest,
+        anthropic_request: dict[str, Any],
+    ) -> dict[str, Any]:
+        """Handle reasoning_effort and thinking configuration for o1/o3 models."""
         # Automatically enable thinking for o1 models even without explicit reasoning_effort
         if (
             openai_req.reasoning_effort
@@ -263,7 +250,12 @@ class OpenAIAdapter(APIAdapter):
                 operation="adapt_request",
             )
 
-        # Note: seed, logprobs, top_logprobs, and store don't have direct Anthropic equivalents
+        return anthropic_request
+
+    def _log_unsupported_parameters(
+        self, openai_req: OpenAIChatCompletionRequest
+    ) -> None:
+        """Log warnings for unsupported OpenAI parameters."""
         if openai_req.seed is not None:
             logger.debug(
                 "unsupported_parameter_ignored",
@@ -287,6 +279,12 @@ class OpenAIAdapter(APIAdapter):
                 operation="adapt_request",
             )
 
+    def _handle_tools(
+        self,
+        openai_req: OpenAIChatCompletionRequest,
+        anthropic_request: dict[str, Any],
+    ) -> None:
+        """Handle tools, functions, and tool choice conversion."""
         # Handle tools/functions
         if openai_req.tools:
             anthropic_request["tools"] = self._convert_tools_to_anthropic(
@@ -298,6 +296,7 @@ class OpenAIAdapter(APIAdapter):
                 openai_req.functions
             )
 
+        # Handle tool choice
         if openai_req.tool_choice:
             # Convert tool choice - can be string or OpenAIToolChoice object
             if isinstance(openai_req.tool_choice, str):
@@ -319,19 +318,6 @@ class OpenAIAdapter(APIAdapter):
                 openai_req.function_call
             )
 
-        logger.debug(
-            "format_conversion_completed",
-            from_format="openai",
-            to_format="anthropic",
-            original_model=openai_req.model,
-            anthropic_model=anthropic_request.get("model"),
-            has_tools=bool(anthropic_request.get("tools")),
-            has_system=bool(anthropic_request.get("system")),
-            message_count=len(cast(list[Any], anthropic_request["messages"])),
-            operation="adapt_request",
-        )
-        return anthropic_request
-
     def adapt_response(self, response: dict[str, Any]) -> dict[str, Any]:
         """Convert Anthropic response format to OpenAI format.
 
@@ -351,74 +337,19 @@ class OpenAIAdapter(APIAdapter):
             # Generate response ID
             request_id = generate_openai_response_id()
 
-            # Convert content
-            content = ""
-            tool_calls = []
-
-            if "content" in response and response["content"]:
-                for block in response["content"]:
-                    if block.get("type") == "text":
-                        content += block.get("text", "")
-                    elif block.get("type") == "thinking":
-                        # Handle thinking blocks - we can include them with a marker
-                        thinking_text = block.get("thinking", "")
-                        signature = block.get("signature")
-                        if thinking_text:
-                            content += f'<thinking signature="{signature}">{thinking_text}</thinking>'
-                    elif block.get("type") == "tool_use":
-                        tool_calls.append(format_openai_tool_call(block))
-                    else:
-                        logger.warning(
-                            "unsupported_content_block_type", type=block.get("type")
-                        )
+            # Convert content and extract tool calls
+            content, tool_calls = self._convert_content_blocks(response)
 
             # Create OpenAI message
-            # When there are tool calls but no content, use empty string instead of None
-            # Otherwise, if content is empty string, convert to None
-            final_content: str | None = content
-            if tool_calls and not content:
-                final_content = ""
-            elif content == "":
-                final_content = None
-
-            message = OpenAIResponseMessage(
-                role="assistant",
-                content=final_content,
-                tool_calls=tool_calls if tool_calls else None,
-            )
-
-            # Map stop reason
-            finish_reason = self._convert_stop_reason_to_openai(
-                response.get("stop_reason")
-            )
+            message = self._create_openai_message(content, tool_calls)
 
-            # Ensure finish_reason is a valid literal type
-            if finish_reason not in ["stop", "length", "tool_calls", "content_filter"]:
-                finish_reason = "stop"
+            # Create choice with proper finish reason
+            choice = self._create_openai_choice(message, response)
 
-            # Cast to proper literal type
-            valid_finish_reason = cast(
-                Literal["stop", "length", "tool_calls", "content_filter"], finish_reason
-            )
+            # Create usage information
+            usage = self._create_openai_usage(response)
 
-            # Create choice
-            choice = OpenAIChoice(
-                index=0,
-                message=message,
-                finish_reason=valid_finish_reason,
-                logprobs=None,  # Anthropic doesn't support logprobs
-            )
-
-            # Create usage
-            usage_info = response.get("usage", {})
-            usage = OpenAIUsage(
-                prompt_tokens=usage_info.get("input_tokens", 0),
-                completion_tokens=usage_info.get("output_tokens", 0),
-                total_tokens=usage_info.get("input_tokens", 0)
-                + usage_info.get("output_tokens", 0),
-            )
-
-            # Create OpenAI response
+            # Create final OpenAI response
             openai_response = OpenAIChatCompletionResponse(
                 id=request_id,
                 object="chat.completion",
@@ -435,19 +366,134 @@ class OpenAIAdapter(APIAdapter):
                 to_format="openai",
                 response_id=request_id,
                 original_model=original_model,
-                finish_reason=valid_finish_reason,
+                finish_reason=choice.finish_reason,
                 content_length=len(content) if content else 0,
                 tool_calls_count=len(tool_calls),
-                input_tokens=usage_info.get("input_tokens", 0),
-                output_tokens=usage_info.get("output_tokens", 0),
+                input_tokens=usage.prompt_tokens,
+                output_tokens=usage.completion_tokens,
                 operation="adapt_response",
                 choice=choice,
             )
             return openai_response.model_dump()
 
-        except Exception as e:
+        except ValidationError as e:
             raise ValueError(f"Invalid Anthropic response format: {e}") from e
 
+    def _convert_content_blocks(
+        self, response: dict[str, Any]
+    ) -> tuple[str, list[Any]]:
+        """Convert Anthropic content blocks to OpenAI format content and tool calls."""
+        content = ""
+        tool_calls: list[Any] = []
+
+        if "content" in response and response["content"]:
+            for block in response["content"]:
+                if block.get("type") == "text":
+                    text_content = block.get("text", "")
+                    # Forward text content as-is (already formatted if needed)
+                    content += text_content
+                elif block.get("type") == "system_message":
+                    # Handle custom system_message content blocks
+                    system_text = block.get("text", "")
+                    source = block.get("source", "claude_code_sdk")
+                    # Format as text with clear source attribution
+                    content += f"[{source}]: {system_text}"
+                elif block.get("type") == "tool_use_sdk":
+                    # Handle custom tool_use_sdk content blocks - convert to standard tool_calls
+                    tool_call_block = {
+                        "type": "tool_use",
+                        "id": block.get("id", ""),
+                        "name": block.get("name", ""),
+                        "input": block.get("input", {}),
+                    }
+                    tool_calls.append(format_openai_tool_call(tool_call_block))
+                elif block.get("type") == "tool_result_sdk":
+                    # Handle custom tool_result_sdk content blocks - add as text with source attribution
+                    source = block.get("source", "claude_code_sdk")
+                    tool_use_id = block.get("tool_use_id", "")
+                    result_content = block.get("content", "")
+                    is_error = block.get("is_error", False)
+                    error_indicator = " (ERROR)" if is_error else ""
+                    content += f"[{source} tool_result {tool_use_id}{error_indicator}]: {result_content}"
+                elif block.get("type") == "result_message":
+                    # Handle custom result_message content blocks - add as text with source attribution
+                    source = block.get("source", "claude_code_sdk")
+                    result_data = block.get("data", {})
+                    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_text = f"[{source} result {session_id}]: stop_reason={stop_reason}, usage={usage}"
+                    if cost_usd is not None:
+                        formatted_text += f", cost_usd={cost_usd}"
+                    content += formatted_text
+                elif block.get("type") == "thinking":
+                    # Handle thinking blocks - we can include them with a marker
+                    thinking_text = block.get("thinking", "")
+                    signature = block.get("signature")
+                    if thinking_text:
+                        content += f'<thinking signature="{signature}">{thinking_text}</thinking>'
+                elif block.get("type") == "tool_use":
+                    # Handle legacy tool_use content blocks
+                    tool_calls.append(format_openai_tool_call(block))
+                else:
+                    logger.warning(
+                        "unsupported_content_block_type", type=block.get("type")
+                    )
+
+        return content, tool_calls
+
+    def _create_openai_message(
+        self, content: str, tool_calls: list[Any]
+    ) -> OpenAIResponseMessage:
+        """Create OpenAI message with proper content handling."""
+        # When there are tool calls but no content, use empty string instead of None
+        # Otherwise, if content is empty string, convert to None
+        final_content: str | None = content
+        if tool_calls and not content:
+            final_content = ""
+        elif content == "":
+            final_content = None
+
+        return OpenAIResponseMessage(
+            role="assistant",
+            content=final_content,
+            tool_calls=tool_calls if tool_calls else None,
+        )
+
+    def _create_openai_choice(
+        self, message: OpenAIResponseMessage, response: dict[str, Any]
+    ) -> OpenAIChoice:
+        """Create OpenAI choice with proper finish reason handling."""
+        # Map stop reason
+        finish_reason = self._convert_stop_reason_to_openai(response.get("stop_reason"))
+
+        # Ensure finish_reason is a valid literal type
+        if finish_reason not in ["stop", "length", "tool_calls", "content_filter"]:
+            finish_reason = "stop"
+
+        # Cast to proper literal type
+        valid_finish_reason = cast(
+            Literal["stop", "length", "tool_calls", "content_filter"], finish_reason
+        )
+
+        return OpenAIChoice(
+            index=0,
+            message=message,
+            finish_reason=valid_finish_reason,
+            logprobs=None,  # Anthropic doesn't support logprobs
+        )
+
+    def _create_openai_usage(self, response: dict[str, Any]) -> OpenAIUsage:
+        """Create OpenAI usage information from Anthropic response."""
+        usage_info = response.get("usage", {})
+        return OpenAIUsage(
+            prompt_tokens=usage_info.get("input_tokens", 0),
+            completion_tokens=usage_info.get("output_tokens", 0),
+            total_tokens=usage_info.get("input_tokens", 0)
+            + usage_info.get("output_tokens", 0),
+        )
+
     async def adapt_stream(
         self, stream: AsyncIterator[dict[str, Any]]
     ) -> AsyncIterator[dict[str, Any]]:
@@ -462,31 +508,25 @@ class OpenAIAdapter(APIAdapter):
         Raises:
             ValueError: If the stream format is invalid or unsupported
         """
-        # Create stream processor
+        # Create stream processor with dict output format
         processor = OpenAIStreamProcessor(
             enable_usage=True,
             enable_tool_calls=True,
-            enable_text_chunking=False,  # Keep text as-is for compatibility
+            output_format="dict",  # Output dict objects instead of SSE strings
         )
 
         try:
-            # Process the stream and parse SSE format back to dict objects
-            async for sse_chunk in processor.process_stream(stream):
-                if sse_chunk.startswith("data: "):
-                    data_str = sse_chunk[6:].strip()
-                    if data_str and data_str != "[DONE]":
-                        try:
-                            yield json.loads(data_str)
-                        except json.JSONDecodeError:
-                            logger.warning(
-                                "streaming_chunk_parse_failed",
-                                chunk_data=data_str[:100] + "..."
-                                if len(data_str) > 100
-                                else data_str,
-                                operation="adapt_stream",
-                            )
-                            continue
+            # Process the stream - now yields dict objects directly
+            async for chunk in processor.process_stream(stream):
+                yield chunk  # type: ignore[misc]  # chunk is guaranteed to be dict when output_format="dict"
         except Exception as e:
+            logger.error(
+                "streaming_conversion_failed",
+                error=str(e),
+                error_type=type(e).__name__,
+                operation="adapt_stream",
+                exc_info=True,
+            )
             raise ValueError(f"Error processing streaming response: {e}") from e
 
     def _convert_messages_to_anthropic(
@@ -910,6 +950,4 @@ __all__ = [
     "OpenAIAdapter",
     "OpenAIChatCompletionRequest",
     "OpenAIChatCompletionResponse",
-    "map_openai_model_to_claude",
-    "OPENAI_TO_CLAUDE_MODEL_MAPPING",
 ]