router-maestro 0.1.2__py3-none-any.whl

router_maestro/config/priorities.py

@@ -0,0 +1,93 @@
+"""Model priority configuration."""
+
+from enum import Enum
+
+from pydantic import BaseModel, Field
+
+
+class FallbackStrategy(str, Enum):
+    """Fallback strategy options."""
+
+    PRIORITY = "priority"  # Fallback to next model in priorities list
+    SAME_MODEL = "same-model"  # Only fallback to providers with the same model
+    NONE = "none"  # Disable fallback, fail immediately
+
+
+class FallbackConfig(BaseModel):
+    """Fallback configuration."""
+
+    strategy: FallbackStrategy = Field(
+        default=FallbackStrategy.PRIORITY,
+        description="Fallback strategy",
+    )
+    maxRetries: int = Field(  # noqa: N815
+        default=2,
+        ge=0,
+        le=10,
+        description="Maximum number of fallback retries",
+    )
+
+
+class PrioritiesConfig(BaseModel):
+    """Configuration for model priorities and fallback."""
+
+    priorities: list[str] = Field(
+        default_factory=list,
+        description="Model priorities in format 'provider/model', highest to lowest",
+    )
+    fallback: FallbackConfig = Field(default_factory=FallbackConfig)
+
+    @classmethod
+    def get_default(cls) -> "PrioritiesConfig":
+        """Get default empty priorities configuration."""
+        return cls(priorities=[])
+
+    def get_priority(self, provider: str, model: str) -> int:
+        """Get priority for a model.
+
+        Args:
+            provider: Provider name
+            model: Model ID
+
+        Returns:
+            Priority index (lower = higher priority), or 999999 if not in list
+        """
+        key = f"{provider}/{model}"
+        try:
+            return self.priorities.index(key)
+        except ValueError:
+            return 999999
+
+    def add_priority(self, provider: str, model: str, position: int | None = None) -> None:
+        """Add a model to priorities.
+
+        Args:
+            provider: Provider name
+            model: Model ID
+            position: Position to insert (None = append to end)
+        """
+        key = f"{provider}/{model}"
+        # Remove if already exists
+        if key in self.priorities:
+            self.priorities.remove(key)
+        # Insert at position
+        if position is None:
+            self.priorities.append(key)
+        else:
+            self.priorities.insert(position, key)
+
+    def remove_priority(self, provider: str, model: str) -> bool:
+        """Remove a model from priorities.
+
+        Args:
+            provider: Provider name
+            model: Model ID
+
+        Returns:
+            True if removed, False if not found
+        """
+        key = f"{provider}/{model}"
+        if key in self.priorities:
+            self.priorities.remove(key)
+            return True
+        return False

router_maestro/config/providers.py

@@ -0,0 +1,34 @@
+"""Provider and model configuration models."""
+
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+class ModelConfig(BaseModel):
+    """Configuration for a single model."""
+
+    name: str = Field(default="", description="Display name for the model")
+
+
+class CustomProviderConfig(BaseModel):
+    """Configuration for a custom (OpenAI-compatible) provider."""
+
+    type: str = Field(default="openai-compatible", description="Provider type")
+    baseURL: str = Field(..., description="Base URL for API requests")  # noqa: N815
+    models: dict[str, ModelConfig] = Field(default_factory=dict, description="Model configurations")
+    options: dict[str, Any] = Field(default_factory=dict, description="Additional provider options")
+
+
+class ProvidersConfig(BaseModel):
+    """Root configuration for custom providers only."""
+
+    providers: dict[str, CustomProviderConfig] = Field(
+        default_factory=dict,
+        description="Custom provider configurations (not including built-in providers)",
+    )
+
+    @classmethod
+    def get_default(cls) -> "ProvidersConfig":
+        """Get default empty configuration."""
+        return cls(providers={})

router_maestro/config/server.py

@@ -0,0 +1,115 @@
+"""Server configuration management.
+
+API keys are stored in contexts.json under context.
+This module provides utilities to manage API keys.
+"""
+
+import secrets
+
+from router_maestro.config.contexts import ContextConfig
+from router_maestro.config.settings import load_contexts_config, save_contexts_config
+
+
+def generate_api_key() -> str:
+    """Generate a random API key."""
+    return f"sk-rm-{secrets.token_urlsafe(32)}"
+
+
+def get_local_api_key() -> str | None:
+    """Get API key for local context.
+
+    Returns:
+        The API key if configured, None otherwise.
+    """
+    config = load_contexts_config()
+    local_ctx = config.contexts.get("local")
+    if local_ctx:
+        return local_ctx.api_key
+    return None
+
+
+def get_current_context_api_key() -> str | None:
+    """Get API key for current context.
+
+    Returns:
+        The API key if configured, None otherwise.
+    """
+    config = load_contexts_config()
+    ctx_name = config.current
+    ctx = config.contexts.get(ctx_name)
+    if ctx:
+        return ctx.api_key
+    return None
+
+
+def set_local_api_key(api_key: str) -> None:
+    """Set API key for local context.
+
+    Args:
+        api_key: The API key to set.
+    """
+    config = load_contexts_config()
+
+    # Ensure local context exists
+    if "local" not in config.contexts:
+        config.contexts["local"] = ContextConfig(endpoint="http://localhost:8080")
+
+    config.contexts["local"].api_key = api_key
+    save_contexts_config(config)
+
+
+def get_or_create_api_key(api_key: str | None = None) -> tuple[str, bool]:
+    """Get or create an API key for local server.
+
+    Priority order:
+    1. Provided api_key argument (from CLI --api-key)
+    2. ROUTER_MAESTRO_API_KEY environment variable
+    3. Existing key in contexts.json
+    4. Generate new key
+
+    Args:
+        api_key: Optional API key to use.
+
+    Returns:
+        Tuple of (api_key, was_generated)
+    """
+    import os
+
+    if api_key:
+        # User provided API key via CLI, save it to local context
+        set_local_api_key(api_key)
+        return api_key, False
+
+    # Check environment variable
+    env_key = os.environ.get("ROUTER_MAESTRO_API_KEY")
+    if env_key:
+        # Save to local context for persistence
+        set_local_api_key(env_key)
+        return env_key, False
+
+    # Try to load from local context
+    existing_key = get_local_api_key()
+    if existing_key:
+        return existing_key, False
+
+    # Generate new key and save to local context
+    new_key = generate_api_key()
+    set_local_api_key(new_key)
+    return new_key, True
+
+
+# Legacy compatibility - ServerConfig is no longer used but kept for reference
+class ServerConfig:
+    """Deprecated: Server configuration is now stored in contexts.json."""
+
+    def __init__(self, api_key: str = "") -> None:
+        self.api_key = api_key
+
+
+def load_server_config() -> ServerConfig:
+    """Load server configuration (for backward compatibility).
+
+    Now reads from contexts.json local context.
+    """
+    api_key = get_local_api_key() or ""
+    return ServerConfig(api_key=api_key)

router_maestro/config/settings.py

@@ -0,0 +1,76 @@
+"""Global settings and configuration management."""
+
+import json
+from pathlib import Path
+from typing import TypeVar
+
+from pydantic import BaseModel
+
+from router_maestro.config.contexts import ContextsConfig
+from router_maestro.config.paths import CONTEXTS_FILE, PRIORITIES_FILE, PROVIDERS_FILE
+from router_maestro.config.priorities import PrioritiesConfig
+from router_maestro.config.providers import ProvidersConfig
+
+T = TypeVar("T", bound=BaseModel)
+
+
+def load_config(path: Path, model: type[T], default_factory: callable) -> T:
+    """Load configuration from JSON file.
+
+    Args:
+        path: Path to configuration file
+        model: Pydantic model class to parse into
+        default_factory: Function to create default configuration
+
+    Returns:
+        Parsed configuration object
+    """
+    if not path.exists():
+        config = default_factory()
+        save_config(path, config)
+        return config
+    with open(path, encoding="utf-8") as f:
+        data = json.load(f)
+    return model.model_validate(data)
+
+
+def save_config(path: Path, config: BaseModel) -> None:
+    """Save configuration to JSON file.
+
+    Args:
+        path: Path to configuration file
+        config: Configuration object to save
+    """
+    path.parent.mkdir(parents=True, exist_ok=True)
+    with open(path, "w", encoding="utf-8") as f:
+        json.dump(config.model_dump(mode="json"), f, indent=2, ensure_ascii=False)
+
+
+def load_providers_config() -> ProvidersConfig:
+    """Load providers configuration."""
+    return load_config(PROVIDERS_FILE, ProvidersConfig, ProvidersConfig.get_default)
+
+
+def save_providers_config(config: ProvidersConfig) -> None:
+    """Save providers configuration."""
+    save_config(PROVIDERS_FILE, config)
+
+
+def load_priorities_config() -> PrioritiesConfig:
+    """Load priorities configuration."""
+    return load_config(PRIORITIES_FILE, PrioritiesConfig, PrioritiesConfig.get_default)
+
+
+def save_priorities_config(config: PrioritiesConfig) -> None:
+    """Save priorities configuration."""
+    save_config(PRIORITIES_FILE, config)
+
+
+def load_contexts_config() -> ContextsConfig:
+    """Load contexts configuration."""
+    return load_config(CONTEXTS_FILE, ContextsConfig, ContextsConfig.get_default)
+
+
+def save_contexts_config(config: ContextsConfig) -> None:
+    """Save contexts configuration."""
+    save_config(CONTEXTS_FILE, config)

router_maestro/providers/__init__.py

@@ -0,0 +1,31 @@
+"""Providers module for router-maestro."""
+
+from router_maestro.providers.anthropic import AnthropicProvider
+from router_maestro.providers.base import (
+    BaseProvider,
+    ChatRequest,
+    ChatResponse,
+    ChatStreamChunk,
+    Message,
+    ModelInfo,
+    ProviderError,
+)
+from router_maestro.providers.copilot import CopilotProvider
+from router_maestro.providers.openai import OpenAIProvider
+from router_maestro.providers.openai_compat import OpenAICompatibleProvider
+
+__all__ = [
+    # Base classes
+    "BaseProvider",
+    "ProviderError",
+    "Message",
+    "ChatRequest",
+    "ChatResponse",
+    "ChatStreamChunk",
+    "ModelInfo",
+    # Providers
+    "CopilotProvider",
+    "OpenAIProvider",
+    "AnthropicProvider",
+    "OpenAICompatibleProvider",
+]

router_maestro/providers/anthropic.py

@@ -0,0 +1,203 @@
+"""Anthropic provider implementation."""
+
+from collections.abc import AsyncIterator
+
+import httpx
+
+from router_maestro.auth import AuthManager, AuthType
+from router_maestro.providers.base import (
+    BaseProvider,
+    ChatRequest,
+    ChatResponse,
+    ChatStreamChunk,
+    ModelInfo,
+    ProviderError,
+)
+from router_maestro.utils import get_logger
+
+logger = get_logger("providers.anthropic")
+
+ANTHROPIC_API_URL = "https://api.anthropic.com/v1"
+
+
+class AnthropicProvider(BaseProvider):
+    """Anthropic Claude provider."""
+
+    name = "anthropic"
+
+    def __init__(self, base_url: str = ANTHROPIC_API_URL) -> None:
+        self.base_url = base_url.rstrip("/")
+        self.auth_manager = AuthManager()
+
+    def is_authenticated(self) -> bool:
+        """Check if authenticated with Anthropic."""
+        cred = self.auth_manager.get_credential("anthropic")
+        return cred is not None and cred.type == AuthType.API_KEY
+
+    def _get_api_key(self) -> str:
+        """Get the API key."""
+        cred = self.auth_manager.get_credential("anthropic")
+        if not cred or cred.type != AuthType.API_KEY:
+            logger.error("Not authenticated with Anthropic")
+            raise ProviderError("Not authenticated with Anthropic", status_code=401)
+        return cred.key
+
+    def _get_headers(self) -> dict[str, str]:
+        """Get headers for Anthropic API requests."""
+        return {
+            "x-api-key": self._get_api_key(),
+            "Content-Type": "application/json",
+            "anthropic-version": "2023-06-01",
+        }
+
+    def _convert_messages(self, messages: list) -> tuple[str | None, list[dict]]:
+        """Convert OpenAI-style messages to Anthropic format.
+
+        Returns:
+            Tuple of (system_prompt, messages)
+        """
+        system_prompt = None
+        converted = []
+
+        for msg in messages:
+            if msg.role == "system":
+                system_prompt = msg.content
+            else:
+                converted.append({"role": msg.role, "content": msg.content})
+
+        return system_prompt, converted
+
+    async def chat_completion(self, request: ChatRequest) -> ChatResponse:
+        """Generate a chat completion via Anthropic."""
+        system_prompt, messages = self._convert_messages(request.messages)
+
+        payload = {
+            "model": request.model,
+            "messages": messages,
+            "max_tokens": request.max_tokens or 4096,
+        }
+        if system_prompt:
+            payload["system"] = system_prompt
+        if request.temperature != 1.0:
+            payload["temperature"] = request.temperature
+
+        logger.debug("Anthropic chat completion: model=%s", request.model)
+        async with httpx.AsyncClient() as client:
+            try:
+                response = await client.post(
+                    f"{self.base_url}/messages",
+                    json=payload,
+                    headers=self._get_headers(),
+                    timeout=120.0,
+                )
+                response.raise_for_status()
+                data = response.json()
+
+                # Extract content from Anthropic response
+                content = ""
+                for block in data.get("content", []):
+                    if block.get("type") == "text":
+                        content += block.get("text", "")
+
+                logger.debug("Anthropic chat completion successful")
+                return ChatResponse(
+                    content=content,
+                    model=data.get("model", request.model),
+                    finish_reason=data.get("stop_reason", "stop"),
+                    usage={
+                        "prompt_tokens": data.get("usage", {}).get("input_tokens", 0),
+                        "completion_tokens": data.get("usage", {}).get("output_tokens", 0),
+                        "total_tokens": (
+                            data.get("usage", {}).get("input_tokens", 0)
+                            + data.get("usage", {}).get("output_tokens", 0)
+                        ),
+                    },
+                )
+            except httpx.HTTPStatusError as e:
+                retryable = e.response.status_code in (429, 500, 502, 503, 504, 529)
+                logger.error("Anthropic API error: %d", e.response.status_code)
+                raise ProviderError(
+                    f"Anthropic API error: {e.response.status_code}",
+                    status_code=e.response.status_code,
+                    retryable=retryable,
+                )
+            except httpx.HTTPError as e:
+                logger.error("Anthropic HTTP error: %s", e)
+                raise ProviderError(f"HTTP error: {e}", retryable=True)
+
+    async def chat_completion_stream(self, request: ChatRequest) -> AsyncIterator[ChatStreamChunk]:
+        """Generate a streaming chat completion via Anthropic."""
+        system_prompt, messages = self._convert_messages(request.messages)
+
+        payload = {
+            "model": request.model,
+            "messages": messages,
+            "max_tokens": request.max_tokens or 4096,
+            "stream": True,
+        }
+        if system_prompt:
+            payload["system"] = system_prompt
+        if request.temperature != 1.0:
+            payload["temperature"] = request.temperature
+
+        logger.debug("Anthropic streaming chat: model=%s", request.model)
+        async with httpx.AsyncClient() as client:
+            try:
+                async with client.stream(
+                    "POST",
+                    f"{self.base_url}/messages",
+                    json=payload,
+                    headers=self._get_headers(),
+                    timeout=120.0,
+                ) as response:
+                    response.raise_for_status()
+
+                    async for line in response.aiter_lines():
+                        if not line or not line.startswith("data: "):
+                            continue
+
+                        data_str = line[6:]
+                        if not data_str:
+                            continue
+
+                        import json
+
+                        data = json.loads(data_str)
+                        event_type = data.get("type")
+
+                        if event_type == "content_block_delta":
+                            delta = data.get("delta", {})
+                            if delta.get("type") == "text_delta":
+                                yield ChatStreamChunk(
+                                    content=delta.get("text", ""),
+                                    finish_reason=None,
+                                )
+                        elif event_type == "message_stop":
+                            yield ChatStreamChunk(
+                                content="",
+                                finish_reason="stop",
+                            )
+            except httpx.HTTPStatusError as e:
+                retryable = e.response.status_code in (429, 500, 502, 503, 504, 529)
+                logger.error("Anthropic stream API error: %d", e.response.status_code)
+                raise ProviderError(
+                    f"Anthropic API error: {e.response.status_code}",
+                    status_code=e.response.status_code,
+                    retryable=retryable,
+                )
+            except httpx.HTTPError as e:
+                logger.error("Anthropic stream HTTP error: %s", e)
+                raise ProviderError(f"HTTP error: {e}", retryable=True)
+
+    async def list_models(self) -> list[ModelInfo]:
+        """List available Anthropic models."""
+        # Anthropic doesn't have a models endpoint, return known models
+        logger.debug("Returning known Anthropic models")
+        return [
+            ModelInfo(id="claude-sonnet-4-20250514", name="Claude Sonnet 4", provider=self.name),
+            ModelInfo(
+                id="claude-3-5-sonnet-20241022", name="Claude 3.5 Sonnet", provider=self.name
+            ),
+            ModelInfo(id="claude-3-5-haiku-20241022", name="Claude 3.5 Haiku", provider=self.name),
+            ModelInfo(id="claude-3-opus-20240229", name="Claude 3 Opus", provider=self.name),
+        ]

router_maestro/providers/base.py

@@ -0,0 +1,123 @@
+"""Base provider interface."""
+
+from abc import ABC, abstractmethod
+from collections.abc import AsyncIterator
+from dataclasses import dataclass, field
+
+
+@dataclass
+class Message:
+    """A message in the conversation."""
+
+    role: str  # "system", "user", "assistant", "tool"
+    content: str | list  # Can be str or list for multimodal content (images)
+    tool_call_id: str | None = None  # Required for tool role messages
+    tool_calls: list[dict] | None = None  # For assistant messages with tool calls
+
+
+@dataclass
+class ChatRequest:
+    """Request for chat completion."""
+
+    model: str
+    messages: list[Message]
+    temperature: float = 1.0
+    max_tokens: int | None = None
+    stream: bool = False
+    tools: list[dict] | None = None  # OpenAI format tool definitions
+    # "auto", "none", "required", or {"type": "function", "function": {"name": "..."}}
+    tool_choice: str | dict | None = None
+    extra: dict = field(default_factory=dict)
+
+
+@dataclass
+class ChatResponse:
+    """Response from chat completion."""
+
+    content: str
+    model: str
+    finish_reason: str = "stop"
+    usage: dict | None = None  # {"prompt_tokens": X, "completion_tokens": Y, "total_tokens": Z}
+
+
+@dataclass
+class ChatStreamChunk:
+    """A chunk from streaming chat completion."""
+
+    content: str
+    finish_reason: str | None = None
+    usage: dict | None = None  # Token usage info (typically in final chunk)
+    tool_calls: list[dict] | None = None  # Tool call deltas for streaming
+
+
+@dataclass
+class ModelInfo:
+    """Information about an available model."""
+
+    id: str
+    name: str
+    provider: str
+
+
+class ProviderError(Exception):
+    """Error from a provider."""
+
+    def __init__(self, message: str, status_code: int = 500, retryable: bool = False):
+        super().__init__(message)
+        self.status_code = status_code
+        self.retryable = retryable
+
+
+class BaseProvider(ABC):
+    """Abstract base class for model providers."""
+
+    name: str = "base"
+
+    @abstractmethod
+    async def chat_completion(self, request: ChatRequest) -> ChatResponse:
+        """Generate a chat completion.
+
+        Args:
+            request: Chat completion request
+
+        Returns:
+            Chat completion response
+        """
+        pass
+
+    @abstractmethod
+    async def chat_completion_stream(self, request: ChatRequest) -> AsyncIterator[ChatStreamChunk]:
+        """Generate a streaming chat completion.
+
+        Args:
+            request: Chat completion request
+
+        Yields:
+            Chat completion chunks
+        """
+        pass
+
+    @abstractmethod
+    async def list_models(self) -> list[ModelInfo]:
+        """List available models.
+
+        Returns:
+            List of available models
+        """
+        pass
+
+    @abstractmethod
+    def is_authenticated(self) -> bool:
+        """Check if the provider is authenticated.
+
+        Returns:
+            True if authenticated
+        """
+        pass
+
+    async def ensure_token(self) -> None:
+        """Ensure the provider has a valid token.
+
+        Override this for providers that need token refresh.
+        """
+        pass