local-openai2anthropic 0.1.0__py3-none-any.whl → 0.3.6__py3-none-any.whl

local_openai2anthropic/converter.py

@@ -5,35 +5,23 @@ Core conversion logic between Anthropic and OpenAI formats.
 
 import json
 import logging
-import time
-from typing import Any, AsyncGenerator, Optional
-
-logger = logging.getLogger(__name__)
+from typing import Any, Optional
 
 from anthropic.types import (
     ContentBlock,
-    ContentBlockDeltaEvent,
-    ContentBlockStartEvent,
-    ContentBlockStopEvent,
     Message,
-    MessageDeltaEvent,
     MessageParam,
-    MessageStartEvent,
-    MessageStopEvent,
     TextBlock,
-    TextDelta,
     ToolUseBlock,
 )
 from anthropic.types.message_create_params import MessageCreateParams
 from openai.types.chat import (
     ChatCompletion,
-    ChatCompletionChunk,
     ChatCompletionToolParam,
 )
 from openai.types.chat.completion_create_params import CompletionCreateParams
 
 from local_openai2anthropic.protocol import UsageWithCache
-from local_openai2anthropic.server_tools import ServerToolRegistry
 
 logger = logging.getLogger(__name__)
 
@@ -59,11 +47,12 @@ def convert_anthropic_to_openai(
     system = anthropic_params.get("system")
     stop_sequences = anthropic_params.get("stop_sequences")
     stream = anthropic_params.get("stream", False)
-    temperature = anthropic_params.get("temperature")
+    temperature = anthropic_params.get("temperature", 0.6)
     tool_choice = anthropic_params.get("tool_choice")
     tools = anthropic_params.get("tools")
     top_k = anthropic_params.get("top_k")
-    top_p = anthropic_params.get("top_p")
+    top_p = anthropic_params.get("top_p", 0.95)
+    repetition_penalty = anthropic_params.get("repetition_penalty", 1.1)
     thinking = anthropic_params.get("thinking")
     # metadata is accepted but not forwarded to OpenAI
 
@@ -102,7 +91,9 @@ def convert_anthropic_to_openai(
             converted_messages = _convert_anthropic_message_to_openai(msg)
             openai_messages.extend(converted_messages)
             msg_count += 1
-    logger.debug(f"Converted {msg_count} messages, total OpenAI messages: {len(openai_messages)}")
+    logger.debug(
+        f"Converted {msg_count} messages, total OpenAI messages: {len(openai_messages)}"
+    )
 
     # Build OpenAI params
     params: dict[str, Any] = {
@@ -110,6 +101,7 @@ def convert_anthropic_to_openai(
         "messages": openai_messages,
         "max_tokens": max_tokens,
         "stream": stream,
+        "repetition_penalty": repetition_penalty,
     }
 
     # Always include usage in stream for accurate token counting
@@ -149,17 +141,21 @@ def convert_anthropic_to_openai(
             openai_tools.append(openai_tool)
 
         # Add server tools as OpenAI function tools
-        for tool_class in (enabled_server_tools or []):
+        for tool_class in enabled_server_tools or []:
             if tool_class.tool_type in server_tools_config:
                 config = server_tools_config[tool_class.tool_type]
                 openai_tools.append(tool_class.to_openai_tool(config))
 
         if openai_tools:
             params["tools"] = openai_tools
-        
+
         # Convert tool_choice
         if tool_choice:
-            tc = tool_choice if isinstance(tool_choice, dict) else tool_choice.model_dump()
+            tc = (
+                tool_choice
+                if isinstance(tool_choice, dict)
+                else tool_choice.model_dump()
+            )
             tc_type = tc.get("type")
             if tc_type == "auto":
                 params["tool_choice"] = "auto"
@@ -172,14 +168,18 @@ def convert_anthropic_to_openai(
                 }
         else:
             params["tool_choice"] = "auto"
-    
+
     # Handle thinking parameter
     # vLLM/SGLang use chat_template_kwargs.thinking to toggle thinking mode
+    # Some models use "thinking", others use "enable_thinking", so we include both
     if thinking and isinstance(thinking, dict):
         thinking_type = thinking.get("type")
         if thinking_type == "enabled":
-            # Enable thinking mode for vLLM/SGLang
-            params["chat_template_kwargs"] = {"thinking": True}
+            # Enable thinking mode - include both variants for compatibility
+            params["chat_template_kwargs"] = {
+                "thinking": True,
+                "enable_thinking": True,
+            }
 
             # Log if budget_tokens was provided but will be ignored
             budget_tokens = thinking.get("budget_tokens")
@@ -187,14 +187,20 @@ def convert_anthropic_to_openai(
                 logger.debug(
                     "thinking.budget_tokens (%s) is accepted but not supported by "
                     "vLLM/SGLang. Using default thinking configuration.",
-                    budget_tokens
+                    budget_tokens,
                 )
         else:
             # Default to disabled thinking mode if not explicitly enabled
-            params["chat_template_kwargs"] = {"thinking": False}
+            params["chat_template_kwargs"] = {
+                "thinking": False,
+                "enable_thinking": False,
+            }
     else:
         # Default to disabled thinking mode when thinking is not provided
-        params["chat_template_kwargs"] = {"thinking": False}
+        params["chat_template_kwargs"] = {
+            "thinking": False,
+            "enable_thinking": False,
+        }
 
     # Store server tool configs for later use by router
     if server_tools_config:
@@ -208,32 +214,32 @@ def _convert_anthropic_message_to_openai(
 ) -> list[dict[str, Any]]:
     """
     Convert a single Anthropic message to OpenAI format.
-    
-    Returns a list of messages because tool_results need to be 
+
+    Returns a list of messages because tool_results need to be
     separate tool messages in OpenAI format.
     """
     role = msg.get("role", "user")
     content = msg.get("content", "")
-    
+
     if isinstance(content, str):
         return [{"role": role, "content": content}]
-    
+
     # Handle list of content blocks
     openai_content: list[dict[str, Any]] = []
     tool_calls: list[dict[str, Any]] = []
     tool_call_results: list[dict[str, Any]] = []
-    
+
     for block in content:
         if isinstance(block, str):
             openai_content.append({"type": "text", "text": block})
             continue
-            
+
         block_type = block.get("type") if isinstance(block, dict) else block.type
-        
+
         if block_type == "text":
             text = block.get("text") if isinstance(block, dict) else block.text
             openai_content.append({"type": "text", "text": text})
-            
+
         elif block_type == "image":
             # Convert image to image_url format
             source = block.get("source") if isinstance(block, dict) else block.source
@@ -246,11 +252,13 @@ def _convert_anthropic_message_to_openai(
                     data = source.data
                 # Build data URL
                 url = f"data:{media_type};base64,{data}"
-                openai_content.append({
-                    "type": "image_url",
-                    "image_url": {"url": url},
-                })
-                
+                openai_content.append(
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": url},
+                    }
+                )
+
         elif block_type == "tool_use":
             # Convert to function call
             if isinstance(block, dict):
@@ -261,27 +269,31 @@ def _convert_anthropic_message_to_openai(
                 tool_id = block.id
                 name = block.name
                 input_data = block.input
-                
-            tool_calls.append({
-                "id": tool_id,
-                "type": "function",
-                "function": {
-                    "name": name,
-                    "arguments": json.dumps(input_data) if isinstance(input_data, dict) else str(input_data),
-                },
-            })
-            
+
+            tool_calls.append(
+                {
+                    "id": tool_id,
+                    "type": "function",
+                    "function": {
+                        "name": name,
+                        "arguments": json.dumps(input_data)
+                        if isinstance(input_data, dict)
+                        else str(input_data),
+                    },
+                }
+            )
+
         elif block_type == "tool_result":
             # Tool results need to be separate tool messages
             if isinstance(block, dict):
                 tool_use_id = block.get("tool_use_id", "")
                 result_content = block.get("content", "")
-                is_error = block.get("is_error", False)
+                # Note: is_error is not directly supported in OpenAI API
             else:
                 tool_use_id = block.tool_use_id
                 result_content = block.content
-                is_error = getattr(block, "is_error", False)
-                
+                # Note: is_error is not directly supported in OpenAI API
+
             # Handle content that might be a list or string
             if isinstance(result_content, list):
                 # Extract text from content blocks
@@ -298,7 +310,7 @@ def _convert_anthropic_message_to_openai(
                 result_text = "\n".join(text_parts)
             else:
                 result_text = str(result_content)
-                
+
             tool_msg: dict[str, Any] = {
                 "role": "tool",
                 "tool_call_id": tool_use_id,
@@ -306,28 +318,28 @@ def _convert_anthropic_message_to_openai(
             }
             # Note: is_error is not directly supported in OpenAI API
             # but we could add it to content if needed
-            
+
             tool_call_results.append(tool_msg)
-    
+
     # Build primary message
     messages: list[dict[str, Any]] = []
     # SGLang requires content field to be present, default to empty string
     primary_msg: dict[str, Any] = {"role": role, "content": ""}
-    
+
     if openai_content:
         if len(openai_content) == 1 and openai_content[0]["type"] == "text":
             primary_msg["content"] = openai_content[0]["text"]
         else:
             primary_msg["content"] = openai_content
-    
+
     if tool_calls:
         primary_msg["tool_calls"] = tool_calls
-    
+
     messages.append(primary_msg)
-    
+
     # Add tool result messages separately
     messages.extend(tool_call_results)
-        
+
     return messages
 
 
@@ -353,20 +365,33 @@ def convert_openai_to_anthropic(
 ) -> Message:
     """
     Convert OpenAI ChatCompletion to Anthropic Message.
-    
+
     Args:
         completion: OpenAI chat completion response
         model: Model name
-        
+
     Returns:
         Anthropic Message response
     """
+    from anthropic.types.beta import BetaThinkingBlock
+
     choice = completion.choices[0]
     message = choice.message
-    
+
     # Convert content blocks
     content: list[ContentBlock] = []
-    
+
+    # Add reasoning content (thinking) first if present
+    reasoning_content = getattr(message, "reasoning_content", None)
+    if reasoning_content:
+        content.append(
+            BetaThinkingBlock(
+                type="thinking",
+                thinking=reasoning_content,
+                signature="",  # Signature not available from OpenAI format
+            )
+        )
+
     # Add text content if present
     if message.content:
         if isinstance(message.content, str):
@@ -375,16 +400,20 @@ def convert_openai_to_anthropic(
             for part in message.content:
                 if part.type == "text":
                     content.append(TextBlock(type="text", text=part.text))
-    
+
     # Convert tool calls
     if message.tool_calls:
         for tc in message.tool_calls:
+            # Handle case where function might be None
+            if not tc.function:
+                continue
+
             tool_input: dict[str, Any] = {}
             try:
                 tool_input = json.loads(tc.function.arguments)
             except json.JSONDecodeError:
                 tool_input = {"raw": tc.function.arguments}
-                
+
             content.append(
                 ToolUseBlock(
                     type="tool_use",
@@ -393,7 +422,7 @@ def convert_openai_to_anthropic(
                     input=tool_input,
                 )
             )
-    
+
     # Determine stop reason
     stop_reason_map = {
         "stop": "end_turn",
@@ -401,18 +430,24 @@ def convert_openai_to_anthropic(
         "tool_calls": "tool_use",
         "content_filter": "end_turn",
     }
-    anthropic_stop_reason = stop_reason_map.get(choice.finish_reason or "stop", "end_turn")
-    
+    anthropic_stop_reason = stop_reason_map.get(
+        choice.finish_reason or "stop", "end_turn"
+    )
+
     # Build usage dict with cache support (if available from upstream)
     usage_dict = None
     if completion.usage:
         usage_dict = {
             "input_tokens": completion.usage.prompt_tokens,
             "output_tokens": completion.usage.completion_tokens,
-            "cache_creation_input_tokens": getattr(completion.usage, "cache_creation_input_tokens", None),
-            "cache_read_input_tokens": getattr(completion.usage, "cache_read_input_tokens", None),
+            "cache_creation_input_tokens": getattr(
+                completion.usage, "cache_creation_input_tokens", None
+            ),
+            "cache_read_input_tokens": getattr(
+                completion.usage, "cache_read_input_tokens", None
+            ),
         }
-    
+
     # Build message dict to avoid Pydantic validation issues
     message_dict = {
         "id": completion.id,
@@ -424,183 +459,5 @@ def convert_openai_to_anthropic(
         "stop_sequence": None,
         "usage": usage_dict,
     }
-    
-    return Message.model_validate(message_dict)
 
-
-async def convert_openai_stream_to_anthropic(
-    stream: AsyncGenerator[ChatCompletionChunk, None],
-    model: str,
-    enable_ping: bool = False,
-    ping_interval: float = 15.0,
-) -> AsyncGenerator[dict, None]:
-    """
-    Convert OpenAI streaming response to Anthropic streaming events.
-    
-    Args:
-        stream: OpenAI chat completion stream
-        model: Model name
-        enable_ping: Whether to send periodic ping events
-        ping_interval: Interval between ping events in seconds
-        
-    Yields:
-        Anthropic MessageStreamEvent objects as dicts
-    """
-    message_id = f"msg_{int(time.time() * 1000)}"
-    first_chunk = True
-    content_block_started = False
-    content_block_index = 0
-    current_tool_call: Optional[dict[str, Any]] = None
-    finish_reason: Optional[str] = None
-    
-    # Track usage for final message_delta
-    input_tokens = 0
-    output_tokens = 0
-    
-    last_ping_time = time.time()
-    
-    async for chunk in stream:
-        # Send ping events if enabled and interval has passed
-        if enable_ping:
-            current_time = time.time()
-            if current_time - last_ping_time >= ping_interval:
-                yield {"type": "ping"}
-                last_ping_time = current_time
-        
-        # First chunk: message_start event
-        if first_chunk:
-            if chunk.usage:
-                input_tokens = chunk.usage.prompt_tokens
-                output_tokens = chunk.usage.completion_tokens
-            
-            yield {
-                "type": "message_start",
-                "message": {
-                    "id": message_id,
-                    "type": "message",
-                    "role": "assistant",
-                    "content": [],
-                    "model": model,
-                    "stop_reason": None,
-                    "stop_sequence": None,
-                    "usage": {
-                        "input_tokens": input_tokens,
-                        "output_tokens": 0,
-                        "cache_creation_input_tokens": None,
-                        "cache_read_input_tokens": None,
-                    },
-                },
-            }
-            first_chunk = False
-            continue
-        
-        # Handle usage-only chunks (last chunk)
-        if not chunk.choices:
-            if chunk.usage:
-                input_tokens = chunk.usage.prompt_tokens
-                output_tokens = chunk.usage.completion_tokens
-                
-                # Close any open content block
-                if content_block_started:
-                    yield {
-                        "type": "content_block_stop",
-                        "index": content_block_index,
-                    }
-                
-                # Message delta with final usage
-                stop_reason_map = {
-                    "stop": "end_turn",
-                    "length": "max_tokens",
-                    "tool_calls": "tool_use",
-                }
-                yield {
-                    "type": "message_delta",
-                    "delta": {
-                        "stop_reason": stop_reason_map.get(finish_reason or "stop", "end_turn"),
-                    },
-                    "usage": {
-                        "input_tokens": input_tokens,
-                        "output_tokens": output_tokens,
-                        "cache_creation_input_tokens": getattr(chunk.usage, "cache_creation_input_tokens", None),
-                        "cache_read_input_tokens": getattr(chunk.usage, "cache_read_input_tokens", None),
-                    },
-                }
-            continue
-        
-        choice = chunk.choices[0]
-        delta = choice.delta
-        
-        # Track finish reason
-        if choice.finish_reason:
-            finish_reason = choice.finish_reason
-            continue
-        
-        # Handle content
-        if delta.content:
-            if not content_block_started:
-                # Start text content block
-                yield {
-                    "type": "content_block_start",
-                    "index": content_block_index,
-                    "content_block": {"type": "text", "text": ""},
-                }
-                content_block_started = True
-            
-            if delta.content:
-                yield {
-                    "type": "content_block_delta",
-                    "index": content_block_index,
-                    "delta": {"type": "text_delta", "text": delta.content},
-                }
-        
-        # Handle tool calls
-        if delta.tool_calls:
-            tool_call = delta.tool_calls[0]
-            
-            if tool_call.id:
-                # Close previous content block if any
-                if content_block_started:
-                    yield {
-                        "type": "content_block_stop",
-                        "index": content_block_index,
-                    }
-                    content_block_started = False
-                    content_block_index += 1
-                
-                # Start new tool_use block
-                current_tool_call = {
-                    "id": tool_call.id,
-                    "name": tool_call.function.name if tool_call.function else "",
-                    "arguments": "",
-                }
-                yield {
-                    "type": "content_block_start",
-                    "index": content_block_index,
-                    "content_block": {
-                        "type": "tool_use",
-                        "id": tool_call.id,
-                        "name": tool_call.function.name if tool_call.function else "",
-                        "input": {},
-                    },
-                }
-                content_block_started = True
-                
-            elif tool_call.function and tool_call.function.arguments:
-                # Continue tool call arguments
-                args = tool_call.function.arguments
-                current_tool_call["arguments"] += args
-                yield {
-                    "type": "content_block_delta",
-                    "index": content_block_index,
-                    "delta": {"type": "input_json_delta", "partial_json": args},
-                }
-    
-    # Close final content block
-    if content_block_started:
-        yield {
-            "type": "content_block_stop",
-            "index": content_block_index,
-        }
-    
-    # Message stop event
-    yield {"type": "message_stop"}
+    return Message.model_validate(message_dict)