local-openai2anthropic 0.2.2__py3-none-any.whl → 0.2.4__py3-none-any.whl

local_openai2anthropic/__init__.py

@@ -3,7 +3,7 @@
 local-openai2anthropic: A proxy server that converts Anthropic Messages API to OpenAI API.
 """
 
-__version__ = "0.1.0"
+__version__ = "0.2.4"
 
 from local_openai2anthropic.protocol import (
     AnthropicError,

local_openai2anthropic/config.py

@@ -40,7 +40,7 @@ class Settings(BaseSettings):
     cors_headers: list[str] = ["*"]
     
     # Logging
-    log_level: str = "INFO"
+    log_level: str = "DEBUG"
 
     # Tavily Web Search Configuration
     tavily_api_key: Optional[str] = None

local_openai2anthropic/converter.py

@@ -5,23 +5,13 @@ 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
@@ -175,11 +165,15 @@ def convert_anthropic_to_openai(
     
     # 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")
@@ -191,10 +185,16 @@ def convert_anthropic_to_openai(
                 )
         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:
@@ -361,12 +361,25 @@ def convert_openai_to_anthropic(
     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):
@@ -426,208 +439,3 @@ def convert_openai_to_anthropic(
     }
     
     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 reasoning content (thinking)
-        if delta.reasoning_content:
-            reasoning = delta.reasoning_content
-            # Start thinking content block if not already started
-            if not content_block_started or content_block_index == 0:
-                # We need a separate index for thinking block
-                if content_block_started:
-                    # Close previous block
-                    yield {
-                        "type": "content_block_stop",
-                        "index": content_block_index,
-                    }
-                    content_block_index += 1
-                yield {
-                    "type": "content_block_start",
-                    "index": content_block_index,
-                    "content_block": {"type": "thinking", "thinking": ""},
-                }
-                content_block_started = True
-
-            yield {
-                "type": "content_block_delta",
-                "index": content_block_index,
-                "delta": {"type": "thinking_delta", "thinking": reasoning},
-            }
-            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"}

local_openai2anthropic/openai_types.py

@@ -0,0 +1,149 @@
+# SPDX-License-Identifier: Apache-2.0
+"""
+OpenAI API type definitions for compatibility with vLLM/SGLang responses.
+
+This module defines Pydantic models compatible with OpenAI API responses,
+these models support additional fields like `reasoning_content` that are
+returned by vLLM/SGLang but not present in the official OpenAI SDK.
+"""
+
+from typing import Any, Literal, Optional, TypedDict
+
+from pydantic import BaseModel
+
+
+# TypedDict types for parameters (used as dict in code)
+class ChatCompletionToolFunction(TypedDict):
+    """Function definition for a tool."""
+
+    name: str
+    description: str
+    parameters: dict[str, Any]
+
+
+class ChatCompletionToolParam(TypedDict):
+    """Tool parameter for chat completion."""
+
+    type: Literal["function"]
+    function: ChatCompletionToolFunction
+
+
+class CompletionCreateParams(TypedDict, total=False):
+    """Parameters for creating a chat completion."""
+
+    model: str
+    messages: list[dict[str, Any]]
+    max_tokens: int
+    temperature: float
+    top_p: float
+    top_k: int
+    stream: bool
+    stop: list[str]
+    tools: list[ChatCompletionToolParam]
+    tool_choice: str | dict[str, Any]
+    stream_options: dict[str, Any]
+    # Additional fields for vLLM/SGLang compatibility
+    chat_template_kwargs: dict[str, Any]
+    # Internal field for server tools config
+    _server_tools_config: dict[str, dict[str, Any]]
+
+
+# Pydantic models for API responses
+class Function(BaseModel):
+    """A function call."""
+
+    name: str
+    arguments: str
+
+
+class ChatCompletionMessageToolCall(BaseModel):
+    """A tool call in a chat completion message."""
+
+    id: str
+    type: str = "function"
+    function: Function
+
+
+class ChatCompletionMessage(BaseModel):
+    """A chat completion message."""
+
+    role: str
+    content: Optional[str] = None
+    tool_calls: Optional[list[ChatCompletionMessageToolCall]] = None
+    # Additional field for reasoning content (thinking) from vLLM/SGLang
+    reasoning_content: Optional[str] = None
+
+
+class Choice(BaseModel):
+    """A choice in a chat completion response."""
+
+    index: int = 0
+    message: ChatCompletionMessage
+    finish_reason: Optional[str] = None
+
+
+class FunctionDelta(BaseModel):
+    """A function call delta."""
+
+    name: Optional[str] = None
+    arguments: Optional[str] = None
+
+
+class ChatCompletionDeltaToolCall(BaseModel):
+    """A tool call delta in a streaming response."""
+
+    index: int = 0
+    id: Optional[str] = None
+    type: Optional[str] = None
+    function: Optional[FunctionDelta] = None
+
+
+class ChoiceDelta(BaseModel):
+    """A delta in a streaming chat completion response."""
+
+    role: Optional[str] = None
+    content: Optional[str] = None
+    tool_calls: Optional[list[ChatCompletionDeltaToolCall]] = None
+    # Additional field for reasoning content (thinking) from vLLM/SGLang
+    reasoning_content: Optional[str] = None
+
+
+class StreamingChoice(BaseModel):
+    """A choice in a streaming chat completion response."""
+
+    index: int = 0
+    delta: ChoiceDelta
+    finish_reason: Optional[str] = None
+
+
+class CompletionUsage(BaseModel):
+    """Usage statistics for a completion request."""
+
+    prompt_tokens: int
+    completion_tokens: int
+    total_tokens: int
+    # Optional cache-related fields
+    cache_creation_input_tokens: Optional[int] = None
+    cache_read_input_tokens: Optional[int] = None
+
+
+class ChatCompletion(BaseModel):
+    """A chat completion response."""
+
+    id: str
+    object: str = "chat.completion"
+    created: int
+    model: str
+    choices: list[Choice]
+    usage: Optional[CompletionUsage] = None
+
+
+class ChatCompletionChunk(BaseModel):
+    """A chunk in a streaming chat completion response."""
+
+    id: str
+    object: str = "chat.completion.chunk"
+    created: int
+    model: str
+    choices: list[StreamingChoice]
+    usage: Optional[CompletionUsage] = None

local_openai2anthropic/router.py

@@ -82,6 +82,7 @@ async def _stream_response(
             first_chunk = True
             content_block_started = False
             content_block_index = 0
+            current_block_type = None  # 'thinking', 'text', or 'tool_use'
             finish_reason = None
             input_tokens = 0
             output_tokens = 0
@@ -97,13 +98,14 @@ async def _stream_response(
 
                 try:
                     chunk = json.loads(data)
+                    logger.debug(f"[OpenAI Stream Chunk] {json.dumps(chunk, ensure_ascii=False)}")
                 except json.JSONDecodeError:
                     continue
 
                 # First chunk: message_start
                 if first_chunk:
                     message_id = chunk.get("id", "")
-                    usage = chunk.get("usage", {})
+                    usage = chunk.get("usage") or {}
                     input_tokens = usage.get("prompt_tokens", 0)
 
                     start_event = {
@@ -124,54 +126,70 @@ async def _stream_response(
                             },
                         },
                     }
+                    logger.debug(f"[Anthropic Stream Event] message_start: {json.dumps(start_event, ensure_ascii=False)}")
                     yield f"event: message_start\ndata: {json.dumps(start_event)}\n\n"
                     first_chunk = False
                     continue
 
                 # Handle usage-only chunks
                 if not chunk.get("choices"):
-                    usage = chunk.get("usage", {})
+                    usage = chunk.get("usage") or {}
                     if usage:
                         if content_block_started:
                             yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': content_block_index})}\n\n"
                             content_block_started = False
 
                         stop_reason_map = {"stop": "end_turn", "length": "max_tokens", "tool_calls": "tool_use"}
-                        yield f"event: message_delta\ndata: {json.dumps({'type': 'message_delta', 'delta': {'stop_reason': stop_reason_map.get(finish_reason or 'stop', 'end_turn')}, 'usage': {'input_tokens': usage.get('prompt_tokens', 0), 'output_tokens': usage.get('completion_tokens', 0), 'cache_creation_input_tokens': None, 'cache_read_input_tokens': None}})}\n\n"
+                        delta_event = {'type': 'message_delta', 'delta': {'stop_reason': stop_reason_map.get(finish_reason or 'stop', 'end_turn')}, 'usage': {'input_tokens': usage.get('prompt_tokens', 0), 'output_tokens': usage.get('completion_tokens', 0), 'cache_creation_input_tokens': None, 'cache_read_input_tokens': None}}
+                        logger.debug(f"[Anthropic Stream Event] message_delta: {json.dumps(delta_event, ensure_ascii=False)}")
+                        yield f"event: message_delta\ndata: {json.dumps(delta_event)}\n\n"
                     continue
 
                 choice = chunk["choices"][0]
                 delta = choice.get("delta", {})
 
-                # Track finish reason
+                # Track finish reason (but don't skip - content may also be present)
                 if choice.get("finish_reason"):
                     finish_reason = choice["finish_reason"]
-                    continue
 
                 # Handle reasoning content (thinking)
                 if delta.get("reasoning_content"):
                     reasoning = delta["reasoning_content"]
                     # Start thinking content block if not already started
-                    if not content_block_started or content_block_index == 0:
-                        # We need a separate index for thinking block
-                        # For simplicity, we treat thinking as a separate block before text
+                    if not content_block_started or current_block_type != 'thinking':
+                        # Close previous block if exists
                         if content_block_started:
-                            # Close previous block
-                            yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': content_block_index})}\n\n"
+                            stop_block = {'type': 'content_block_stop', 'index': content_block_index}
+                            logger.debug(f"[Anthropic Stream Event] content_block_stop ({current_block_type}): {json.dumps(stop_block, ensure_ascii=False)}")
+                            yield f"event: content_block_stop\ndata: {json.dumps(stop_block)}\n\n"
                             content_block_index += 1
-                        yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'thinking', 'thinking': ''}})}\n\n"
+                        start_block = {'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'thinking', 'thinking': ''}}
+                        logger.debug(f"[Anthropic Stream Event] content_block_start (thinking): {json.dumps(start_block, ensure_ascii=False)}")
+                        yield f"event: content_block_start\ndata: {json.dumps(start_block)}\n\n"
                         content_block_started = True
+                        current_block_type = 'thinking'
 
-                    yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': content_block_index, 'delta': {'type': 'thinking_delta', 'thinking': reasoning}})}\n\n"
+                    delta_block = {'type': 'content_block_delta', 'index': content_block_index, 'delta': {'type': 'thinking_delta', 'thinking': reasoning}}
+                    yield f"event: content_block_delta\ndata: {json.dumps(delta_block)}\n\n"
                     continue
 
                 # Handle content
                 if delta.get("content"):
-                    if not content_block_started:
-                        yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'text', 'text': ''}})}\n\n"
+                    if not content_block_started or current_block_type != 'text':
+                        # Close previous block if exists
+                        if content_block_started:
+                            stop_block = {'type': 'content_block_stop', 'index': content_block_index}
+                            logger.debug(f"[Anthropic Stream Event] content_block_stop ({current_block_type}): {json.dumps(stop_block, ensure_ascii=False)}")
+                            yield f"event: content_block_stop\ndata: {json.dumps(stop_block)}\n\n"
+                            content_block_index += 1
+                        start_block = {'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'text', 'text': ''}}
+                        logger.debug(f"[Anthropic Stream Event] content_block_start (text): {json.dumps(start_block, ensure_ascii=False)}")
+                        yield f"event: content_block_start\ndata: {json.dumps(start_block)}\n\n"
                         content_block_started = True
+                        current_block_type = 'text'
 
-                    yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': content_block_index, 'delta': {'type': 'text_delta', 'text': delta['content']}})}\n\n"
+                    delta_block = {'type': 'content_block_delta', 'index': content_block_index, 'delta': {'type': 'text_delta', 'text': delta['content']}}
+                    yield f"event: content_block_delta\ndata: {json.dumps(delta_block)}\n\n"
 
                 # Handle tool calls
                 if delta.get("tool_calls"):
@@ -183,27 +201,34 @@ async def _stream_response(
                             content_block_started = False
                             content_block_index += 1
 
-                        yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'tool_use', 'id': tool_call['id'], 'name': tool_call.get('function', {}).get('name', ''), 'input': {}}})}\n\n"
+                        func = tool_call.get('function') or {}
+                        yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'tool_use', 'id': tool_call['id'], 'name': func.get('name', ''), 'input': {}}})}\n\n"
                         content_block_started = True
+                        current_block_type = 'tool_use'
 
-                    elif tool_call.get("function", {}).get("arguments"):
-                        args = tool_call["function"]["arguments"]
+                    elif (tool_call.get('function') or {}).get("arguments"):
+                        args = (tool_call.get('function') or {}).get("arguments", "")
                         yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': content_block_index, 'delta': {'type': 'input_json_delta', 'partial_json': args}})}\n\n"
 
             # Close final content block
             if content_block_started:
-                yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': content_block_index})}\n\n"
+                stop_block = {'type': 'content_block_stop', 'index': content_block_index}
+                logger.debug(f"[Anthropic Stream Event] content_block_stop (final): {json.dumps(stop_block, ensure_ascii=False)}")
+                yield f"event: content_block_stop\ndata: {json.dumps(stop_block)}\n\n"
 
             # Message stop
-            yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
-            yield "data: [DONE]\n\n"
+            stop_event = {'type': 'message_stop'}
+            logger.debug(f"[Anthropic Stream Event] message_stop: {json.dumps(stop_event, ensure_ascii=False)}")
+            yield f"event: message_stop\ndata: {json.dumps(stop_event)}\n\n"
 
     except Exception as e:
+        import traceback
+        error_msg = f"{str(e)}\n{traceback.format_exc()}"
+        logger.error(f"Stream error: {error_msg}")
         error_event = AnthropicErrorResponse(
             error=AnthropicError(type="internal_error", message=str(e))
         )
         yield f"event: error\ndata: {error_event.model_dump_json()}\n\n"
-        yield "data: [DONE]\n\n"
 
 
 async def _convert_result_to_stream(
@@ -272,6 +297,14 @@ async def _convert_result_to_stream(
 
             yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': i, 'content_block': tool_result_block})}\n\n"
             yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': i})}\n\n"
+
+        elif block_type == "thinking":
+            # Handle thinking blocks (BetaThinkingBlock)
+            yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': i, 'content_block': {'type': 'thinking', 'thinking': ''}})}\n\n"
+            thinking_text = block.get("thinking", "")
+            if thinking_text:
+                yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': i, 'delta': {'type': 'thinking_delta', 'thinking': thinking_text}})}\n\n"
+            yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': i})}\n\n"
     
     # 3. message_delta with final usage
     delta_event = {
@@ -289,7 +322,6 @@ async def _convert_result_to_stream(
     
     # 4. message_stop
     yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
-    yield "data: [DONE]\n\n"
 
 
 class ServerToolHandler:
@@ -579,7 +611,7 @@ async def create_message(
     try:
         body_bytes = await request.body()
         body_json = json.loads(body_bytes.decode("utf-8"))
-        logger.info(f"Received body: {body_json}")
+        logger.debug(f"[Anthropic Request] {json.dumps(body_json, ensure_ascii=False, indent=2)}")
         anthropic_params = body_json
     except json.JSONDecodeError as e:
         logger.error(f"Invalid JSON in request body: {e}")
@@ -636,6 +668,10 @@ async def create_message(
         enabled_server_tools=enabled_server_tools if has_server_tools else None,
     )
     openai_params: dict[str, Any] = dict(openai_params_obj)  # type: ignore
+    
+    # Log converted OpenAI request (remove internal fields)
+    log_params = {k: v for k, v in openai_params.items() if not k.startswith('_')}
+    logger.debug(f"[OpenAI Request] {json.dumps(log_params, ensure_ascii=False, indent=2)}")
 
     stream = openai_params.get("stream", False)
     model = openai_params.get("model", "")
@@ -692,11 +728,16 @@ async def create_message(
                     )
 
                 openai_completion = response.json()
+                logger.debug(f"[OpenAI Response] {json.dumps(openai_completion, ensure_ascii=False, indent=2)}")
+                
                 from openai.types.chat import ChatCompletion
                 completion = ChatCompletion.model_validate(openai_completion)
                 anthropic_message = convert_openai_to_anthropic(completion, model)
+                
+                anthropic_response = anthropic_message.model_dump()
+                logger.debug(f"[Anthropic Response] {json.dumps(anthropic_response, ensure_ascii=False, indent=2)}")
 
-                return JSONResponse(content=anthropic_message.model_dump())
+                return JSONResponse(content=anthropic_response)
 
             except httpx.TimeoutException:
                 error_response = AnthropicErrorResponse(
@@ -745,6 +786,103 @@ async def list_models(
             )
 
 
+@router.post("/v1/messages/count_tokens")
+async def count_tokens(
+    request: Request,
+    settings: Settings = Depends(get_request_settings),
+) -> JSONResponse:
+    """
+    Count tokens in messages without creating a message.
+    Uses tiktoken for local token counting.
+    """
+    try:
+        body_bytes = await request.body()
+        body_json = json.loads(body_bytes.decode("utf-8"))
+        logger.debug(f"[Count Tokens Request] {json.dumps(body_json, ensure_ascii=False, indent=2)}")
+    except json.JSONDecodeError as e:
+        error_response = AnthropicErrorResponse(
+            error=AnthropicError(type="invalid_request_error", message=f"Invalid JSON: {e}")
+        )
+        return JSONResponse(status_code=422, content=error_response.model_dump())
+    except Exception as e:
+        error_response = AnthropicErrorResponse(
+            error=AnthropicError(type="invalid_request_error", message=str(e))
+        )
+        return JSONResponse(status_code=400, content=error_response.model_dump())
+
+    # Validate required fields
+    if not isinstance(body_json, dict):
+        error_response = AnthropicErrorResponse(
+            error=AnthropicError(type="invalid_request_error", message="Request body must be a JSON object")
+        )
+        return JSONResponse(status_code=422, content=error_response.model_dump())
+
+    messages = body_json.get("messages", [])
+    if not isinstance(messages, list):
+        error_response = AnthropicErrorResponse(
+            error=AnthropicError(type="invalid_request_error", message="messages must be a list")
+        )
+        return JSONResponse(status_code=422, content=error_response.model_dump())
+
+    model = body_json.get("model", "")
+    system = body_json.get("system")
+    tools = body_json.get("tools", [])
+
+    try:
+        # Use tiktoken for token counting
+        import tiktoken
+        
+        # Map model names to tiktoken encoding
+        # Claude models don't have direct tiktoken encodings, so we use cl100k_base as approximation
+        encoding = tiktoken.get_encoding("cl100k_base")
+        
+        total_tokens = 0
+        
+        # Count system prompt tokens if present
+        if system:
+            if isinstance(system, str):
+                total_tokens += len(encoding.encode(system))
+            elif isinstance(system, list):
+                for block in system:
+                    if isinstance(block, dict) and block.get("type") == "text":
+                        total_tokens += len(encoding.encode(block.get("text", "")))
+        
+        # Count message tokens
+        for msg in messages:
+            content = msg.get("content", "")
+            if isinstance(content, str):
+                total_tokens += len(encoding.encode(content))
+            elif isinstance(content, list):
+                for block in content:
+                    if isinstance(block, dict):
+                        if block.get("type") == "text":
+                            total_tokens += len(encoding.encode(block.get("text", "")))
+                        elif block.get("type") == "image":
+                            # Images are typically counted as a fixed number of tokens
+                            # This is an approximation
+                            total_tokens += 85  # Standard approximation for images
+        
+        # Count tool definitions tokens
+        if tools:
+            for tool in tools:
+                tool_def = tool if isinstance(tool, dict) else tool.model_dump()
+                # Rough approximation for tool definitions
+                total_tokens += len(encoding.encode(json.dumps(tool_def)))
+        
+        logger.debug(f"[Count Tokens Response] input_tokens: {total_tokens}")
+        
+        return JSONResponse(content={
+            "input_tokens": total_tokens
+        })
+        
+    except Exception as e:
+        logger.error(f"Token counting error: {e}")
+        error_response = AnthropicErrorResponse(
+            error=AnthropicError(type="internal_error", message=f"Failed to count tokens: {str(e)}")
+        )
+        return JSONResponse(status_code=500, content=error_response.model_dump())
+
+
 @router.get("/health")
 async def health_check() -> dict[str, str]:
     """Health check endpoint."""

{local_openai2anthropic-0.2.2.dist-info → local_openai2anthropic-0.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: local-openai2anthropic
-Version: 0.2.2
+Version: 0.2.4
 Summary: A lightweight proxy server that converts Anthropic Messages API to OpenAI API
 Project-URL: Homepage, https://github.com/dongfangzan/local-openai2anthropic
 Project-URL: Repository, https://github.com/dongfangzan/local-openai2anthropic

{local_openai2anthropic-0.2.2.dist-info → local_openai2anthropic-0.2.4.dist-info}/RECORD

@@ -1,18 +1,19 @@
-local_openai2anthropic/__init__.py,sha256=jgIoIwQXIXS83WbRUx2CF1x0A8DloLduoUIUGXwWhSU,1059
+local_openai2anthropic/__init__.py,sha256=xPWXxEgbns2l2aiZzW0BDbNBkjcfXK-Ee-2ukgjQPKc,1059
 local_openai2anthropic/__main__.py,sha256=K21u5u7FN8-DbO67TT_XDF0neGqJeFrVNkteRauCRQk,179
-local_openai2anthropic/config.py,sha256=jkPqZZ_uaEjG9uOTEyLnrJS74VVONJdKvgab2XzMTDs,1917
-local_openai2anthropic/converter.py,sha256=u5YaeuOZZfcx4vAxAyXS52TKDory9w_nVwkOhEOBme4,22757
+local_openai2anthropic/config.py,sha256=bnM7p5htd6rHgLn7Z0Ukmm2jVImLuVjIB5Cnfpf2ClY,1918
+local_openai2anthropic/converter.py,sha256=qp0LPJBTP0uAb_5l9VINZ03RAjmumxdquP6JqWXiZkQ,15779
 local_openai2anthropic/daemon.py,sha256=pZnRojGFcuIpR8yLDNjV-b0LJRBVhgRAa-dKeRRse44,10017
 local_openai2anthropic/daemon_runner.py,sha256=rguOH0PgpbjqNsKYei0uCQX8JQOQ1wmtQH1CtW95Dbw,3274
 local_openai2anthropic/main.py,sha256=5tdgPel8RSCn1iK0d7hYAmcTM9vYHlepgQujaEXA2ic,9866
+local_openai2anthropic/openai_types.py,sha256=jFdCvLwtXYoo5gGRqOhbHQcVaxcsxNnCP_yFPIv7rG4,3823
 local_openai2anthropic/protocol.py,sha256=vUEgxtRPFll6jEtLc4DyxTLCBjrWIEScZXhEqe4uibk,5185
-local_openai2anthropic/router.py,sha256=xgZiH7Nnb74OJ2_PSIfO9oOgVtUG4akEciUAuuJozJ4,32673
+local_openai2anthropic/router.py,sha256=KDIsckdQLx78z5rmVX8Zhr5zWO9m_qB-BjQbTwWjj0s,40224
 local_openai2anthropic/tavily_client.py,sha256=QsBhnyF8BFWPAxB4XtWCCpHCquNL5SW93-zjTTi4Meg,3774
 local_openai2anthropic/server_tools/__init__.py,sha256=QlJfjEta-HOCtLe7NaY_fpbEKv-ZpInjAnfmSqE9tbk,615
 local_openai2anthropic/server_tools/base.py,sha256=pNFsv-jSgxVrkY004AHAcYMNZgVSO8ZOeCzQBUtQ3vU,5633
 local_openai2anthropic/server_tools/web_search.py,sha256=1C7lX_cm-tMaN3MsCjinEZYPJc_Hj4yAxYay9h8Zbvs,6543
-local_openai2anthropic-0.2.2.dist-info/METADATA,sha256=1LDwStgAm9IYC4MV52b9VxgjNQCY8eR2gUd2Ini7ET8,10040
-local_openai2anthropic-0.2.2.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-local_openai2anthropic-0.2.2.dist-info/entry_points.txt,sha256=hdc9tSJUNxyNLXcTYye5SuD2K0bEQhxBhGnWTFup6ZM,116
-local_openai2anthropic-0.2.2.dist-info/licenses/LICENSE,sha256=X3_kZy3lJvd_xp8IeyUcIAO2Y367MXZc6aaRx8BYR_s,11369
-local_openai2anthropic-0.2.2.dist-info/RECORD,,
+local_openai2anthropic-0.2.4.dist-info/METADATA,sha256=nWz75h6XmZzWk3BdkMhTZNT0xlUmUSNmx2jgyFONS10,10040
+local_openai2anthropic-0.2.4.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+local_openai2anthropic-0.2.4.dist-info/entry_points.txt,sha256=hdc9tSJUNxyNLXcTYye5SuD2K0bEQhxBhGnWTFup6ZM,116
+local_openai2anthropic-0.2.4.dist-info/licenses/LICENSE,sha256=X3_kZy3lJvd_xp8IeyUcIAO2Y367MXZc6aaRx8BYR_s,11369
+local_openai2anthropic-0.2.4.dist-info/RECORD,,