local-openai2anthropic 0.2.0__tar.gz → 0.2.3__tar.gz

{local_openai2anthropic-0.2.0 → local_openai2anthropic-0.2.3}/.gitignore

@@ -60,3 +60,4 @@ Thumbs.db
 # Local development
 .env.local
 .env.*.local
+.env*

{local_openai2anthropic-0.2.0 → local_openai2anthropic-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: local-openai2anthropic
-Version: 0.2.0
+Version: 0.2.3
 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.0 → local_openai2anthropic-0.2.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "local-openai2anthropic"
-version = "0.2.0"
+version = "0.2.3"
 description = "A lightweight proxy server that converts Anthropic Messages API to OpenAI API"
 readme = "README.md"
 license = { text = "Apache-2.0" }

{local_openai2anthropic-0.2.0 → local_openai2anthropic-0.2.3}/src/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.3"
 
 from local_openai2anthropic.protocol import (
     AnthropicError,

{local_openai2anthropic-0.2.0 → local_openai2anthropic-0.2.3}/src/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-0.2.0 → local_openai2anthropic-0.2.3}/src/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,181 +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 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-0.2.3/src/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-0.2.0 → local_openai2anthropic-0.2.3}/src/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,37 +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"]
+
+                # 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 current_block_type != 'thinking':
+                        # 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': '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'
+
+                    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"):
@@ -166,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(
@@ -255,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 = {
@@ -272,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:
@@ -562,6 +611,7 @@ async def create_message(
     try:
         body_bytes = await request.body()
         body_json = json.loads(body_bytes.decode("utf-8"))
+        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}")
@@ -618,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", "")
@@ -674,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(