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

local_openai2anthropic/main.py

@@ -21,25 +21,25 @@ def create_app(settings: Settings | None = None) -> FastAPI:
     """Create and configure the FastAPI application."""
     if settings is None:
         settings = get_settings()
-    
+
     # Configure logging
     logging.basicConfig(
         level=getattr(logging, settings.log_level.upper()),
         format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
     )
-    
+
     # Create FastAPI app
     app = FastAPI(
         title="local-openai2anthropic",
         description="A proxy server that converts Anthropic Messages API to OpenAI API",
-        version="0.1.0",
+        version="0.2.0",
         docs_url="/docs",
         redoc_url="/redoc",
     )
-    
+
     # Store settings in app state
     app.state.settings = settings
-    
+
     # Add CORS middleware
     app.add_middleware(
         CORSMiddleware,
@@ -48,16 +48,17 @@ def create_app(settings: Settings | None = None) -> FastAPI:
         allow_methods=settings.cors_methods,
         allow_headers=settings.cors_headers,
     )
-    
+
     # Add API key authentication middleware if configured
     if settings.api_key:
+
         @app.middleware("http")
         async def auth_middleware(request: Request, call_next):
             """Validate API key if configured."""
             # Skip auth for docs and health check
             if request.url.path in ["/docs", "/redoc", "/openapi.json", "/health"]:
                 return await call_next(request)
-            
+
             auth_header = request.headers.get("Authorization", "")
             if not auth_header.startswith("Bearer "):
                 error_response = AnthropicErrorResponse(
@@ -70,7 +71,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
                     status_code=401,
                     content=error_response.model_dump(),
                 )
-            
+
             token = auth_header[7:]  # Remove "Bearer " prefix
             if token != settings.api_key:
                 error_response = AnthropicErrorResponse(
@@ -83,12 +84,12 @@ def create_app(settings: Settings | None = None) -> FastAPI:
                     status_code=401,
                     content=error_response.model_dump(),
                 )
-            
+
             return await call_next(request)
-    
+
     # Include routers
     app.include_router(router)
-    
+
     # Exception handlers
     @app.exception_handler(HTTPException)
     async def http_exception_handler(request: Request, exc: HTTPException):
@@ -99,7 +100,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
                 status_code=exc.status_code,
                 content=exc.detail,
             )
-        
+
         error_response = AnthropicErrorResponse(
             error=AnthropicError(
                 type="api_error",
@@ -110,7 +111,7 @@ def create_app(settings: Settings | None = None) -> FastAPI:
             status_code=exc.status_code,
             content=error_response.model_dump(),
         )
-    
+
     @app.exception_handler(Exception)
     async def general_exception_handler(request: Request, exc: Exception):
         """Handle unexpected exceptions."""
@@ -125,27 +126,12 @@ def create_app(settings: Settings | None = None) -> FastAPI:
             status_code=500,
             content=error_response.model_dump(),
         )
-    
-    return app
 
+    return app
 
-def main() -> None:
-    """Main entry point."""
-    # Parse arguments first (before loading settings)
-    parser = argparse.ArgumentParser(
-        prog="oa2a",
-        description="A proxy server that converts Anthropic Messages API to OpenAI API",
-    )
-    parser.add_argument(
-        "--version",
-        action="version",
-        version="%(prog)s 0.1.1",
-    )
-    args = parser.parse_args()
-
-    # Load settings
-    settings = get_settings()
 
+def run_foreground(settings: Settings) -> None:
+    """Run server in foreground mode (blocking)."""
     # Validate required settings
     if not settings.openai_api_key:
         print(
@@ -159,11 +145,12 @@ def main() -> None:
 
     # Create app
     app = create_app(settings)
-    
+
     # Run server
-    print(f"Starting local-openai2anthropic server on {settings.host}:{settings.port}")
+    print(f"Starting server on {settings.host}:{settings.port}")
     print(f"Proxying to: {settings.openai_base_url}")
-    
+    print("Press Ctrl+C to stop\n")
+
     uvicorn.run(
         app,
         host=settings.host,
@@ -173,5 +160,157 @@ def main() -> None:
     )
 
 
+def main() -> None:
+    """Main entry point with subcommand support."""
+    # Create main parser
+    parser = argparse.ArgumentParser(
+        prog="oa2a",
+        description="A proxy server that converts Anthropic Messages API to OpenAI API",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  oa2a start              # Start server in background
+  oa2a stop               # Stop background server
+  oa2a restart            # Restart background server
+  oa2a status             # Check server status
+  oa2a logs               # View server logs
+  oa2a logs -f            # Follow server logs (tail -f)
+  oa2a                    # Run server in foreground (default behavior)
+        """.strip(),
+    )
+
+    parser.add_argument(
+        "--version",
+        action="version",
+        version="%(prog)s 0.2.0",
+    )
+
+    # Create subparsers for commands
+    subparsers = parser.add_subparsers(dest="command", help="Available commands")
+
+    # start command
+    start_parser = subparsers.add_parser("start", help="Start server in background")
+    start_parser.add_argument(
+        "--host",
+        default=None,
+        help="Server host (default: 0.0.0.0)",
+    )
+    start_parser.add_argument(
+        "--port",
+        type=int,
+        default=None,
+        help="Server port (default: 8080)",
+    )
+    start_parser.add_argument(
+        "--log-level",
+        default="info",
+        choices=["debug", "info", "warning", "error"],
+        help="Logging level (default: info)",
+    )
+
+    # stop command
+    stop_parser = subparsers.add_parser("stop", help="Stop background server")
+    stop_parser.add_argument(
+        "-f", "--force",
+        action="store_true",
+        help="Force kill the server",
+    )
+
+    # restart command
+    restart_parser = subparsers.add_parser("restart", help="Restart background server")
+    restart_parser.add_argument(
+        "--host",
+        default=None,
+        help="Server host (default: 0.0.0.0)",
+    )
+    restart_parser.add_argument(
+        "--port",
+        type=int,
+        default=None,
+        help="Server port (default: 8080)",
+    )
+    restart_parser.add_argument(
+        "--log-level",
+        default="info",
+        choices=["debug", "info", "warning", "error"],
+        help="Logging level (default: info)",
+    )
+
+    # status command
+    status_parser = subparsers.add_parser("status", help="Check server status")
+
+    # logs command
+    logs_parser = subparsers.add_parser("logs", help="View server logs")
+    logs_parser.add_argument(
+        "-f", "--follow",
+        action="store_true",
+        help="Follow log output (like tail -f)",
+    )
+    logs_parser.add_argument(
+        "-n", "--lines",
+        type=int,
+        default=50,
+        help="Number of lines to show (default: 50)",
+    )
+
+    args = parser.parse_args()
+
+    # Import daemon module only when needed
+    from local_openai2anthropic import daemon
+
+    # Handle subcommands
+    if args.command == "start":
+        # Get settings for defaults
+        settings = get_settings()
+        host = args.host or settings.host
+        port = args.port or settings.port
+
+        success = daemon.start_daemon(
+            host=host,
+            port=port,
+            log_level=args.log_level,
+        )
+        sys.exit(0 if success else 1)
+
+    elif args.command == "stop":
+        success = daemon.stop_daemon(force=args.force)
+        sys.exit(0 if success else 1)
+
+    elif args.command == "restart":
+        # Get settings for defaults
+        settings = get_settings()
+        host = args.host or settings.host
+        port = args.port or settings.port
+
+        success = daemon.restart_daemon(
+            host=host,
+            port=port,
+            log_level=args.log_level,
+        )
+        sys.exit(0 if success else 1)
+
+    elif args.command == "status":
+        running, pid, config = daemon.get_status()
+        if running and config:
+            host = config.get("host", "0.0.0.0")
+            port = config.get("port", 8080)
+            print(f"Server is running (PID: {pid})")
+            print(f"Listening on: {host}:{port}")
+        elif running:
+            print(f"Server is running (PID: {pid})")
+        else:
+            print("Server is not running")
+        sys.exit(0)
+
+    elif args.command == "logs":
+        success = daemon.show_logs(follow=args.follow, lines=args.lines)
+        sys.exit(0 if success else 1)
+
+    else:
+        # No command - run in foreground (original behavior)
+        settings = get_settings()
+        run_foreground(settings)
+
+
 if __name__ == "__main__":
     main()

local_openai2anthropic/router.py

@@ -148,6 +148,23 @@ async def _stream_response(
                     finish_reason = choice["finish_reason"]
                     continue
 
+                # Handle reasoning content (thinking)
+                if delta.get("reasoning_content"):
+                    reasoning = delta["reasoning_content"]
+                    # Start thinking content block if not already started
+                    if not content_block_started or content_block_index == 0:
+                        # We need a separate index for thinking block
+                        # For simplicity, we treat thinking as a separate block before text
+                        if content_block_started:
+                            # Close previous block
+                            yield f"event: content_block_stop\ndata: {json.dumps({'type': 'content_block_stop', 'index': content_block_index})}\n\n"
+                            content_block_index += 1
+                        yield f"event: content_block_start\ndata: {json.dumps({'type': 'content_block_start', 'index': content_block_index, 'content_block': {'type': 'thinking', 'thinking': ''}})}\n\n"
+                        content_block_started = True
+
+                    yield f"event: content_block_delta\ndata: {json.dumps({'type': 'content_block_delta', 'index': content_block_index, 'delta': {'type': 'thinking_delta', 'thinking': reasoning}})}\n\n"
+                    continue
+
                 # Handle content
                 if delta.get("content"):
                     if not content_block_started:
@@ -562,6 +579,7 @@ async def create_message(
     try:
         body_bytes = await request.body()
         body_json = json.loads(body_bytes.decode("utf-8"))
+        logger.info(f"Received body: {body_json}")
         anthropic_params = body_json
     except json.JSONDecodeError as e:
         logger.error(f"Invalid JSON in request body: {e}")

local_openai2anthropic-0.2.2.dist-info/METADATA

@@ -0,0 +1,351 @@
+Metadata-Version: 2.4
+Name: local-openai2anthropic
+Version: 0.2.2
+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.2.dist-info/RECORD

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