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

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(

local_openai2anthropic-0.2.3.dist-info/METADATA

@@ -0,0 +1,351 @@
+Metadata-Version: 2.4
+Name: local-openai2anthropic
+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
+Project-URL: Issues, https://github.com/dongfangzan/local-openai2anthropic/issues
+Author-email: dongfangzan <zsybook0124@163.com>
+Maintainer-email: dongfangzan <zsybook0124@163.com>
+License: Apache-2.0
+License-File: LICENSE
+Keywords: anthropic,api,claude,messages,openai,proxy
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Requires-Dist: anthropic>=0.30.0
+Requires-Dist: fastapi>=0.100.0
+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: uvicorn[standard]>=0.23.0
+Provides-Extra: dev
+Requires-Dist: black>=23.0.0; extra == 'dev'
+Requires-Dist: mypy>=1.0.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.0.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# local-openai2anthropic
+
+[![Python 3.12+](https://img.shields.io/badge/python-3.12+-blue.svg)](https://www.python.org/downloads/)
+[![License: Apache 2.0](https://img.shields.io/badge/License-Apache%202.0-blue.svg)](https://opensource.org/licenses/Apache-2.0)
+[![PyPI](https://img.shields.io/pypi/v/local-openai2anthropic.svg)](https://pypi.org/project/local-openai2anthropic/)
+
+**English | [中文](README_zh.md)**
+
+A lightweight proxy that lets applications built with [Claude SDK](https://github.com/anthropics/anthropic-sdk-python) talk to locally-hosted OpenAI-compatible LLMs.
+
+---
+
+## What Problem This Solves
+
+Many local LLM tools (vLLM, SGLang, etc.) provide an OpenAI-compatible API. But if you've built your app using Anthropic's Claude SDK, you can't use them directly.
+
+This proxy translates Claude SDK calls to OpenAI API format in real-time, enabling:
+
+- **Local LLM inference** with Claude-based apps
+- **Offline development** without cloud API costs
+- **Privacy-first AI** - data never leaves your machine
+- **Seamless model switching** between cloud and local
+
+---
+
+## Supported Local Backends
+
+Currently tested and supported:
+
+| Backend | Description | Status |
+|---------|-------------|--------|
+| [vLLM](https://github.com/vllm-project/vllm) | High-throughput LLM inference | ✅ Fully supported |
+| [SGLang](https://github.com/sgl-project/sglang) | Fast structured language model serving | ✅ Fully supported |
+
+Other OpenAI-compatible backends may work but are not fully tested.
+
+---
+
+## Quick Start
+
+### 1. Install
+
+```bash
+pip install local-openai2anthropic
+```
+
+### 2. Start Your Local LLM Server
+
+Example with vLLM:
+```bash
+vllm serve meta-llama/Llama-2-7b-chat-hf
+# vLLM starts OpenAI-compatible API at http://localhost:8000/v1
+```
+
+Or with SGLang:
+```bash
+sglang launch --model-path meta-llama/Llama-2-7b-chat-hf --port 8000
+# SGLang starts at http://localhost:8000/v1
+```
+
+### 3. Start the Proxy
+
+**Option A: Run in background (recommended)**
+
+```bash
+export OA2A_OPENAI_BASE_URL=http://localhost:8000/v1  # Your local LLM endpoint
+export OA2A_OPENAI_API_KEY=dummy  # Any value, not used by local backends
+
+oa2a start              # Start server in background
+# Server starts at http://localhost:8080
+
+# View logs
+oa2a logs               # Show last 50 lines of logs
+oa2a logs -f            # Follow logs in real-time (Ctrl+C to exit)
+
+# Check status
+oa2a status             # Check if server is running
+
+# Stop server
+oa2a stop               # Stop background server
+
+# Restart server
+oa2a restart            # Restart with same settings
+```
+
+**Option B: Run in foreground**
+
+```bash
+export OA2A_OPENAI_BASE_URL=http://localhost:8000/v1
+export OA2A_OPENAI_API_KEY=dummy
+
+oa2a                    # Run server in foreground (blocking)
+# Press Ctrl+C to stop
+```
+
+### 4. Use in Your App
+
+```python
+import anthropic
+
+client = anthropic.Anthropic(
+    base_url="http://localhost:8080",  # Point to proxy
+    api_key="dummy-key",  # Not used
+)
+
+message = client.messages.create(
+    model="meta-llama/Llama-2-7b-chat-hf",  # Your local model name
+    max_tokens=1024,
+    messages=[{"role": "user", "content": "Hello!"}],
+)
+
+print(message.content[0].text)
+```
+
+---
+
+## Using with Claude Code
+
+You can configure [Claude Code](https://github.com/anthropics/claude-code) to use your local LLM through this proxy.
+
+### 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
+```
+
+2. **Alternatively, set environment variables** before running Claude Code:
+
+```bash
+export ANTHROPIC_BASE_URL=http://localhost:8080
+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
+
+Terminal 1 - Start your local LLM:
+```bash
+vllm serve meta-llama/Llama-2-7b-chat-hf
+```
+
+Terminal 2 - Start the proxy:
+```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
+```
+
+Terminal 3 - Launch Claude Code with local LLM:
+```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.
+
+---
+
+## Features
+
+- ✅ **Streaming responses** - Real-time token streaming via SSE
+- ✅ **Tool calling** - Local LLM function calling support
+- ✅ **Vision models** - Multi-modal input for vision-capable models
+- ✅ **Web Search** - Give your local LLM internet access (see below)
+- ✅ **Thinking mode** - Supports reasoning/thinking model outputs
+
+---
+
+## Web Search Capability 🔍
+
+**Bridge the gap: Give your local LLM the web search power that Claude Code users enjoy!**
+
+When using locally-hosted models with Claude Code, you lose access to the built-in web search tool. This proxy fills that gap by providing a server-side web search implementation powered by [Tavily](https://tavily.com).
+
+### The Problem
+
+| Scenario | Web Search Available? |
+|----------|----------------------|
+| Using Claude (cloud) in Claude Code | ✅ Built-in |
+| Using local vLLM/SGLang in Claude Code | ❌ Not available |
+| **Using this proxy + local LLM** | ✅ **Enabled via Tavily** |
+
+### How It Works
+
+```
+Claude Code → Anthropic SDK → This Proxy → Local LLM
+                                      ↓
+                                 Tavily API (Web Search)
+```
+
+The proxy intercepts `web_search_20250305` tool calls and handles them directly, regardless of whether your local model supports web search natively.
+
+### Setup Tavily Search
+
+1. **Get a free API key** at [tavily.com](https://tavily.com) - generous free tier available
+
+2. **Configure the proxy:**
+```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"  # Enable web search
+
+oa2a
+```
+
+3. **Use in your app:**
+```python
+import anthropic
+
+client = anthropic.Anthropic(
+    base_url="http://localhost:8080",
+    api_key="dummy-key",
+)
+
+message = client.messages.create(
+    model="meta-llama/Llama-2-7b-chat-hf",
+    max_tokens=1024,
+    tools=[
+        {
+            "name": "web_search_20250305",
+            "description": "Search the web for current information",
+            "input_schema": {
+                "type": "object",
+                "properties": {
+                    "query": {"type": "string", "description": "Search query"},
+                },
+                "required": ["query"],
+            },
+        }
+    ],
+    messages=[{"role": "user", "content": "What happened in AI today?"}],
+)
+
+if message.stop_reason == "tool_use":
+    tool_use = message.content[-1]
+    print(f"Searching: {tool_use.input}")
+    # The proxy automatically calls Tavily and returns results
+```
+
+### Tavily Configuration Options
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `OA2A_TAVILY_API_KEY` | - | Your Tavily API key ([get free at tavily.com](https://tavily.com)) |
+| `OA2A_TAVILY_MAX_RESULTS` | 5 | Number of search results to return |
+| `OA2A_TAVILY_TIMEOUT` | 30 | Search timeout in seconds |
+| `OA2A_WEBSEARCH_MAX_USES` | 5 | Max search calls per request |
+
+---
+
+## Configuration
+
+| Variable | Required | Default | Description |
+|----------|----------|---------|-------------|
+| `OA2A_OPENAI_BASE_URL` | ✅ | - | Your local LLM's OpenAI-compatible endpoint |
+| `OA2A_OPENAI_API_KEY` | ✅ | - | Any value (local backends usually ignore this) |
+| `OA2A_PORT` | ❌ | 8080 | Proxy server port |
+| `OA2A_HOST` | ❌ | 0.0.0.0 | Proxy server host |
+| `OA2A_TAVILY_API_KEY` | ❌ | - | Enable web search ([tavily.com](https://tavily.com)) |
+
+---
+
+## Architecture
+
+```
+Your App (Claude SDK)
+         │
+         ▼
+┌─────────────────────┐
+│  local-openai2anthropic  │  ← This proxy
+│  (Port 8080)        │
+└─────────────────────┘
+         │
+         ▼
+Your Local LLM Server
+(vLLM / SGLang)
+(OpenAI-compatible API)
+```
+
+---
+
+## Development
+
+```bash
+git clone https://github.com/dongfangzan/local-openai2anthropic.git
+cd local-openai2anthropic
+pip install -e ".[dev]"
+
+pytest
+```
+
+## License
+
+Apache License 2.0

local_openai2anthropic-0.2.3.dist-info/RECORD

@@ -0,0 +1,19 @@
+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,,