Anthropic endpoint for claude code

src/proxy_app/main.py

@@ -1,4 +1,5 @@
 import time
+import uuid
 
 # Phase 1: Minimal imports for arg parsing and TUI
 import asyncio
@@ -99,7 +100,7 @@
     from contextlib import asynccontextmanager
     from fastapi import FastAPI, Request, HTTPException, Depends
     from fastapi.middleware.cors import CORSMiddleware
-    from fastapi.responses import StreamingResponse
+    from fastapi.responses import StreamingResponse, JSONResponse
     from fastapi.security import APIKeyHeader
 
 print("  → Loading core dependencies...")
@@ -213,6 +214,13 @@ class EnrichedModelList(BaseModel):
     data: List[EnrichedModelCard]
 
 
+# --- Anthropic API Models (imported from library) ---
+from rotator_library.anthropic_compat import (
+    AnthropicMessagesRequest,
+    AnthropicCountTokensRequest,
+)
+
+
 # Calculate total loading time
 _elapsed = time.time() - _start_time
 print(
@@ -664,6 +672,27 @@ async def verify_api_key(auth: str = Depends(api_key_header)):
     return auth
 
 
+# --- Anthropic API Key Header ---
+anthropic_api_key_header = APIKeyHeader(name="x-api-key", auto_error=False)
+
+
+async def verify_anthropic_api_key(
+    x_api_key: str = Depends(anthropic_api_key_header),
+    auth: str = Depends(api_key_header),
+):
+    """
+    Dependency to verify API key for Anthropic endpoints.
+    Accepts either x-api-key header (Anthropic style) or Authorization Bearer (OpenAI style).
+    """
+    # Check x-api-key first (Anthropic style)
+    if x_api_key and x_api_key == PROXY_API_KEY:
+        return x_api_key
+    # Fall back to Bearer token (OpenAI style)
+    if auth and auth == f"Bearer {PROXY_API_KEY}":
+        return auth
+    raise HTTPException(status_code=401, detail="Invalid or missing API Key")
+
+
 async def streaming_response_wrapper(
     request: Request,
     request_data: dict,
@@ -963,6 +992,156 @@ async def chat_completions(
         raise HTTPException(status_code=500, detail=str(e))
 
 
+# --- Anthropic Messages API Endpoint ---
+@app.post("/v1/messages")
+async def anthropic_messages(
+    request: Request,
+    body: AnthropicMessagesRequest,
+    client: RotatingClient = Depends(get_rotating_client),
+    _=Depends(verify_anthropic_api_key),
+):
+    """
+    Anthropic-compatible Messages API endpoint.
+
+    Accepts requests in Anthropic's format and returns responses in Anthropic's format.
+    Internally translates to OpenAI format for processing via LiteLLM.
+
+    This endpoint is compatible with Claude Code and other Anthropic API clients.
+    """
+    # Initialize logger if enabled
+    logger = DetailedLogger() if ENABLE_REQUEST_LOGGING else None
+
+    try:
+        # Log the request to console
+        log_request_to_console(
+            url=str(request.url),
+            headers=dict(request.headers),
+            client_info=(
+                request.client.host if request.client else "unknown",
+                request.client.port if request.client else 0,
+            ),
+            request_data=body.model_dump(exclude_none=True),
+        )
+
+        # Use the library method to handle the request
+        result = await client.anthropic_messages(body, raw_request=request)
+
+        if body.stream:
+            # Streaming response
+            return StreamingResponse(
+                result,
+                media_type="text/event-stream",
+                headers={
+                    "Cache-Control": "no-cache",
+                    "Connection": "keep-alive",
+                    "X-Accel-Buffering": "no",
+                },
+            )
+        else:
+            # Non-streaming response
+            if logger:
+                logger.log_final_response(
+                    status_code=200,
+                    headers=None,
+                    body=result,
+                )
+            return JSONResponse(content=result)
+
+    except (
+        litellm.InvalidRequestError,
+        ValueError,
+        litellm.ContextWindowExceededError,
+    ) as e:
+        error_response = {
+            "type": "error",
+            "error": {"type": "invalid_request_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=400, detail=error_response)
+    except litellm.AuthenticationError as e:
+        error_response = {
+            "type": "error",
+            "error": {"type": "authentication_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=401, detail=error_response)
+    except litellm.RateLimitError as e:
+        error_response = {
+            "type": "error",
+            "error": {"type": "rate_limit_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=429, detail=error_response)
+    except (litellm.ServiceUnavailableError, litellm.APIConnectionError) as e:
+        error_response = {
+            "type": "error",
+            "error": {"type": "api_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=503, detail=error_response)
+    except litellm.Timeout as e:
+        error_response = {
+            "type": "error",
+            "error": {"type": "api_error", "message": f"Request timed out: {str(e)}"},
+        }
+        raise HTTPException(status_code=504, detail=error_response)
+    except Exception as e:
+        logging.error(f"Anthropic messages endpoint error: {e}")
+        if logger:
+            logger.log_final_response(
+                status_code=500,
+                headers=None,
+                body={"error": str(e)},
+            )
+        error_response = {
+            "type": "error",
+            "error": {"type": "api_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=500, detail=error_response)
+
+
+# --- Anthropic Count Tokens Endpoint ---
+@app.post("/v1/messages/count_tokens")
+async def anthropic_count_tokens(
+    request: Request,
+    body: AnthropicCountTokensRequest,
+    client: RotatingClient = Depends(get_rotating_client),
+    _=Depends(verify_anthropic_api_key),
+):
+    """
+    Anthropic-compatible count_tokens endpoint.
+
+    Counts the number of tokens that would be used by a Messages API request.
+    This is useful for estimating costs and managing context windows.
+
+    Accepts requests in Anthropic's format and returns token count in Anthropic's format.
+    """
+    try:
+        # Use the library method to handle the request
+        result = await client.anthropic_count_tokens(body)
+        return JSONResponse(content=result)
+
+    except (
+        litellm.InvalidRequestError,
+        ValueError,
+        litellm.ContextWindowExceededError,
+    ) as e:
+        error_response = {
+            "type": "error",
+            "error": {"type": "invalid_request_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=400, detail=error_response)
+    except litellm.AuthenticationError as e:
+        error_response = {
+            "type": "error",
+            "error": {"type": "authentication_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=401, detail=error_response)
+    except Exception as e:
+        logging.error(f"Anthropic count_tokens endpoint error: {e}")
+        error_response = {
+            "type": "error",
+            "error": {"type": "api_error", "message": str(e)},
+        }
+        raise HTTPException(status_code=500, detail=error_response)
+
+
 @app.post("/v1/embeddings")
 async def embeddings(
     request: Request,

src/rotator_library/__init__.py

@@ -8,18 +8,20 @@
     from .providers import PROVIDER_PLUGINS
     from .providers.provider_interface import ProviderInterface
     from .model_info_service import ModelInfoService, ModelInfo, ModelMetadata
+    from . import anthropic_compat
 
 __all__ = [
     "RotatingClient",
     "PROVIDER_PLUGINS",
     "ModelInfoService",
     "ModelInfo",
     "ModelMetadata",
+    "anthropic_compat",
 ]
 
 
 def __getattr__(name):
-    """Lazy-load PROVIDER_PLUGINS and ModelInfoService to speed up module import."""
+    """Lazy-load PROVIDER_PLUGINS, ModelInfoService, and anthropic_compat to speed up module import."""
     if name == "PROVIDER_PLUGINS":
         from .providers import PROVIDER_PLUGINS
 
@@ -36,4 +38,8 @@ def __getattr__(name):
         from .model_info_service import ModelMetadata
 
         return ModelMetadata
+    if name == "anthropic_compat":
+        from . import anthropic_compat
+
+        return anthropic_compat
     raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

src/rotator_library/anthropic_compat/__init__.py

@@ -0,0 +1,67 @@
+"""
+Anthropic API compatibility module for rotator_library.
+
+This module provides format translation between Anthropic's Messages API
+and OpenAI's Chat Completions API, enabling any OpenAI-compatible provider
+to work with Anthropic clients like Claude Code.
+
+Usage:
+    from rotator_library.anthropic_compat import (
+        AnthropicMessagesRequest,
+        AnthropicMessagesResponse,
+        translate_anthropic_request,
+        openai_to_anthropic_response,
+        anthropic_streaming_wrapper,
+    )
+"""
+
+from .models import (
+    AnthropicTextBlock,
+    AnthropicImageSource,
+    AnthropicImageBlock,
+    AnthropicToolUseBlock,
+    AnthropicToolResultBlock,
+    AnthropicMessage,
+    AnthropicTool,
+    AnthropicThinkingConfig,
+    AnthropicMessagesRequest,
+    AnthropicUsage,
+    AnthropicMessagesResponse,
+    AnthropicCountTokensRequest,
+    AnthropicCountTokensResponse,
+)
+
+from .translator import (
+    anthropic_to_openai_messages,
+    anthropic_to_openai_tools,
+    anthropic_to_openai_tool_choice,
+    openai_to_anthropic_response,
+    translate_anthropic_request,
+)
+
+from .streaming import anthropic_streaming_wrapper
+
+__all__ = [
+    # Models
+    "AnthropicTextBlock",
+    "AnthropicImageSource",
+    "AnthropicImageBlock",
+    "AnthropicToolUseBlock",
+    "AnthropicToolResultBlock",
+    "AnthropicMessage",
+    "AnthropicTool",
+    "AnthropicThinkingConfig",
+    "AnthropicMessagesRequest",
+    "AnthropicUsage",
+    "AnthropicMessagesResponse",
+    "AnthropicCountTokensRequest",
+    "AnthropicCountTokensResponse",
+    # Translator functions
+    "anthropic_to_openai_messages",
+    "anthropic_to_openai_tools",
+    "anthropic_to_openai_tool_choice",
+    "openai_to_anthropic_response",
+    "translate_anthropic_request",
+    # Streaming
+    "anthropic_streaming_wrapper",
+]