router-maestro 0.1.2__py3-none-any.whl

router_maestro/server/routes/anthropic.py

@@ -0,0 +1,228 @@
+"""Anthropic Messages API compatible route."""
+
+import json
+import uuid
+from collections.abc import AsyncGenerator
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+
+from router_maestro.providers import ChatRequest, ProviderError
+from router_maestro.routing import Router, get_router
+from router_maestro.server.schemas.anthropic import (
+    AnthropicCountTokensRequest,
+    AnthropicMessagesRequest,
+    AnthropicMessagesResponse,
+    AnthropicStreamState,
+    AnthropicTextBlock,
+    AnthropicUsage,
+)
+from router_maestro.server.translation import (
+    translate_anthropic_to_openai,
+    translate_openai_chunk_to_anthropic_events,
+)
+from router_maestro.utils import (
+    estimate_tokens_from_char_count,
+    get_logger,
+    map_openai_stop_reason_to_anthropic,
+)
+
+logger = get_logger("server.routes.anthropic")
+
+router = APIRouter()
+
+
+@router.post("/v1/messages")
+@router.post("/api/anthropic/v1/messages")
+async def messages(request: AnthropicMessagesRequest):
+    """Handle Anthropic Messages API requests."""
+    logger.info(
+        "Received Anthropic messages request: model=%s, stream=%s",
+        request.model,
+        request.stream,
+    )
+    model_router = get_router()
+
+    # Translate Anthropic request to OpenAI format
+    chat_request = translate_anthropic_to_openai(request)
+
+    if request.stream:
+        # Estimate input tokens for context display
+        estimated_tokens = _estimate_input_tokens(request)
+        return StreamingResponse(
+            stream_response(model_router, chat_request, request.model, estimated_tokens),
+            media_type="text/event-stream",
+        )
+
+    try:
+        response, provider_name = await model_router.chat_completion(chat_request)
+
+        # Build Anthropic response
+        content = []
+        if response.content:
+            content.append(AnthropicTextBlock(type="text", text=response.content))
+
+        usage = AnthropicUsage(
+            input_tokens=response.usage.get("prompt_tokens", 0) if response.usage else 0,
+            output_tokens=response.usage.get("completion_tokens", 0) if response.usage else 0,
+        )
+
+        # Map finish reason
+        stop_reason = _map_finish_reason(response.finish_reason)
+
+        return AnthropicMessagesResponse(
+            id=f"msg_{uuid.uuid4().hex[:24]}",
+            type="message",
+            role="assistant",
+            content=content,
+            model=response.model,
+            stop_reason=stop_reason,
+            stop_sequence=None,
+            usage=usage,
+        )
+    except ProviderError as e:
+        logger.error("Anthropic messages request failed: %s", e)
+        raise HTTPException(status_code=e.status_code, detail=str(e))
+
+
+@router.post("/v1/messages/count_tokens")
+@router.post("/api/anthropic/v1/messages/count_tokens")
+async def count_tokens(request: AnthropicCountTokensRequest):
+    """Count tokens for a messages request.
+
+    This is a simplified implementation that estimates tokens.
+    Since we're proxying to various providers, we can't get exact counts
+    without making an actual request.
+    """
+    total_chars = 0
+
+    # Count system prompt
+    if request.system:
+        if isinstance(request.system, str):
+            total_chars += len(request.system)
+        else:
+            for block in request.system:
+                total_chars += len(block.text)
+
+    # Count messages
+    for msg in request.messages:
+        content = msg.content if hasattr(msg, "content") else msg.get("content", "")
+        if isinstance(content, str):
+            total_chars += len(content)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict):
+                    if block.get("type") == "text":
+                        total_chars += len(block.get("text", ""))
+                elif hasattr(block, "text"):
+                    total_chars += len(block.text)
+
+    return {"input_tokens": estimate_tokens_from_char_count(total_chars)}
+
+
+def _map_finish_reason(reason: str | None) -> str | None:
+    """Map OpenAI finish reason to Anthropic stop reason."""
+    return map_openai_stop_reason_to_anthropic(reason)
+
+
+def _estimate_input_tokens(request: AnthropicMessagesRequest) -> int:
+    """Estimate input tokens from request content.
+
+    Uses a rough approximation of ~4 characters per token for English text.
+    This provides an estimate for context display before actual usage is known.
+    """
+    total_chars = 0
+
+    # Count system prompt
+    if request.system:
+        if isinstance(request.system, str):
+            total_chars += len(request.system)
+        else:
+            for block in request.system:
+                if hasattr(block, "text"):
+                    total_chars += len(block.text)
+
+    # Count messages
+    for msg in request.messages:
+        content = msg.content if hasattr(msg, "content") else msg.get("content", "")
+        if isinstance(content, str):
+            total_chars += len(content)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict):
+                    if block.get("type") == "text":
+                        total_chars += len(block.get("text", ""))
+                    elif block.get("type") == "tool_result":
+                        tool_content = block.get("content", "")
+                        if isinstance(tool_content, str):
+                            total_chars += len(tool_content)
+                        elif isinstance(tool_content, list):
+                            for tc in tool_content:
+                                if isinstance(tc, dict) and tc.get("type") == "text":
+                                    total_chars += len(tc.get("text", ""))
+                elif hasattr(block, "text"):
+                    total_chars += len(block.text)
+
+    # Count tools definitions if present
+    if request.tools:
+        for tool in request.tools:
+            if hasattr(tool, "name"):
+                total_chars += len(tool.name)
+            if hasattr(tool, "description") and tool.description:
+                total_chars += len(tool.description)
+            if hasattr(tool, "input_schema"):
+                # Rough estimate for schema
+                import json
+
+                try:
+                    schema_str = json.dumps(tool.input_schema)
+                    total_chars += len(schema_str)
+                except Exception:
+                    pass
+
+    return estimate_tokens_from_char_count(total_chars)
+
+
+async def stream_response(
+    model_router: Router,
+    request: ChatRequest,
+    original_model: str,
+    estimated_input_tokens: int = 0,
+) -> AsyncGenerator[str, None]:
+    """Stream Anthropic Messages API response."""
+    try:
+        stream, provider_name = await model_router.chat_completion_stream(request)
+        response_id = f"msg_{uuid.uuid4().hex[:24]}"
+
+        state = AnthropicStreamState(estimated_input_tokens=estimated_input_tokens)
+
+        async for chunk in stream:
+            # Build OpenAI-style chunk for translation
+            openai_chunk = {
+                "id": response_id,
+                "choices": [
+                    {
+                        "delta": {
+                            "content": chunk.content if chunk.content else None,
+                            "tool_calls": chunk.tool_calls,
+                        },
+                        "finish_reason": chunk.finish_reason,
+                    }
+                ],
+                "usage": chunk.usage,  # Pass through usage info
+            }
+
+            events = translate_openai_chunk_to_anthropic_events(openai_chunk, state, original_model)
+
+            for event in events:
+                yield f"event: {event['type']}\ndata: {json.dumps(event)}\n\n"
+
+    except ProviderError as e:
+        error_event = {
+            "type": "error",
+            "error": {
+                "type": "api_error",
+                "message": str(e),
+            },
+        }
+        yield f"event: error\ndata: {json.dumps(error_event)}\n\n"

router_maestro/server/routes/chat.py

@@ -0,0 +1,142 @@
+"""Chat completions route."""
+
+import json
+import time
+import uuid
+from collections.abc import AsyncGenerator
+
+from fastapi import APIRouter, HTTPException
+from fastapi.responses import StreamingResponse
+
+from router_maestro.providers import ChatRequest, Message, ProviderError
+from router_maestro.routing import Router, get_router
+from router_maestro.server.schemas import (
+    ChatCompletionChoice,
+    ChatCompletionChunk,
+    ChatCompletionChunkChoice,
+    ChatCompletionChunkDelta,
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    ChatCompletionUsage,
+    ChatMessage,
+)
+from router_maestro.utils import get_logger
+
+logger = get_logger("server.routes.chat")
+
+router = APIRouter()
+
+
+@router.post("/chat/completions")
+@router.post("/v1/chat/completions")
+async def chat_completions(request: ChatCompletionRequest):
+    """Handle chat completion requests."""
+    logger.info(
+        "Received chat completion request: model=%s, stream=%s",
+        request.model,
+        request.stream,
+    )
+    model_router = get_router()
+
+    # Convert to internal format
+    chat_request = ChatRequest(
+        model=request.model,
+        messages=[Message(role=m.role, content=m.content) for m in request.messages],
+        temperature=request.temperature,
+        max_tokens=request.max_tokens,
+        stream=request.stream,
+    )
+
+    if request.stream:
+        return StreamingResponse(
+            stream_response(model_router, chat_request),
+            media_type="text/event-stream",
+        )
+
+    try:
+        response, provider_name = await model_router.chat_completion(chat_request)
+
+        usage = None
+        if response.usage:
+            usage = ChatCompletionUsage(
+                prompt_tokens=response.usage.get("prompt_tokens", 0),
+                completion_tokens=response.usage.get("completion_tokens", 0),
+                total_tokens=response.usage.get("total_tokens", 0),
+            )
+
+        return ChatCompletionResponse(
+            id=f"chatcmpl-{uuid.uuid4().hex[:8]}",
+            created=int(time.time()),
+            model=response.model,
+            choices=[
+                ChatCompletionChoice(
+                    index=0,
+                    message=ChatMessage(role="assistant", content=response.content),
+                    finish_reason=response.finish_reason,
+                )
+            ],
+            usage=usage,
+        )
+    except ProviderError as e:
+        logger.error("Chat completion request failed: %s", e)
+        raise HTTPException(status_code=e.status_code, detail=str(e))
+
+
+async def stream_response(model_router: Router, request: ChatRequest) -> AsyncGenerator[str, None]:
+    """Stream chat completion response."""
+    try:
+        stream, provider_name = await model_router.chat_completion_stream(request)
+        response_id = f"chatcmpl-{uuid.uuid4().hex[:8]}"
+        created = int(time.time())
+
+        # Send initial chunk with role
+        initial_chunk = ChatCompletionChunk(
+            id=response_id,
+            created=created,
+            model=request.model,
+            choices=[
+                ChatCompletionChunkChoice(
+                    index=0,
+                    delta=ChatCompletionChunkDelta(role="assistant"),
+                    finish_reason=None,
+                )
+            ],
+        )
+        yield f"data: {initial_chunk.model_dump_json()}\n\n"
+
+        async for chunk in stream:
+            if chunk.content:
+                chunk_response = ChatCompletionChunk(
+                    id=response_id,
+                    created=created,
+                    model=request.model,
+                    choices=[
+                        ChatCompletionChunkChoice(
+                            index=0,
+                            delta=ChatCompletionChunkDelta(content=chunk.content),
+                            finish_reason=None,
+                        )
+                    ],
+                )
+                yield f"data: {chunk_response.model_dump_json()}\n\n"
+
+            if chunk.finish_reason:
+                final_chunk = ChatCompletionChunk(
+                    id=response_id,
+                    created=created,
+                    model=request.model,
+                    choices=[
+                        ChatCompletionChunkChoice(
+                            index=0,
+                            delta=ChatCompletionChunkDelta(),
+                            finish_reason=chunk.finish_reason,
+                        )
+                    ],
+                )
+                yield f"data: {final_chunk.model_dump_json()}\n\n"
+
+        yield "data: [DONE]\n\n"
+
+    except ProviderError as e:
+        error_data = {"error": {"message": str(e), "type": "provider_error"}}
+        yield f"data: {json.dumps(error_data)}\n\n"

router_maestro/server/routes/models.py

@@ -0,0 +1,34 @@
+"""Models route."""
+
+import time
+
+from fastapi import APIRouter
+
+from router_maestro.routing import Router
+from router_maestro.server.schemas import ModelList, ModelObject
+
+router = APIRouter()
+
+
+def get_router() -> Router:
+    """Get the router instance."""
+    return Router()
+
+
+@router.get("/models")
+@router.get("/v1/models")
+async def list_models() -> ModelList:
+    """List available models."""
+    model_router = get_router()
+    models = await model_router.list_models()
+
+    return ModelList(
+        data=[
+            ModelObject(
+                id=model.id,
+                created=int(time.time()),
+                owned_by=model.provider,
+            )
+            for model in models
+        ]
+    )

router_maestro/server/schemas/__init__.py

@@ -0,0 +1,57 @@
+"""Server schemas."""
+
+from router_maestro.server.schemas.admin import (
+    AuthListResponse,
+    AuthProviderInfo,
+    LoginRequest,
+    ModelInfo,
+    ModelsResponse,
+    OAuthInitResponse,
+    OAuthStatusResponse,
+    PrioritiesResponse,
+    PrioritiesUpdateRequest,
+    StatsQuery,
+    StatsResponse,
+)
+from router_maestro.server.schemas.openai import (
+    ChatCompletionChoice,
+    ChatCompletionChunk,
+    ChatCompletionChunkChoice,
+    ChatCompletionChunkDelta,
+    ChatCompletionRequest,
+    ChatCompletionResponse,
+    ChatCompletionUsage,
+    ChatMessage,
+    ErrorDetail,
+    ErrorResponse,
+    ModelList,
+    ModelObject,
+)
+
+__all__ = [
+    # Admin schemas
+    "AuthListResponse",
+    "AuthProviderInfo",
+    "LoginRequest",
+    "ModelInfo",
+    "ModelsResponse",
+    "OAuthInitResponse",
+    "OAuthStatusResponse",
+    "PrioritiesResponse",
+    "PrioritiesUpdateRequest",
+    "StatsQuery",
+    "StatsResponse",
+    # OpenAI schemas
+    "ChatCompletionChoice",
+    "ChatCompletionChunk",
+    "ChatCompletionChunkChoice",
+    "ChatCompletionChunkDelta",
+    "ChatCompletionRequest",
+    "ChatCompletionResponse",
+    "ChatCompletionUsage",
+    "ChatMessage",
+    "ErrorDetail",
+    "ErrorResponse",
+    "ModelList",
+    "ModelObject",
+]

router_maestro/server/schemas/admin.py

@@ -0,0 +1,87 @@
+"""Admin API schemas for remote management."""
+
+from pydantic import BaseModel, Field
+
+
+class AuthProviderInfo(BaseModel):
+    """Information about an authenticated provider."""
+
+    provider: str = Field(..., description="Provider name")
+    auth_type: str = Field(..., description="Authentication type: 'oauth' or 'api'")
+    status: str = Field(..., description="Status: 'active' or 'expired'")
+
+
+class AuthListResponse(BaseModel):
+    """Response for listing authenticated providers."""
+
+    providers: list[AuthProviderInfo] = Field(default_factory=list)
+
+
+class LoginRequest(BaseModel):
+    """Request to initiate login."""
+
+    provider: str = Field(..., description="Provider to authenticate with")
+    api_key: str | None = Field(default=None, description="API key for API key auth")
+
+
+class OAuthInitResponse(BaseModel):
+    """Response for OAuth initialization (device flow)."""
+
+    session_id: str = Field(..., description="Session ID for polling status")
+    user_code: str = Field(..., description="Code to enter at verification URL")
+    verification_uri: str = Field(..., description="URL to visit for authorization")
+    expires_in: int = Field(..., description="Seconds until expiration")
+
+
+class OAuthStatusResponse(BaseModel):
+    """Response for OAuth status polling."""
+
+    status: str = Field(..., description="Status: 'pending', 'complete', 'expired', or 'error'")
+    error: str | None = Field(default=None, description="Error message if status is 'error'")
+
+
+class ModelInfo(BaseModel):
+    """Information about a model."""
+
+    provider: str = Field(..., description="Provider name")
+    id: str = Field(..., description="Model ID")
+    name: str = Field(..., description="Display name")
+
+
+class ModelsResponse(BaseModel):
+    """Response for listing models."""
+
+    models: list[ModelInfo] = Field(default_factory=list)
+
+
+class PrioritiesResponse(BaseModel):
+    """Response for getting priorities."""
+
+    priorities: list[str] = Field(default_factory=list, description="Model priorities in order")
+    fallback: dict = Field(default_factory=dict, description="Fallback configuration")
+
+
+class PrioritiesUpdateRequest(BaseModel):
+    """Request to update priorities."""
+
+    priorities: list[str] = Field(..., description="New priority list")
+    fallback: dict | None = Field(default=None, description="Optional fallback config update")
+
+
+class StatsQuery(BaseModel):
+    """Query parameters for stats."""
+
+    days: int = Field(default=7, ge=1, le=365, description="Number of days to query")
+    provider: str | None = Field(default=None, description="Filter by provider")
+    model: str | None = Field(default=None, description="Filter by model")
+
+
+class StatsResponse(BaseModel):
+    """Response for usage statistics."""
+
+    total_requests: int = Field(default=0)
+    total_tokens: int = Field(default=0)
+    prompt_tokens: int = Field(default=0)
+    completion_tokens: int = Field(default=0)
+    by_provider: dict[str, dict] = Field(default_factory=dict)
+    by_model: dict[str, dict] = Field(default_factory=dict)