copilotx 2.3.0__tar.gz → 2.3.2__tar.gz

{copilotx-2.3.0 → copilotx-2.3.2}/.gitignore

@@ -24,3 +24,5 @@ Thumbs.db
 
 # Project specific
 *.log
+# Tests (contains API keys and sensitive config)
+tests/

{copilotx-2.3.0 → copilotx-2.3.2}/PKG-INFO

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: copilotx
-Version: 2.3.0
+Version: 2.3.2
 Summary: Local GitHub Copilot API proxy — use GPT-4o, Claude, Gemini via OpenAI/Anthropic compatible APIs
 Project-URL: Homepage, https://github.com/Polly2014/CopilotX
 Project-URL: Repository, https://github.com/Polly2014/CopilotX
 Project-URL: Issues, https://github.com/Polly2014/CopilotX/issues
-Author-email: Polly <polly@polly.wang>
+Author-email: Polly <im@polly.wang>
 License: MIT
 License-File: LICENSE
 Keywords: anthropic,copilot,llm,openai,proxy
@@ -369,7 +369,8 @@ client = OpenAI(
 | v1.0.0 | Local | OAuth, dual API, streaming, model discovery |
 | v2.0.0 | Remote | API key auth, remote deploy, Nginx/Caddy + systemd templates |
 | v2.1.0 | Codex | Responses API, vision support, dynamic API URL, stream ID sync |
-| **v2.2.0** | **Config** | **`copilotx config` command for client setup (Claude Code)** |
+| v2.2.0 | Config | `copilotx config` command for client setup (Claude Code) |
+| **v2.3.x** | **Polish** | **Error passthrough, stream error handling, test suite** |
 | v3.0.0 | Multi-User | Token pool, user database, OpenRouter mode |
 
 ## ⚠️ Disclaimer

{copilotx-2.3.0 → copilotx-2.3.2}/README.md

@@ -344,7 +344,8 @@ client = OpenAI(
 | v1.0.0 | Local | OAuth, dual API, streaming, model discovery |
 | v2.0.0 | Remote | API key auth, remote deploy, Nginx/Caddy + systemd templates |
 | v2.1.0 | Codex | Responses API, vision support, dynamic API URL, stream ID sync |
-| **v2.2.0** | **Config** | **`copilotx config` command for client setup (Claude Code)** |
+| v2.2.0 | Config | `copilotx config` command for client setup (Claude Code) |
+| **v2.3.x** | **Polish** | **Error passthrough, stream error handling, test suite** |
 | v3.0.0 | Multi-User | Token pool, user database, OpenRouter mode |
 
 ## ⚠️ Disclaimer

{copilotx-2.3.0 → copilotx-2.3.2}/deploy/nginx-copilotx-http.conf

@@ -9,6 +9,9 @@ server {
     listen 80;
     listen [::]:80;
     server_name YOUR_DOMAIN;
+
+    # Allow large request bodies for long conversations (Claude 200K context can exceed 16MB)
+    client_max_body_size 32M;
     
     # Let's Encrypt challenge
     location /.well-known/acme-challenge/ {

{copilotx-2.3.0 → copilotx-2.3.2}/deploy/nginx-copilotx.conf

@@ -38,8 +38,8 @@ server {
     include /etc/letsencrypt/options-ssl-nginx.conf;
     ssl_dhparam /etc/letsencrypt/ssl-dhparams.pem;
 
-    # Allow large request bodies for long prompts (default 1MB is too small)
-    client_max_body_size 16M;
+    # Allow large request bodies for long conversations (Claude 200K context can exceed 16MB)
+    client_max_body_size 32M;
 
     # Security headers
     add_header X-Frame-Options "SAMEORIGIN" always;

{copilotx-2.3.0 → copilotx-2.3.2}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "copilotx"
-version = "2.3.0"
+version = "2.3.2"
 description = "Local GitHub Copilot API proxy — use GPT-4o, Claude, Gemini via OpenAI/Anthropic compatible APIs"
 readme = "README.md"
 license = { text = "MIT" }
 requires-python = ">=3.10"
-authors = [{ name = "Polly", email = "polly@polly.wang" }]
+authors = [{ name = "Polly", email = "im@polly.wang" }]
 keywords = ["copilot", "llm", "proxy", "openai", "anthropic"]
 classifiers = [
     "Development Status :: 5 - Production/Stable",

{copilotx-2.3.0 → copilotx-2.3.2}/src/copilotx/__init__.py

@@ -1,3 +1,3 @@
 """CopilotX — Local GitHub Copilot API proxy."""
 
-__version__ = "2.3.0"
+__version__ = "2.3.2"

{copilotx-2.3.0 → copilotx-2.3.2}/src/copilotx/proxy/client.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import json
+import logging
 import time
 from typing import Any, AsyncIterator
 
@@ -18,6 +19,8 @@ from copilotx.config import (
     REQUEST_TIMEOUT,
 )
 
+logger = logging.getLogger(__name__)
+
 
 class CopilotClient:
     """Async client that talks to the Copilot API (dynamic base URL)."""
@@ -87,7 +90,17 @@ class CopilotClient:
         assert self._client is not None
         url = f"{self._api_base}{COPILOT_CHAT_COMPLETIONS_PATH}"
         resp = await self._client.post(url, json=payload, headers=self._headers())
-        resp.raise_for_status()
+        if resp.status_code >= 400:
+            error_body = resp.text
+            logger.error(
+                "Chat completions error: status=%d body=%s",
+                resp.status_code, error_body[:1000],
+            )
+            raise httpx.HTTPStatusError(
+                f"HTTP {resp.status_code}: {error_body[:500]}",
+                request=resp.request,
+                response=resp,
+            )
         return resp.json()
 
     # ── Chat Completions (streaming) ────────────────────────────────
@@ -101,7 +114,17 @@ class CopilotClient:
         async with self._client.stream(
             "POST", url, json=payload, headers=self._headers(),
         ) as resp:
-            resp.raise_for_status()
+            if resp.status_code >= 400:
+                error_body = await resp.aread()
+                logger.error(
+                    "Chat completions stream error: status=%d body=%s",
+                    resp.status_code, error_body[:1000],
+                )
+                raise httpx.HTTPStatusError(
+                    f"HTTP {resp.status_code}: {error_body.decode('utf-8', errors='replace')[:500]}",
+                    request=resp.request,
+                    response=resp,
+                )
             async for line in resp.aiter_lines():
                 if line:
                     yield (line + "\n").encode("utf-8")
@@ -124,10 +147,22 @@ class CopilotClient:
         # Strip service_tier — not supported by GitHub Copilot
         payload.pop("service_tier", None)
 
+        logger.debug("Responses API request: url=%s payload_keys=%s", url, list(payload.keys()))
+
         resp = await self._client.post(
             url, json=payload, headers=self._headers(extra_headers),
         )
-        resp.raise_for_status()
+        if resp.status_code >= 400:
+            error_body = resp.text
+            logger.error(
+                "Responses API error: status=%d url=%s body=%s",
+                resp.status_code, url, error_body[:1000],
+            )
+            raise httpx.HTTPStatusError(
+                f"HTTP {resp.status_code}: {error_body[:500]}",
+                request=resp.request,
+                response=resp,
+            )
         return resp.json()
 
     # ── Responses API (streaming) ───────────────────────────────────
@@ -150,7 +185,17 @@ class CopilotClient:
         async with self._client.stream(
             "POST", url, json=payload, headers=self._headers(extra_headers),
         ) as resp:
-            resp.raise_for_status()
+            if resp.status_code >= 400:
+                error_body = await resp.aread()
+                logger.error(
+                    "Responses stream error: status=%d url=%s body=%s",
+                    resp.status_code, url, error_body[:1000],
+                )
+                raise httpx.HTTPStatusError(
+                    f"HTTP {resp.status_code}: {error_body.decode('utf-8', errors='replace')[:500]}",
+                    request=resp.request,
+                    response=resp,
+                )
             async for line in resp.aiter_lines():
                 if line:
                     yield (line + "\n").encode("utf-8")

{copilotx-2.3.0 → copilotx-2.3.2}/src/copilotx/proxy/translator.py

@@ -381,11 +381,47 @@ def openai_to_anthropic_response(openai_resp: dict, model: str) -> dict:
     """Convert an OpenAI chat completion response to Anthropic /v1/messages format.
 
     Handles text content, tool_calls, and mixed responses.
+
+    IMPORTANT: Copilot backend may split text and tool_calls into separate choices:
+      choices[0] = {"message": {"content": "text..."}, "finish_reason": "tool_calls"}
+      choices[1] = {"message": {"tool_calls": [...]},   "finish_reason": "tool_calls"}
+    We must merge ALL choices to build the complete Anthropic response.
     """
-    choice = openai_resp.get("choices", [{}])[0]
-    message = choice.get("message", {})
-    content_text = message.get("content", "")
-    tool_calls = message.get("tool_calls")
+    choices = openai_resp.get("choices", [{}])
+
+    # Merge content and tool_calls from ALL choices
+    # (Copilot backend splits them into separate choices)
+    content_text = ""
+    all_tool_calls: list[dict] = []
+    finish_reason = "end_turn"
+
+    for choice in choices:
+        message = choice.get("message", {})
+
+        # Collect text content
+        text = message.get("content")
+        if text:
+            if content_text:
+                content_text += "\n" + text
+            else:
+                content_text = text
+
+        # Collect tool_calls
+        tc_list = message.get("tool_calls")
+        if tc_list:
+            all_tool_calls.extend(tc_list)
+
+        # Use the most specific finish_reason
+        fr = choice.get("finish_reason")
+        if fr == "tool_calls":
+            finish_reason = "tool_calls"
+        elif fr and finish_reason not in ("tool_calls",):
+            finish_reason = fr
+
+    logger.debug(
+        "OpenAI response: %d choices, text=%d chars, tool_calls=%d, finish=%s",
+        len(choices), len(content_text), len(all_tool_calls), finish_reason,
+    )
 
     # Build content blocks
     content_blocks: list[dict[str, Any]] = []
@@ -395,8 +431,8 @@ def openai_to_anthropic_response(openai_resp: dict, model: str) -> dict:
         content_blocks.append({"type": "text", "text": content_text})
 
     # Convert OpenAI tool_calls → Anthropic tool_use blocks
-    if tool_calls:
-        for tc in tool_calls:
+    if all_tool_calls:
+        for tc in all_tool_calls:
             func = tc.get("function", {})
             # Parse arguments JSON string → dict
             try:
@@ -416,7 +452,6 @@ def openai_to_anthropic_response(openai_resp: dict, model: str) -> dict:
         content_blocks.append({"type": "text", "text": ""})
 
     # Map finish_reason
-    finish_reason = choice.get("finish_reason", "end_turn")
     stop_reason_map = {
         "stop": "end_turn",
         "length": "max_tokens",
@@ -516,12 +551,29 @@ async def openai_stream_to_anthropic_stream(
             yield _sse_event("message_start", start_event)
             sent_start = True
 
-        # Extract delta
-        choice = chunk.get("choices", [{}])[0]
-        delta = choice.get("delta", {})
-        chunk_finish = choice.get("finish_reason")
-        content = delta.get("content")
-        tool_calls = delta.get("tool_calls")
+        # Extract delta from ALL choices (Copilot may split text/tool_calls
+        # into separate choices with different indices)
+        content = None
+        tool_calls = None
+        chunk_finish = None
+
+        for choice in chunk.get("choices", []):
+            delta = choice.get("delta", {})
+
+            # Collect text content from any choice
+            c = delta.get("content")
+            if c:
+                content = c
+
+            # Collect tool_calls from any choice
+            tc = delta.get("tool_calls")
+            if tc:
+                tool_calls = tc
+
+            # Track finish reason from any choice
+            fr = choice.get("finish_reason")
+            if fr:
+                chunk_finish = fr
 
         # Track finish reason
         if chunk_finish:

{copilotx-2.3.0 → copilotx-2.3.2}/src/copilotx/server/app.py

@@ -6,6 +6,7 @@ from contextlib import asynccontextmanager
 from typing import AsyncIterator
 
 from fastapi import FastAPI, Request, Response
+from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from starlette.middleware.base import BaseHTTPMiddleware
 
@@ -15,6 +16,16 @@ from copilotx.config import COPILOTX_API_KEY, LOCALHOST_ADDRS, PUBLIC_PATHS
 from copilotx.proxy.client import CopilotClient
 
 
+# ── CORS Configuration ──────────────────────────────────────────────
+
+CORS_ORIGINS = [
+    "https://polly.wang",
+    "https://www.polly.wang",
+    "http://127.0.0.1:1111",   # Zola dev server
+    "http://localhost:1111",  # Zola dev server (localhost)
+]
+
+
 # ── API Key Middleware ──────────────────────────────────────────────
 
 
@@ -30,6 +41,10 @@ class ApiKeyMiddleware(BaseHTTPMiddleware):
     """
 
     async def dispatch(self, request: Request, call_next) -> Response:
+        # CORS preflight requests must pass through (handled by CORSMiddleware)
+        if request.method == "OPTIONS":
+            return await call_next(request)
+
         # No API key configured → fully open (local mode)
         if not COPILOTX_API_KEY:
             return await call_next(request)
@@ -107,6 +122,15 @@ def create_app(token_manager: TokenManager) -> FastAPI:
     )
     app.state.token_manager = token_manager
 
+    # Add CORS middleware (must be before other middlewares)
+    app.add_middleware(
+        CORSMiddleware,
+        allow_origins=CORS_ORIGINS,
+        allow_credentials=True,
+        allow_methods=["*"],
+        allow_headers=["*"],
+    )
+
     # Add API key middleware
     app.add_middleware(ApiKeyMiddleware)
 

{copilotx-2.3.0 → copilotx-2.3.2}/src/copilotx/server/routes_anthropic.py

@@ -6,6 +6,7 @@ the Copilot backend speaks), and translates responses back.
 
 from __future__ import annotations
 
+import json
 import logging
 
 from fastapi import APIRouter, Request
@@ -63,13 +64,23 @@ async def messages(request: Request):
             return JSONResponse(content=anthropic_resp)
     except Exception as e:
         logger.error("Copilot backend error: %s", e)
-        return JSONResponse(
-            status_code=502,
-            content={
-                "type": "error",
-                "error": {
-                    "type": "upstream_error",
-                    "message": f"Copilot backend error: {e}",
-                },
+        status_code = 502
+        error_content = {
+            "type": "error",
+            "error": {
+                "type": "upstream_error",
+                "message": f"Copilot backend error: {e}",
             },
-        )
+        }
+        if hasattr(e, 'response') and e.response is not None:
+            status_code = e.response.status_code
+            try:
+                # Try to parse backend JSON error and extract message
+                backend_error = json.loads(e.response.text)
+                if "error" in backend_error:
+                    error_content["error"]["message"] = backend_error["error"].get("message", str(backend_error["error"]))
+                else:
+                    error_content["error"]["message"] = e.response.text[:500]
+            except (json.JSONDecodeError, ValueError):
+                error_content["error"]["message"] = e.response.text[:500]
+        return JSONResponse(status_code=status_code, content=error_content)

{copilotx-2.3.0 → copilotx-2.3.2}/src/copilotx/server/routes_openai.py

@@ -6,12 +6,17 @@ the Copilot backend already speaks OpenAI format.
 
 from __future__ import annotations
 
+import json
+import logging
+
 from fastapi import APIRouter, Request
 from fastapi.responses import JSONResponse
 
 from copilotx.proxy.streaming import sse_response
 from copilotx.server.app import get_ready_client
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(tags=["OpenAI"])
 
 
@@ -31,12 +36,19 @@ async def chat_completions(request: Request):
             result = await client.chat_completions(body)
             return JSONResponse(content=result)
     except Exception as e:
-        return JSONResponse(
-            status_code=502,
-            content={
-                "error": {
-                    "message": f"Copilot backend error: {e}",
-                    "type": "upstream_error",
-                }
-            },
-        )
+        logger.error("Chat completions error: %s", e)
+        status_code = 502
+        error_content = {
+            "error": {
+                "message": f"Copilot backend error: {e}",
+                "type": "upstream_error",
+            }
+        }
+        if hasattr(e, 'response') and e.response is not None:
+            status_code = e.response.status_code
+            try:
+                # Try to parse and forward the backend's JSON error
+                error_content = json.loads(e.response.text)
+            except (json.JSONDecodeError, ValueError):
+                error_content["error"]["message"] = e.response.text[:500]
+        return JSONResponse(status_code=status_code, content=error_content)

{copilotx-2.3.0 → copilotx-2.3.2}/src/copilotx/server/routes_responses.py

@@ -57,15 +57,21 @@ async def responses(request: Request):
             return JSONResponse(content=result)
     except Exception as e:
         logger.error("Responses API error: %s", e)
-        return JSONResponse(
-            status_code=502,
-            content={
-                "error": {
-                    "message": f"Copilot backend error: {e}",
-                    "type": "upstream_error",
-                }
-            },
-        )
+        status_code = 502
+        error_content = {
+            "error": {
+                "message": f"Copilot backend error: {e}",
+                "type": "upstream_error",
+            }
+        }
+        if hasattr(e, 'response') and e.response is not None:
+            status_code = e.response.status_code
+            try:
+                # Try to parse and forward the backend's JSON error
+                error_content = json.loads(e.response.text)
+            except (json.JSONDecodeError, ValueError):
+                error_content["error"]["message"] = e.response.text[:500]
+        return JSONResponse(status_code=status_code, content=error_content)
 
 
 # ═══════════════════════════════════════════════════════════════════

copilotx-2.3.0/test_remote.sh

@@ -1,137 +0,0 @@
-#!/bin/bash
-# CopilotX v2.1.0 远程服务完整测试脚本
-
-set -e
-
-API_KEY=$(grep COPILOTX_API_KEY ~/.copilotx/.env | cut -d= -f2)
-BASE_URL="https://api.polly.wang"
-
-echo "╔══════════════════════════════════════════════════════════════╗"
-echo "║         CopilotX v2.1.0 远程服务完整测试                      ║"
-echo "╚══════════════════════════════════════════════════════════════╝"
-echo ""
-
-# 1. 健康检查
-echo "=== 1. 健康检查 ==="
-curl -s $BASE_URL/health | python3 -m json.tool
-echo ""
-
-# 2. API Key 保护
-echo "=== 2. API Key 保护测试 ==="
-echo -n "   无 Key 访问: "
-RESULT=$(curl -s $BASE_URL/v1/models)
-if echo "$RESULT" | grep -q "error"; then
-    echo "❌ 被拒绝 ✓ (预期行为)"
-else
-    echo "⚠️ 未保护"
-fi
-echo ""
-
-# 3. 模型列表
-echo "=== 3. 模型列表 ==="
-curl -s $BASE_URL/v1/models -H "Authorization: Bearer $API_KEY" | python3 -c "
-import sys,json
-d=json.load(sys.stdin)
-print(f'   ✅ 获取 {len(d[\"data\"])} 个模型')
-for m in d['data'][:6]:
-    print(f\"      - {m['id']} ({m['owned_by']})\")
-print('      ...')
-"
-echo ""
-
-# 4. Chat Completions 非流式
-echo "=== 4. OpenAI Chat Completions (非流式) ==="
-curl -s $BASE_URL/v1/chat/completions \
-  -H "Authorization: Bearer $API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "Reply exactly: Hello CopilotX!"}], "max_tokens": 15}' | python3 -c "
-import sys,json
-d=json.load(sys.stdin)
-if 'choices' in d:
-    print(f\"   ✅ GPT-4o: {d['choices'][0]['message']['content']}\")
-else:
-    print(f\"   ❌ 错误: {d}\")
-"
-echo ""
-
-# 5. Chat Completions 流式
-echo "=== 5. OpenAI Chat Completions (流式) ==="
-echo -n "   ✅ 流式: "
-curl -sN $BASE_URL/v1/chat/completions \
-  -H "Authorization: Bearer $API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"model": "gpt-4o", "messages": [{"role": "user", "content": "Count 1,2,3,4,5"}], "stream": true, "max_tokens": 20}' 2>/dev/null | \
-  grep -oP '"content":"[^"]*"' | head -8 | sed 's/"content":"//g; s/"//g' | tr -d '\n'
-echo ""
-echo ""
-
-# 6. Anthropic Messages
-echo "=== 6. Anthropic /v1/messages ==="
-curl -s $BASE_URL/v1/messages \
-  -H "Authorization: Bearer $API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"model": "claude-sonnet-4", "max_tokens": 25, "messages": [{"role": "user", "content": "Say hello in French"}]}' | python3 -c "
-import sys,json
-d=json.load(sys.stdin)
-if 'content' in d:
-    print(f\"   ✅ Claude: {d['content'][0]['text']}\")
-else:
-    print(f\"   ❌ 错误: {d}\")
-"
-echo ""
-
-# 7. Responses API 非流式
-echo "=== 7. Responses API (非流式) ==="
-echo "   注意: 仅 GPT-5 系列支持 Responses API"
-curl -s $BASE_URL/v1/responses \
-  -H "Authorization: Bearer $API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"model": "gpt-5-mini", "input": "2+2=?"}' | python3 -c "
-import sys,json
-d=json.load(sys.stdin)
-if 'output' in d:
-    for item in d['output']:
-        if item.get('type') == 'message':
-            for c in item.get('content', []):
-                if c.get('type') == 'output_text':
-                    print(f\"   ✅ Responses: {c.get('text', '')[:80]}\")
-                    break
-            break
-    else:
-        print(f\"   ✅ Responses: {str(d['output'])[:80]}\")
-elif 'error' in d:
-    print(f\"   ❌ 错误: {d['error']}\")
-else:
-    print(f\"   ⚠️ 响应: {str(d)[:100]}\")
-"
-echo ""
-
-# 8. Responses API 流式
-echo "=== 8. Responses API (流式) ==="
-echo -n "   ✅ 事件类型: "
-curl -sN $BASE_URL/v1/responses \
-  -H "Authorization: Bearer $API_KEY" \
-  -H "Content-Type: application/json" \
-  -d '{"model": "gpt-5-mini", "input": "Hi", "stream": true}' 2>/dev/null | \
-  head -8 | grep -oP '"type":"[^"]*"' | sort -u | head -4 | tr '\n' ' '
-echo ""
-echo ""
-
-# 9. x-api-key 认证
-echo "=== 9. x-api-key 认证 ==="
-curl -s $BASE_URL/v1/models -H "x-api-key: $API_KEY" | python3 -c "
-import sys,json
-d=json.load(sys.stdin)
-print(f\"   ✅ x-api-key 认证成功\" if 'data' in d else f\"   ❌ 失败\")
-"
-echo ""
-
-# 10. SSL 证书
-echo "=== 10. SSL 证书 ==="
-echo | openssl s_client -connect api.polly.wang:443 -servername api.polly.wang 2>/dev/null | \
-  openssl x509 -noout -dates -issuer 2>/dev/null | sed 's/^/   /'
-echo ""
-
-echo "╔══════════════════════════════════════════════════════════════╗"
-echo "║                   ✅ 测试完成                                 ║"
-echo "╚══════════════════════════════════════════════════════════════╝"

copilotx-2.3.0/tests/test_tools_translation.py

@@ -1,469 +0,0 @@
-"""Tests for Anthropic ↔ OpenAI tools translation.
-
-Verifies that CopilotX correctly translates:
-  1. Anthropic tool definitions → OpenAI tools/functions
-  2. Anthropic tool_use blocks → OpenAI tool_calls
-  3. Anthropic tool_result blocks → OpenAI tool messages
-  4. OpenAI tool_calls response → Anthropic tool_use content blocks
-  5. OpenAI tool_calls streaming → Anthropic tool_use SSE events
-  6. tool_choice conversion
-"""
-
-import asyncio
-import json
-
-from copilotx.proxy.translator import (
-    _convert_anthropic_tool_choice,
-    _convert_anthropic_tools,
-    anthropic_to_openai_request,
-    openai_stream_to_anthropic_stream,
-    openai_to_anthropic_response,
-)
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  1. Tools definitions conversion
-# ═══════════════════════════════════════════════════════════════════
-
-
-def test_tools_definition_conversion():
-    """Anthropic tools → OpenAI tools."""
-    anthropic_tools = [
-        {
-            "name": "read_file",
-            "description": "Read a file from disk",
-            "input_schema": {
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string", "description": "File path"},
-                },
-                "required": ["path"],
-            },
-        },
-        {
-            "name": "write_file",
-            "description": "Write content to a file",
-            "input_schema": {
-                "type": "object",
-                "properties": {
-                    "path": {"type": "string"},
-                    "content": {"type": "string"},
-                },
-                "required": ["path", "content"],
-            },
-        },
-    ]
-
-    result = _convert_anthropic_tools(anthropic_tools)
-
-    assert len(result) == 2
-    assert result[0]["type"] == "function"
-    assert result[0]["function"]["name"] == "read_file"
-    assert result[0]["function"]["description"] == "Read a file from disk"
-    assert result[0]["function"]["parameters"]["required"] == ["path"]
-
-    assert result[1]["function"]["name"] == "write_file"
-    assert len(result[1]["function"]["parameters"]["required"]) == 2
-
-    print("✅ Tools definition conversion: PASSED")
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  2. tool_choice conversion
-# ═══════════════════════════════════════════════════════════════════
-
-
-def test_tool_choice_conversion():
-    """Anthropic tool_choice → OpenAI tool_choice."""
-    # Auto
-    assert _convert_anthropic_tool_choice({"type": "auto"}) == "auto"
-    assert _convert_anthropic_tool_choice("auto") == "auto"
-
-    # Any → required
-    assert _convert_anthropic_tool_choice({"type": "any"}) == "required"
-    assert _convert_anthropic_tool_choice("any") == "required"
-
-    # None
-    assert _convert_anthropic_tool_choice({"type": "none"}) == "none"
-    assert _convert_anthropic_tool_choice("none") == "none"
-
-    # Specific tool
-    result = _convert_anthropic_tool_choice({"type": "tool", "name": "read_file"})
-    assert result == {"type": "function", "function": {"name": "read_file"}}
-
-    print("✅ tool_choice conversion: PASSED")
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  3. Full request translation with tools
-# ═══════════════════════════════════════════════════════════════════
-
-
-def test_full_request_with_tools():
-    """Complete Anthropic request with tools → OpenAI format."""
-    anthropic_request = {
-        "model": "claude-sonnet-4",
-        "max_tokens": 4096,
-        "system": "You are a helpful assistant.",
-        "tools": [
-            {
-                "name": "read_file",
-                "description": "Read a file",
-                "input_schema": {
-                    "type": "object",
-                    "properties": {"path": {"type": "string"}},
-                    "required": ["path"],
-                },
-            }
-        ],
-        "tool_choice": {"type": "auto"},
-        "messages": [
-            {"role": "user", "content": "Read the file /tmp/test.txt"},
-        ],
-        "stream": True,
-    }
-
-    result = anthropic_to_openai_request(anthropic_request)
-
-    assert result["model"] == "claude-sonnet-4"
-    assert result["max_tokens"] == 4096
-    assert result["stream"] is True
-    assert len(result["messages"]) == 2  # system + user
-    assert "tools" in result
-    assert len(result["tools"]) == 1
-    assert result["tools"][0]["type"] == "function"
-    assert result["tools"][0]["function"]["name"] == "read_file"
-    assert result["tool_choice"] == "auto"
-
-    print("✅ Full request with tools: PASSED")
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  4. tool_use / tool_result message conversion
-# ═══════════════════════════════════════════════════════════════════
-
-
-def test_tool_use_message_conversion():
-    """Assistant message with tool_use → OpenAI assistant with tool_calls."""
-    anthropic_request = {
-        "model": "claude-sonnet-4",
-        "max_tokens": 4096,
-        "messages": [
-            {"role": "user", "content": "Read /tmp/test.txt"},
-            {
-                "role": "assistant",
-                "content": [
-                    {"type": "text", "text": "I'll read that file for you."},
-                    {
-                        "type": "tool_use",
-                        "id": "toolu_abc123",
-                        "name": "read_file",
-                        "input": {"path": "/tmp/test.txt"},
-                    },
-                ],
-            },
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "tool_result",
-                        "tool_use_id": "toolu_abc123",
-                        "content": "File content: Hello World",
-                    }
-                ],
-            },
-        ],
-    }
-
-    result = anthropic_to_openai_request(anthropic_request)
-
-    # Should produce: user, assistant (with tool_calls), tool
-    assert len(result["messages"]) == 3
-
-    # Assistant message
-    assistant_msg = result["messages"][1]
-    assert assistant_msg["role"] == "assistant"
-    assert assistant_msg["content"] == "I'll read that file for you."
-    assert len(assistant_msg["tool_calls"]) == 1
-    assert assistant_msg["tool_calls"][0]["id"] == "toolu_abc123"
-    assert assistant_msg["tool_calls"][0]["type"] == "function"
-    assert assistant_msg["tool_calls"][0]["function"]["name"] == "read_file"
-    args = json.loads(assistant_msg["tool_calls"][0]["function"]["arguments"])
-    assert args == {"path": "/tmp/test.txt"}
-
-    # Tool result message
-    tool_msg = result["messages"][2]
-    assert tool_msg["role"] == "tool"
-    assert tool_msg["tool_call_id"] == "toolu_abc123"
-    assert tool_msg["content"] == "File content: Hello World"
-
-    print("✅ tool_use/tool_result message conversion: PASSED")
-
-
-def test_tool_result_with_error():
-    """Tool result with is_error flag."""
-    anthropic_request = {
-        "model": "claude-sonnet-4",
-        "max_tokens": 4096,
-        "messages": [
-            {"role": "user", "content": "Read /nonexistent"},
-            {
-                "role": "assistant",
-                "content": [
-                    {
-                        "type": "tool_use",
-                        "id": "toolu_err123",
-                        "name": "read_file",
-                        "input": {"path": "/nonexistent"},
-                    },
-                ],
-            },
-            {
-                "role": "user",
-                "content": [
-                    {
-                        "type": "tool_result",
-                        "tool_use_id": "toolu_err123",
-                        "content": "File not found",
-                        "is_error": True,
-                    }
-                ],
-            },
-        ],
-    }
-
-    result = anthropic_to_openai_request(anthropic_request)
-    tool_msg = result["messages"][2]
-    assert tool_msg["role"] == "tool"
-    assert "[ERROR]" in tool_msg["content"]
-
-    print("✅ tool_result with error: PASSED")
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  5. Non-streaming response with tool_calls
-# ═══════════════════════════════════════════════════════════════════
-
-
-def test_response_with_tool_calls():
-    """OpenAI response with tool_calls → Anthropic tool_use."""
-    openai_resp = {
-        "id": "chatcmpl-123",
-        "choices": [
-            {
-                "message": {
-                    "content": "Let me read that file.",
-                    "tool_calls": [
-                        {
-                            "id": "call_abc123",
-                            "type": "function",
-                            "function": {
-                                "name": "read_file",
-                                "arguments": '{"path": "/tmp/test.txt"}',
-                            },
-                        }
-                    ],
-                },
-                "finish_reason": "tool_calls",
-            }
-        ],
-        "usage": {"prompt_tokens": 100, "completion_tokens": 50},
-    }
-
-    result = openai_to_anthropic_response(openai_resp, "claude-sonnet-4")
-
-    assert result["type"] == "message"
-    assert result["role"] == "assistant"
-    assert result["stop_reason"] == "tool_use"
-    assert len(result["content"]) == 2
-
-    # Text block
-    assert result["content"][0]["type"] == "text"
-    assert result["content"][0]["text"] == "Let me read that file."
-
-    # Tool use block
-    assert result["content"][1]["type"] == "tool_use"
-    assert result["content"][1]["id"] == "call_abc123"
-    assert result["content"][1]["name"] == "read_file"
-    assert result["content"][1]["input"] == {"path": "/tmp/test.txt"}
-
-    print("✅ Non-streaming response with tool_calls: PASSED")
-
-
-def test_response_tool_calls_only():
-    """OpenAI response with tool_calls but no text."""
-    openai_resp = {
-        "choices": [
-            {
-                "message": {
-                    "content": None,
-                    "tool_calls": [
-                        {
-                            "id": "call_xyz",
-                            "type": "function",
-                            "function": {
-                                "name": "write_file",
-                                "arguments": '{"path": "/tmp/out.txt", "content": "Hello"}',
-                            },
-                        }
-                    ],
-                },
-                "finish_reason": "tool_calls",
-            }
-        ],
-        "usage": {},
-    }
-
-    result = openai_to_anthropic_response(openai_resp, "claude-sonnet-4")
-    assert result["stop_reason"] == "tool_use"
-    assert len(result["content"]) == 1  # Only tool_use, no text
-    assert result["content"][0]["type"] == "tool_use"
-
-    print("✅ Response with tool_calls only (no text): PASSED")
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  6. Streaming response with tool_calls
-# ═══════════════════════════════════════════════════════════════════
-
-
-async def _test_streaming_with_tool_calls():
-    """OpenAI streaming tool_calls → Anthropic tool_use SSE events."""
-
-    # Simulate OpenAI SSE stream with tool calls
-    openai_chunks = [
-        # First chunk: text content
-        b'data: {"choices":[{"delta":{"role":"assistant","content":""},"index":0}]}\n',
-        b'data: {"choices":[{"delta":{"content":"Let me "},"index":0}]}\n',
-        b'data: {"choices":[{"delta":{"content":"read that."},"index":0}]}\n',
-        # Tool call starts
-        b'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"id":"call_123","type":"function","function":{"name":"read_file","arguments":""}}]},"index":0}]}\n',
-        # Tool call arguments stream
-        b'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"{\\"pa"}}]},"index":0}]}\n',
-        b'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"th\\": \\"/tmp"}}]},"index":0}]}\n',
-        b'data: {"choices":[{"delta":{"tool_calls":[{"index":0,"function":{"arguments":"/test.txt\\"}"}}]},"index":0}]}\n',
-        # Finish
-        b'data: {"choices":[{"delta":{},"index":0,"finish_reason":"tool_calls"}]}\n',
-        b"data: [DONE]\n",
-    ]
-
-    async def mock_stream():
-        for chunk in openai_chunks:
-            yield chunk
-
-    events = []
-    async for event_bytes in openai_stream_to_anthropic_stream(
-        mock_stream(), "claude-sonnet-4"
-    ):
-        text = event_bytes.decode("utf-8").strip()
-        for line_pair in text.split("\n\n"):
-            lines = line_pair.strip().split("\n")
-            if len(lines) >= 2:
-                event_type = lines[0].replace("event: ", "")
-                data = json.loads(lines[1].replace("data: ", ""))
-                events.append((event_type, data))
-
-    # Verify event sequence
-    event_types = [e[0] for e in events]
-
-    assert "message_start" in event_types
-    assert "content_block_start" in event_types
-    assert "content_block_delta" in event_types
-    assert "content_block_stop" in event_types
-    assert "message_delta" in event_types
-    assert "message_stop" in event_types
-
-    # Find tool_use events
-    tool_start_events = [
-        (t, d) for t, d in events
-        if t == "content_block_start" and d.get("content_block", {}).get("type") == "tool_use"
-    ]
-    assert len(tool_start_events) == 1
-    assert tool_start_events[0][1]["content_block"]["name"] == "read_file"
-    assert tool_start_events[0][1]["content_block"]["id"] == "call_123"
-
-    # Find input_json_delta events
-    json_deltas = [
-        (t, d) for t, d in events
-        if t == "content_block_delta" and d.get("delta", {}).get("type") == "input_json_delta"
-    ]
-    assert len(json_deltas) >= 1
-
-    # Reconstruct the arguments
-    full_args = "".join(d["delta"]["partial_json"] for _, d in json_deltas)
-    parsed = json.loads(full_args)
-    assert parsed == {"path": "/tmp/test.txt"}
-
-    # Check stop_reason
-    msg_delta = [d for t, d in events if t == "message_delta"][0]
-    assert msg_delta["delta"]["stop_reason"] == "tool_use"
-
-    print("✅ Streaming with tool_calls: PASSED")
-
-
-def test_streaming_with_tool_calls():
-    asyncio.run(_test_streaming_with_tool_calls())
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  7. Multiple tool calls in one response
-# ═══════════════════════════════════════════════════════════════════
-
-
-def test_multiple_tool_calls():
-    """OpenAI response with multiple tool_calls."""
-    openai_resp = {
-        "choices": [
-            {
-                "message": {
-                    "content": None,
-                    "tool_calls": [
-                        {
-                            "id": "call_1",
-                            "type": "function",
-                            "function": {
-                                "name": "read_file",
-                                "arguments": '{"path": "/a.txt"}',
-                            },
-                        },
-                        {
-                            "id": "call_2",
-                            "type": "function",
-                            "function": {
-                                "name": "read_file",
-                                "arguments": '{"path": "/b.txt"}',
-                            },
-                        },
-                    ],
-                },
-                "finish_reason": "tool_calls",
-            }
-        ],
-        "usage": {},
-    }
-
-    result = openai_to_anthropic_response(openai_resp, "claude-sonnet-4")
-    assert len(result["content"]) == 2
-    assert result["content"][0]["type"] == "tool_use"
-    assert result["content"][0]["name"] == "read_file"
-    assert result["content"][1]["type"] == "tool_use"
-    assert result["content"][1]["input"]["path"] == "/b.txt"
-
-    print("✅ Multiple tool calls: PASSED")
-
-
-# ═══════════════════════════════════════════════════════════════════
-#  Run all tests
-# ═══════════════════════════════════════════════════════════════════
-
-if __name__ == "__main__":
-    test_tools_definition_conversion()
-    test_tool_choice_conversion()
-    test_full_request_with_tools()
-    test_tool_use_message_conversion()
-    test_tool_result_with_error()
-    test_response_with_tool_calls()
-    test_response_tool_calls_only()
-    test_streaming_with_tool_calls()
-    test_multiple_tool_calls()
-    print("\n🎉 All tools translation tests passed!")