local-openai2anthropic 0.3.4__py3-none-any.whl → 0.3.5__py3-none-any.whl

local_openai2anthropic/router.py

@@ -5,10 +5,8 @@ FastAPI router for Anthropic-compatible Messages API.
 
 import json
 import logging
-import secrets
-import string
 from http import HTTPStatus
-from typing import Any, AsyncGenerator, cast
+from typing import Any, cast
 
 import httpx
 from fastapi import APIRouter, Depends, HTTPException, Request
@@ -26,10 +24,44 @@ from local_openai2anthropic.protocol import (
     MessageCreateParams,
 )
 from local_openai2anthropic.server_tools import ServerToolRegistry
+from local_openai2anthropic.streaming import _convert_result_to_stream, _stream_response
+from local_openai2anthropic.tools import (
+    ServerToolHandler,
+    _add_tool_results_to_messages,
+    _handle_with_server_tools,
+)
+from local_openai2anthropic.utils import (
+    _chunk_text,
+    _count_tokens,
+    _estimate_input_tokens,
+    _generate_server_tool_id,
+    _normalize_usage,
+)
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
 
+# Backward compatibility: re-export functions used by tests
+__all__ = [
+    "router",
+    "get_request_settings",
+    "create_message",
+    "list_models",
+    "count_tokens",
+    "health_check",
+    # Backward compatibility exports
+    "_stream_response",
+    "_convert_result_to_stream",
+    "ServerToolHandler",
+    "_handle_with_server_tools",
+    "_add_tool_results_to_messages",
+    "_generate_server_tool_id",
+    "_normalize_usage",
+    "_count_tokens",
+    "_chunk_text",
+    "_estimate_input_tokens",
+]
+
 
 def get_request_settings(request: Request) -> Settings:
     """Resolve Settings from the running app when available.
@@ -43,858 +75,6 @@ def get_request_settings(request: Request) -> Settings:
     return get_settings()
 
 
-def _generate_server_tool_id() -> str:
-    """Generate Anthropic-style server tool use ID (srvtoolu_...)."""
-    # Generate 24 random alphanumeric characters
-    chars = string.ascii_lowercase + string.digits
-    random_part = "".join(secrets.choice(chars) for _ in range(24))
-    return f"srvtoolu_{random_part}"
-
-
-def _normalize_usage(usage: dict[str, Any] | None) -> dict[str, Any] | None:
-    if not isinstance(usage, dict):
-        return usage
-    allowed_keys = {
-        "input_tokens",
-        "output_tokens",
-        "cache_creation_input_tokens",
-        "cache_read_input_tokens",
-        "server_tool_use",
-    }
-    normalized = {k: v for k, v in usage.items() if k in allowed_keys}
-    return normalized or None
-
-
-def _count_tokens(text: str) -> int:
-    try:
-        import tiktoken  # type: ignore[import-not-found]
-    except Exception:
-        return 0
-
-    encoding = tiktoken.get_encoding("cl100k_base")
-    return len(encoding.encode(text))
-
-
-def _chunk_text(text: str, chunk_size: int = 200) -> list[str]:
-    if not text:
-        return []
-    return [text[i : i + chunk_size] for i in range(0, len(text), chunk_size)]
-
-
-def _estimate_input_tokens(openai_params: dict[str, Any]) -> int:
-    try:
-        import tiktoken  # type: ignore[import-not-found]
-    except Exception:
-        return 0
-
-    encoding = tiktoken.get_encoding("cl100k_base")
-    total_tokens = 0
-
-    system = openai_params.get("system")
-    if isinstance(system, str):
-        total_tokens += len(encoding.encode(system))
-
-    messages = openai_params.get("messages", [])
-    if isinstance(messages, list):
-        for msg in messages:
-            if not isinstance(msg, dict):
-                continue
-            content = msg.get("content", "")
-            if isinstance(content, str):
-                total_tokens += len(encoding.encode(content))
-            elif isinstance(content, list):
-                for block in content:
-                    if not isinstance(block, dict):
-                        total_tokens += len(encoding.encode(str(block)))
-                        continue
-                    block_type = block.get("type")
-                    if block_type == "text":
-                        total_tokens += len(encoding.encode(block.get("text", "")))
-                    elif block_type == "image_url":
-                        total_tokens += 85
-
-            tool_calls = msg.get("tool_calls")
-            if isinstance(tool_calls, list) and tool_calls:
-                total_tokens += len(encoding.encode(json.dumps(tool_calls)))
-
-    tools = openai_params.get("tools")
-    if isinstance(tools, list) and tools:
-        total_tokens += len(encoding.encode(json.dumps(tools)))
-
-    tool_choice = openai_params.get("tool_choice")
-    if tool_choice is not None:
-        total_tokens += len(encoding.encode(json.dumps(tool_choice)))
-
-    response_format = openai_params.get("response_format")
-    if response_format is not None:
-        total_tokens += len(encoding.encode(json.dumps(response_format)))
-
-    return total_tokens
-
-
-async def _stream_response(
-    client: httpx.AsyncClient,
-    url: str,
-    headers: dict,
-    json_data: dict,
-    model: str,
-) -> AsyncGenerator[str, None]:
-    """
-    Stream response from OpenAI and convert to Anthropic format.
-    """
-    try:
-        async with client.stream(
-            "POST", url, headers=headers, json=json_data
-        ) as response:
-            if response.status_code != 200:
-                error_body = await response.aread()
-                error_text = error_body.decode("utf-8", errors="replace").strip()
-                try:
-                    error_json = json.loads(error_text) if error_text else {}
-                    error_msg = error_json.get("error", {}).get("message") or error_text
-                except json.JSONDecodeError:
-                    error_msg = error_text
-                if not error_msg:
-                    error_msg = (
-                        response.reason_phrase
-                        or f"Upstream API error ({response.status_code})"
-                    )
-
-                error_event = AnthropicErrorResponse(
-                    error=AnthropicError(type="api_error", message=error_msg)
-                )
-                yield f"event: error\ndata: {error_event.model_dump_json()}\n\n"
-                yield "data: [DONE]\n\n"
-                return
-
-            # Process SSE stream
-            first_chunk = True
-            content_block_started = False
-            content_block_index = 0
-            current_block_type = None  # 'thinking', 'text', or 'tool_use'
-            current_tool_call_index = None
-            tool_call_buffers: dict[int, str] = {}
-            finish_reason = None
-            input_tokens = _estimate_input_tokens(json_data)
-            output_tokens = 0
-            message_id = None
-            sent_message_delta = False
-            pending_text_prefix = ""
-
-            async for line in response.aiter_lines():
-                if not line.startswith("data: "):
-                    continue
-
-                data = line[6:]
-                if data == "[DONE]":
-                    if not sent_message_delta:
-                        stop_reason_map = {
-                            "stop": "end_turn",
-                            "length": "max_tokens",
-                            "tool_calls": "tool_use",
-                        }
-                        delta_event = {
-                            "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": 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"
-                    break
-
-                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") or {}
-                    input_tokens = usage.get("prompt_tokens", input_tokens)
-
-                    start_event = {
-                        "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,
-                            },
-                        },
-                    }
-                    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") or {}
-                    if usage:
-                        input_tokens = usage.get("prompt_tokens", input_tokens)
-                        output_tokens = usage.get("completion_tokens", output_tokens)
-                        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",
-                        }
-                        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", input_tokens
-                                ),
-                                "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"
-                        sent_message_delta = True
-                    continue
-
-                choice = chunk["choices"][0]
-                delta = choice.get("delta", {})
-
-                # 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"]
-                    pending_text_prefix = ""
-                    # 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": "",
-                                "signature": "",
-                            },
-                        }
-                        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"
-
-                    for chunk in _chunk_text(reasoning):
-                        delta_block = {
-                            "type": "content_block_delta",
-                            "index": content_block_index,
-                            "delta": {"type": "thinking_delta", "thinking": chunk},
-                        }
-                        yield f"event: content_block_delta\ndata: {json.dumps(delta_block)}\n\n"
-                    continue
-
-                # Handle content
-                if isinstance(delta.get("content"), str):
-                    content_text = delta.get("content", "")
-                    if not content_text:
-                        continue
-                    if content_text.strip() == "(no content)":
-                        continue
-                    if not content_block_started or current_block_type != "text":
-                        if not content_text.strip():
-                            pending_text_prefix += content_text
-                            continue
-                        # 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"
-
-                    if pending_text_prefix:
-                        content_text = pending_text_prefix + content_text
-                        pending_text_prefix = ""
-
-                    output_tokens += _count_tokens(content_text)
-                    delta_block = {
-                        "type": "content_block_delta",
-                        "index": content_block_index,
-                        "delta": {"type": "text_delta", "text": content_text},
-                    }
-                    yield f"event: content_block_delta\ndata: {json.dumps(delta_block)}\n\n"
-
-                # Handle tool calls
-                if delta.get("tool_calls"):
-                    pending_text_prefix = ""
-                    for tool_call in delta["tool_calls"]:
-                        tool_call_idx = tool_call.get("index", 0)
-
-                        if tool_call.get("id"):
-                            if content_block_started and (
-                                current_block_type != "tool_use"
-                                or current_tool_call_index != tool_call_idx
-                            ):
-                                yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': content_block_index})}\n\n"
-                                content_block_started = False
-                                content_block_index += 1
-
-                            if not content_block_started:
-                                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"
-                                current_tool_call_index = tool_call_idx
-                                tool_call_buffers.setdefault(tool_call_idx, "")
-
-                        if (tool_call.get("function") or {}).get("arguments"):
-                            args = (tool_call.get("function") or {}).get(
-                                "arguments", ""
-                            )
-                            if (
-                                not content_block_started
-                                or current_block_type != "tool_use"
-                                or current_tool_call_index != tool_call_idx
-                            ):
-                                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_index += 1
-                                func = tool_call.get("function") or {}
-                                tool_id = tool_call.get("id", "")
-                                yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'tool_use', 'id': tool_id, 'name': func.get('name', ''), 'input': {}}})}\n\n"
-                                content_block_started = True
-                                current_block_type = "tool_use"
-                                current_tool_call_index = tool_call_idx
-                                tool_call_buffers.setdefault(tool_call_idx, "")
-                            tool_call_buffers[tool_call_idx] = (
-                                tool_call_buffers.get(tool_call_idx, "") + args
-                            )
-                            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:
-                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
-            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"
-
-
-async def _convert_result_to_stream(
-    result: JSONResponse,
-    model: str,
-) -> AsyncGenerator[str, None]:
-    """Convert a JSONResponse to streaming SSE format."""
-    import time
-
-    body = json.loads(bytes(result.body).decode("utf-8"))
-    message_id = body.get("id", f"msg_{int(time.time() * 1000)}")
-    content = body.get("content", [])
-    usage = body.get("usage", {})
-    stop_reason = body.get("stop_reason", "end_turn")
-
-    # Map stop_reason
-    stop_reason_map = {
-        "end_turn": "stop",
-        "max_tokens": "length",
-        "tool_use": "tool_calls",
-    }
-    openai_stop_reason = stop_reason_map.get(stop_reason, "stop")
-
-    # 1. message_start event
-    start_event = {
-        "type": "message_start",
-        "message": {
-            "id": message_id,
-            "type": "message",
-            "role": "assistant",
-            "content": [],
-            "model": model,
-            "stop_reason": None,
-            "stop_sequence": None,
-            "usage": {
-                "input_tokens": usage.get("input_tokens", 0),
-                "output_tokens": 0,
-                "cache_creation_input_tokens": usage.get("cache_creation_input_tokens"),
-                "cache_read_input_tokens": usage.get("cache_read_input_tokens"),
-            },
-        },
-    }
-    yield f"event: message_start\ndata: {json.dumps(start_event)}\n\n"
-
-    # 2. Process content blocks
-    for i, block in enumerate(content):
-        block_type = block.get("type")
-
-        if block_type == "text":
-            yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': i, 'content_block': {'type': 'text', 'text': ''}})}\n\n"
-            text = block.get("text", "")
-            yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': i, 'delta': {'type': 'text_delta', 'text': text}})}\n\n"
-            yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': i})}\n\n"
-
-        elif block_type == "tool_use":
-            yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': i, 'content_block': {'type': 'tool_use', 'id': block.get('id', ''), 'name': block.get('name', ''), 'input': block.get('input', {})}})}\n\n"
-            tool_input = block.get("input", {})
-            if tool_input:
-                input_json = json.dumps(tool_input, ensure_ascii=False)
-                yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': i, 'delta': {'type': 'input_json_delta', 'partial_json': input_json}})}\n\n"
-            yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': i})}\n\n"
-
-        elif block_type == "server_tool_use":
-            # Preserve official Anthropic block type so clients can count server tool uses.
-            yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': i, 'content_block': {'type': 'server_tool_use', 'id': block.get('id', ''), 'name': block.get('name', ''), 'input': block.get('input', {})}})}\n\n"
-            yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': i})}\n\n"
-
-        elif block_type == "web_search_tool_result":
-            # Stream the tool result as its own content block.
-            tool_result_block = dict(block)
-            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)
-            signature = block.get("signature", "")
-            yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': i, 'content_block': {'type': 'thinking', 'thinking': '', 'signature': signature}})}\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 = {
-        "type": "message_delta",
-        "delta": {"stop_reason": stop_reason},
-        "usage": {
-            "input_tokens": usage.get("input_tokens", 0),
-            "output_tokens": usage.get("output_tokens", 0),
-            "cache_creation_input_tokens": usage.get("cache_creation_input_tokens"),
-            "cache_read_input_tokens": usage.get("cache_read_input_tokens"),
-            "server_tool_use": usage.get("server_tool_use"),
-        },
-    }
-    yield f"event: message_delta\ndata: {json.dumps(delta_event)}\n\n"
-
-    # 4. message_stop
-    yield f"event: message_stop\ndata: {json.dumps({'type': 'message_stop'})}\n\n"
-
-
-class ServerToolHandler:
-    """Handles server tool execution for non-streaming requests."""
-
-    def __init__(
-        self,
-        server_tools: list[type],
-        configs: dict[str, dict[str, Any]],
-        settings: Settings,
-    ):
-        self.server_tools = {t.tool_name: t for t in server_tools}
-        self.configs = configs
-        self.settings = settings
-        self.usage: dict[str, int] = {}
-
-    def is_server_tool_call(self, tool_call: dict[str, Any]) -> bool:
-        """Check if a tool call is for a server tool."""
-        func_name = tool_call.get("function", {}).get("name")
-        return func_name in self.server_tools
-
-    async def execute_tool(
-        self,
-        tool_call: dict[str, Any],
-    ) -> tuple[list[dict[str, Any]], dict[str, Any]]:
-        """
-        Execute a server tool and return content blocks + tool result message.
-        Returns: (content_blocks, tool_result_message)
-        """
-        func_name = tool_call.get("function", {}).get("name")
-        call_id = tool_call.get("id", "")
-        openai_call_id = tool_call.get("openai_id", call_id)
-
-        tool_class = self.server_tools[func_name]
-        config = self.configs.get(tool_class.tool_type, {})
-
-        # Extract call arguments
-        args = tool_class.extract_call_args(tool_call)
-        if args is None:
-            args = {}
-
-        # Execute the tool
-        result = await tool_class.execute(call_id, args, config, self.settings)
-
-        # Update usage
-        for key, value in result.usage_increment.items():
-            self.usage[key] = self.usage.get(key, 0) + value
-
-        # Build content blocks
-        content_blocks = tool_class.build_content_blocks(call_id, args, result)
-
-        # Build tool result message for OpenAI
-        tool_result_msg = tool_class.build_tool_result_message(
-            openai_call_id, args, result
-        )
-
-        return content_blocks, tool_result_msg
-
-
-async def _handle_with_server_tools(
-    openai_params: dict[str, Any],
-    url: str,
-    headers: dict[str, str],
-    settings: Settings,
-    server_tools: list[type],
-    model: str,
-) -> JSONResponse:
-    """Handle request with server tool execution loop."""
-    params = dict(openai_params)
-    configs = params.pop("_server_tools_config", {})
-
-    handler = ServerToolHandler(server_tools, configs, settings)
-    accumulated_content: list[dict[str, Any]] = []
-
-    # Get max_uses from configs (default to settings or 5)
-    max_uses = settings.websearch_max_uses
-    for config in configs.values():
-        if config.get("max_uses"):
-            max_uses = config["max_uses"]
-            break
-
-    total_tool_calls = 0
-
-    while True:
-        async with httpx.AsyncClient(timeout=settings.request_timeout) as client:
-            try:
-                # Log full request for debugging
-                logger.debug(
-                    f"Request body: {json.dumps(params, indent=2, default=str)[:3000]}"
-                )
-
-                response = await client.post(url, headers=headers, json=params)
-
-                if response.status_code != 200:
-                    logger.error(
-                        f"OpenAI API error: {response.status_code} - {response.text}"
-                    )
-                    raw_text = response.text
-                    try:
-                        if not raw_text:
-                            raw_text = response.content.decode(
-                                "utf-8", errors="replace"
-                            )
-                    except Exception:
-                        raw_text = ""
-                    if not raw_text:
-                        raw_text = response.reason_phrase or ""
-                    error_message = (raw_text or "").strip()
-                    error_response = AnthropicErrorResponse(
-                        error=AnthropicError(
-                            type="api_error",
-                            message=error_message
-                            or f"Upstream API error ({response.status_code})",
-                        )
-                    )
-                    return JSONResponse(
-                        status_code=response.status_code,
-                        content=error_response.model_dump(),
-                    )
-
-                completion_data = response.json()
-                logger.debug(
-                    f"OpenAI response: {json.dumps(completion_data, indent=2)[:500]}..."
-                )
-                from openai.types.chat import ChatCompletion
-
-                completion = ChatCompletion.model_validate(completion_data)
-
-                # Check for server tool calls
-                server_tool_calls = []
-                other_tool_calls = []
-
-                tool_calls = completion.choices[0].message.tool_calls
-                logger.info(
-                    f"Model returned tool_calls: {len(tool_calls) if tool_calls else 0}"
-                )
-
-                if tool_calls:
-                    for tc in tool_calls:
-                        func = getattr(tc, "function", None)
-                        func_name = func.name if func else ""
-                        logger.info(f"  Tool call: {func_name}")
-
-                        # Generate Anthropic-style ID for server tools
-                        is_server = handler.is_server_tool_call(
-                            {
-                                "id": tc.id,
-                                "function": {"name": func_name, "arguments": ""},
-                            }
-                        )
-
-                        # Use Anthropic-style ID for server tools, original ID otherwise
-                        client_tool_id = (
-                            _generate_server_tool_id() if is_server else tc.id
-                        )
-
-                        tc_dict = {
-                            "id": client_tool_id,
-                            "openai_id": tc.id,
-                            "function": {
-                                "name": func_name,
-                                "arguments": func.arguments if func else "{}",
-                            },
-                        }
-                        logger.info(
-                            f"    Is server tool: {is_server}, ID: {client_tool_id}"
-                        )
-                        if is_server:
-                            server_tool_calls.append(tc_dict)
-                        else:
-                            other_tool_calls.append(tc)
-
-                # No server tool calls - we're done
-                logger.info(
-                    f"Server tool calls: {len(server_tool_calls)}, Other: {len(other_tool_calls)}"
-                )
-                if not server_tool_calls:
-                    message = convert_openai_to_anthropic(completion, model)
-
-                    if accumulated_content:
-                        message_dict = message.model_dump()
-                        message_dict["content"] = (
-                            accumulated_content + message_dict.get("content", [])
-                        )
-
-                        if message_dict.get("usage"):
-                            message_dict["usage"]["server_tool_use"] = handler.usage
-                        message_dict["usage"] = _normalize_usage(
-                            message_dict.get("usage")
-                        )
-
-                        # Log full response for debugging
-                        logger.info(
-                            f"Response content blocks: {json.dumps(message_dict.get('content', []), ensure_ascii=False)[:1000]}"
-                        )
-                        logger.info(f"Response usage: {message_dict.get('usage')}")
-                        logger.info(f"Server tool use count: {handler.usage}")
-
-                        return JSONResponse(content=message_dict)
-
-                    message_dict = message.model_dump()
-                    message_dict["usage"] = _normalize_usage(message_dict.get("usage"))
-                    return JSONResponse(content=message_dict)
-
-                # Check max_uses limit
-                if total_tool_calls >= max_uses:
-                    logger.warning(f"Server tool max_uses ({max_uses}) exceeded")
-                    # Return error for each call
-                    for call in server_tool_calls:
-                        func_name = call.get("function", {}).get("name", "")
-                        tool_class = handler.server_tools.get(func_name)
-                        if tool_class:
-                            from local_openai2anthropic.server_tools import ToolResult
-
-                            error_result = ToolResult(
-                                success=False,
-                                content=[],
-                                error_code="max_uses_exceeded",
-                            )
-                            error_blocks = tool_class.build_content_blocks(
-                                call["id"],
-                                {},
-                                error_result,
-                            )
-                            accumulated_content.extend(error_blocks)
-
-                    # Continue with modified messages
-                    assistant_tool_calls = []
-                    for call in server_tool_calls:
-                        assistant_tool_calls.append(
-                            {
-                                "id": call.get("openai_id", call.get("id", "")),
-                                "type": "function",
-                                "function": {
-                                    "name": call.get("function", {}).get("name", ""),
-                                    "arguments": call.get("function", {}).get(
-                                        "arguments", "{}"
-                                    ),
-                                },
-                            }
-                        )
-                    messages = params.get("messages", [])
-                    messages = _add_tool_results_to_messages(
-                        messages, assistant_tool_calls, handler, is_error=True
-                    )
-                    params["messages"] = messages
-                    continue
-
-                # Execute server tools
-                messages = params.get("messages", [])
-                assistant_tool_calls = []
-                tool_results = []
-
-                for call in server_tool_calls:
-                    total_tool_calls += 1
-                    content_blocks, tool_result = await handler.execute_tool(call)
-                    accumulated_content.extend(content_blocks)
-
-                    # Track for assistant message
-                    assistant_tool_calls.append(
-                        {
-                            "id": call.get("openai_id", call.get("id", "")),
-                            "type": "function",
-                            "function": {
-                                "name": call["function"]["name"],
-                                "arguments": call["function"]["arguments"],
-                            },
-                        }
-                    )
-                    tool_results.append(tool_result)
-
-                # Add to messages for next iteration
-                messages = _add_tool_results_to_messages(
-                    messages, assistant_tool_calls, handler, tool_results=tool_results
-                )
-                params["messages"] = messages
-
-            except httpx.TimeoutException:
-                error_response = AnthropicErrorResponse(
-                    error=AnthropicError(
-                        type="timeout_error", message="Request timed out"
-                    )
-                )
-                return JSONResponse(
-                    status_code=HTTPStatus.GATEWAY_TIMEOUT,
-                    content=error_response.model_dump(),
-                )
-            except httpx.RequestError as e:
-                error_response = AnthropicErrorResponse(
-                    error=AnthropicError(type="connection_error", message=str(e))
-                )
-                return JSONResponse(
-                    status_code=HTTPStatus.BAD_GATEWAY,
-                    content=error_response.model_dump(),
-                )
-
-
-def _add_tool_results_to_messages(
-    messages: list[dict[str, Any]],
-    tool_calls: list[dict[str, Any]],
-    handler: ServerToolHandler,
-    tool_results: list[dict[str, Any]] | None = None,
-    is_error: bool = False,
-) -> list[dict[str, Any]]:
-    """Add assistant tool call and results to messages."""
-    messages = list(messages)
-
-    # Add assistant message with tool calls
-    # SGLang requires content to be a string, not None
-    assistant_msg: dict[str, Any] = {
-        "role": "assistant",
-        "content": "",  # Empty string instead of None for SGLang compatibility
-        "tool_calls": tool_calls,
-    }
-    messages.append(assistant_msg)
-
-    # Add tool results
-    if is_error:
-        for call in tool_calls:
-            tool_call_id = call.get("openai_id", call.get("id", ""))
-            messages.append(
-                {
-                    "role": "tool",
-                    "tool_call_id": tool_call_id,
-                    "content": json.dumps(
-                        {
-                            "error": "max_uses_exceeded",
-                            "message": "Maximum tool uses exceeded.",
-                        }
-                    ),
-                }
-            )
-    elif tool_results:
-        messages.extend(tool_results)
-
-    return messages
-
-
 @router.post(
     "/v1/messages",
     response_model=Message,