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

local_openai2anthropic/tools/handler.py

@@ -0,0 +1,357 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Server tool handling."""
+
+import json
+import logging
+from http import HTTPStatus
+from typing import Any
+
+import httpx
+from fastapi.responses import JSONResponse
+
+from local_openai2anthropic.config import Settings
+from local_openai2anthropic.converter import convert_openai_to_anthropic
+from local_openai2anthropic.protocol import AnthropicError, AnthropicErrorResponse
+from local_openai2anthropic.server_tools import ServerToolRegistry
+from local_openai2anthropic.utils.tokens import (
+    _generate_server_tool_id,
+    _normalize_usage,
+)
+
+logger = logging.getLogger(__name__)
+
+
+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

local_openai2anthropic/utils/__init__.py

@@ -0,0 +1,18 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Utility functions for local_openai2anthropic."""
+
+from .tokens import (
+    _chunk_text,
+    _count_tokens,
+    _estimate_input_tokens,
+    _generate_server_tool_id,
+    _normalize_usage,
+)
+
+__all__ = [
+    "_chunk_text",
+    "_count_tokens",
+    "_estimate_input_tokens",
+    "_generate_server_tool_id",
+    "_normalize_usage",
+]

local_openai2anthropic/utils/tokens.py

@@ -0,0 +1,96 @@
+# SPDX-License-Identifier: Apache-2.0
+"""Token-related utility functions."""
+
+import json
+import secrets
+import string
+from typing import Any
+
+
+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

{local_openai2anthropic-0.2.3.dist-info → local_openai2anthropic-0.3.6.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: local-openai2anthropic
-Version: 0.2.3
+Version: 0.3.6
 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
@@ -24,6 +24,7 @@ Requires-Dist: httpx>=0.25.0
 Requires-Dist: openai>=1.30.0
 Requires-Dist: pydantic-settings>=2.0.0
 Requires-Dist: pydantic>=2.0.0
+Requires-Dist: tomli>=2.0.0; python_version < '3.11'
 Requires-Dist: uvicorn[standard]>=0.23.0
 Provides-Extra: dev
 Requires-Dist: black>=23.0.0; extra == 'dev'
@@ -55,6 +56,7 @@ This proxy translates Claude SDK calls to OpenAI API format in real-time, enabli
 - **Offline development** without cloud API costs
 - **Privacy-first AI** - data never leaves your machine
 - **Seamless model switching** between cloud and local
+- **Web Search tool** - built-in Tavily web search for local models
 
 ---
 
@@ -79,7 +81,11 @@ Other OpenAI-compatible backends may work but are not fully tested.
 pip install local-openai2anthropic
 ```
 
-### 2. Start Your Local LLM Server
+### 2. Configure Your LLM Backend (Optional)
+
+**Option A: Start a local LLM server**
+
+If you don't have an LLM server running, you can start one locally:
 
 Example with vLLM:
 ```bash
@@ -93,6 +99,16 @@ sglang launch --model-path meta-llama/Llama-2-7b-chat-hf --port 8000
 # SGLang starts at http://localhost:8000/v1
 ```
 
+**Option B: Use an existing OpenAI-compatible API**
+
+If you already have a deployed OpenAI-compatible API (local or remote), you can use it directly. Just note the base URL for the next step.
+
+Examples:
+- Local vLLM/SGLang: `http://localhost:8000/v1`
+- Remote API: `https://api.example.com/v1`
+
+> **Note:** If you're using [Ollama](https://ollama.com), it natively supports the Anthropic API format, so you don't need this proxy. Just point your Claude SDK directly to `http://localhost:11434/v1`.
+
 ### 3. Start the Proxy
 
 **Option A: Run in background (recommended)**
@@ -155,22 +171,31 @@ You can configure [Claude Code](https://github.com/anthropics/claude-code) to us
 
 ### Configuration Steps
 
-1. **Create or edit Claude Code config file** at `~/.claude/CLAUDE.md`:
-
-```markdown
-# Claude Code Configuration
-
-## API Settings
-
-- Claude API Base URL: http://localhost:8080
-- Claude API Key: dummy-key
-
-## Model Settings
-
-Use model: meta-llama/Llama-2-7b-chat-hf  # Your local model name
+1. **Edit Claude Code config file** at `~/.claude/settings.json`:
+
+```json
+{
+  "env": {
+    "ANTHROPIC_BASE_URL": "http://localhost:8080",
+    "ANTHROPIC_API_KEY": "dummy-key",
+    "ANTHROPIC_MODEL": "meta-llama/Llama-2-7b-chat-hf",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL": "meta-llama/Llama-2-7b-chat-hf",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL": "meta-llama/Llama-2-7b-chat-hf",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "meta-llama/Llama-2-7b-chat-hf",
+    "ANTHROPIC_REASONING_MODEL": "meta-llama/Llama-2-7b-chat-hf"
+  }
+}
 ```
 
-2. **Alternatively, set environment variables** before running Claude Code:
+| Variable | Description |
+|----------|-------------|
+| `ANTHROPIC_MODEL` | General model setting |
+| `ANTHROPIC_DEFAULT_SONNET_MODEL` | Default model for Sonnet mode (Claude Code default) |
+| `ANTHROPIC_DEFAULT_OPUS_MODEL` | Default model for Opus mode |
+| `ANTHROPIC_DEFAULT_HAIKU_MODEL` | Default model for Haiku mode |
+| `ANTHROPIC_REASONING_MODEL` | Default model for reasoning tasks |
+
+2. **Or set environment variables** before running Claude Code:
 
 ```bash
 export ANTHROPIC_BASE_URL=http://localhost:8080
@@ -179,38 +204,36 @@ export ANTHROPIC_API_KEY=dummy-key
 claude
 ```
 
-3. **Or use the `--api-key` and `--base-url` flags**:
-
-```bash
-claude --api-key dummy-key --base-url http://localhost:8080
-```
-
 ### Complete Workflow Example
 
+Make sure `~/.claude/settings.json` is configured as described above.
+
 Terminal 1 - Start your local LLM:
 ```bash
 vllm serve meta-llama/Llama-2-7b-chat-hf
 ```
 
-Terminal 2 - Start the proxy:
+Terminal 2 - Start the proxy (background mode):
 ```bash
 export OA2A_OPENAI_BASE_URL=http://localhost:8000/v1
 export OA2A_OPENAI_API_KEY=dummy
 export OA2A_TAVILY_API_KEY="tvly-your-tavily-api-key"  # Optional: enable web search
 
-oa2a
+oa2a start
 ```
 
-Terminal 3 - Launch Claude Code with local LLM:
+Terminal 3 - Launch Claude Code:
 ```bash
-export ANTHROPIC_BASE_URL=http://localhost:8080
-export ANTHROPIC_API_KEY=dummy-key
-
 claude
 ```
 
 Now Claude Code will use your local LLM instead of the cloud API.
 
+To stop the proxy:
+```bash
+oa2a stop
+```
+
 ---
 
 ## Features

local_openai2anthropic-0.3.6.dist-info/RECORD

@@ -0,0 +1,25 @@
+local_openai2anthropic/__init__.py,sha256=YEz1wpAzYlPY-zbmlQuLf8gpwLEVJBqff4LdfWcz6NM,1059
+local_openai2anthropic/__main__.py,sha256=K21u5u7FN8-DbO67TT_XDF0neGqJeFrVNkteRauCRQk,179
+local_openai2anthropic/config.py,sha256=y40uEMBE57dOGCV3w3v5j82ZPZZJWUnJ4yaFZXJ8pRk,4706
+local_openai2anthropic/converter.py,sha256=og94I514M9km_Wbk9c1ddU6fyaQNEbpd2zfpfnBQaTQ,16029
+local_openai2anthropic/daemon.py,sha256=pZnRojGFcuIpR8yLDNjV-b0LJRBVhgRAa-dKeRRse44,10017
+local_openai2anthropic/daemon_runner.py,sha256=rguOH0PgpbjqNsKYei0uCQX8JQOQ1wmtQH1CtW95Dbw,3274
+local_openai2anthropic/main.py,sha256=3xrjsKFBYK6B8niAtQz0U_yz-eTpf91HnHeAiR9CLQE,12174
+local_openai2anthropic/openai_types.py,sha256=jFdCvLwtXYoo5gGRqOhbHQcVaxcsxNnCP_yFPIv7rG4,3823
+local_openai2anthropic/protocol.py,sha256=VW3B1YrbYg5UAo7PveQv0Ny5vfuNa6yG6IlHtkuyXiI,5178
+local_openai2anthropic/router.py,sha256=gwSGCYQGd0tAj4B4cl30UDkIJDIfBP4D8T9KEMKnxyk,16196
+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/streaming/__init__.py,sha256=RFKYQnc0zlhWK-Dm7GZpmabmszbZhY5NcXaaSsQ7Sys,227
+local_openai2anthropic/streaming/handler.py,sha256=X8viml6b40p-vr-A4HlEi5iCqmTsIMyQgj3S2RfweVE,22033
+local_openai2anthropic/tools/__init__.py,sha256=OM_6YAwy3G1kbrF7n5NvmBwWPGO0hwq4xLrYZFMHANA,318
+local_openai2anthropic/tools/handler.py,sha256=SO8AmEUfNIg16s6jOKBaYdajYc0fiI8ciOoiKXIJe_c,14106
+local_openai2anthropic/utils/__init__.py,sha256=0Apd3lQCmWpQHol4AfjtQe6A3Cpex9Zn-8dyK_FU8Z0,372
+local_openai2anthropic/utils/tokens.py,sha256=TV3vGAjoGZeyo1xPvwb5jto43p1U1f4HteCApB86X0g,3187
+local_openai2anthropic-0.3.6.dist-info/METADATA,sha256=B5M75TvhwturteqT_zxAJ7lXSTAy2QpjTCeDvPRixhQ,11293
+local_openai2anthropic-0.3.6.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+local_openai2anthropic-0.3.6.dist-info/entry_points.txt,sha256=hdc9tSJUNxyNLXcTYye5SuD2K0bEQhxBhGnWTFup6ZM,116
+local_openai2anthropic-0.3.6.dist-info/licenses/LICENSE,sha256=X3_kZy3lJvd_xp8IeyUcIAO2Y367MXZc6aaRx8BYR_s,11369
+local_openai2anthropic-0.3.6.dist-info/RECORD,,

local_openai2anthropic-0.2.3.dist-info/RECORD

@@ -1,19 +0,0 @@
-local_openai2anthropic/__init__.py,sha256=bj8tRC4_GyO5x4A5NqRdpxWWrdhAi7pC8xN9-ui0bQo,1059
-local_openai2anthropic/__main__.py,sha256=K21u5u7FN8-DbO67TT_XDF0neGqJeFrVNkteRauCRQk,179
-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=5c9APWIIkM2pi4C6AZ0OWP_yrE6wn5YQmJo1OOHcuVo,36101
-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.3.dist-info/METADATA,sha256=auO3568iC566_VVykvf8x7oZylGVBhu0qW_zuAgp5WQ,10040
-local_openai2anthropic-0.2.3.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-local_openai2anthropic-0.2.3.dist-info/entry_points.txt,sha256=hdc9tSJUNxyNLXcTYye5SuD2K0bEQhxBhGnWTFup6ZM,116
-local_openai2anthropic-0.2.3.dist-info/licenses/LICENSE,sha256=X3_kZy3lJvd_xp8IeyUcIAO2Y367MXZc6aaRx8BYR_s,11369
-local_openai2anthropic-0.2.3.dist-info/RECORD,,