router-maestro 0.1.4__tar.gz → 0.1.6__tar.gz

router_maestro-0.1.6/.github/workflows/ci.yml

@@ -0,0 +1,55 @@
+name: CI
+
+on:
+  push:
+    branches: [master, main]
+  pull_request:
+    branches: [master, main]
+
+concurrency:
+  group: ${{ github.workflow }}-${{ github.ref }}
+  cancel-in-progress: true
+
+jobs:
+  lint:
+    name: Lint
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Install dependencies
+        run: uv sync --extra dev
+
+      - name: Run ruff check
+        run: uv run ruff check src/ tests/
+
+      - name: Run ruff format check
+        run: uv run ruff format --check src/ tests/
+
+  test:
+    name: Test (Python ${{ matrix.python-version }})
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ["3.11", "3.12"]
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python ${{ matrix.python-version }}
+        run: uv python install ${{ matrix.python-version }}
+
+      - name: Install dependencies
+        run: uv sync --extra dev
+
+      - name: Run tests
+        run: uv run pytest tests/ -v

router_maestro-0.1.6/.github/workflows/release.yml

@@ -0,0 +1,167 @@
+name: Release
+
+on:
+  push:
+    tags:
+      - "v*.*.*"
+  workflow_dispatch:
+    inputs:
+      version:
+        description: "Version to release (e.g., 0.1.6). Leave empty to use pyproject.toml version."
+        required: false
+        type: string
+      skip_pypi:
+        description: "Skip PyPI publishing"
+        required: false
+        type: boolean
+        default: false
+      skip_docker:
+        description: "Skip Docker publishing"
+        required: false
+        type: boolean
+        default: false
+
+concurrency:
+  group: release
+  cancel-in-progress: false
+
+jobs:
+  test:
+    name: Test
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Install dependencies
+        run: uv sync --extra dev
+
+      - name: Run ruff check
+        run: uv run ruff check src/ tests/
+
+      - name: Run tests
+        run: uv run pytest tests/ -v
+
+  prepare:
+    name: Prepare Release
+    runs-on: ubuntu-latest
+    needs: test
+    outputs:
+      version: ${{ steps.version.outputs.version }}
+      docker_tags: ${{ steps.docker.outputs.tags }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Determine version
+        id: version
+        run: |
+          if [[ "${{ github.event_name }}" == "push" && "${{ github.ref_type }}" == "tag" ]]; then
+            # Extract version from tag (v1.2.3 -> 1.2.3)
+            VERSION="${GITHUB_REF_NAME#v}"
+          elif [[ -n "${{ inputs.version }}" ]]; then
+            # Use workflow_dispatch input
+            VERSION="${{ inputs.version }}"
+          else
+            # Read from pyproject.toml
+            VERSION=$(grep -Po '(?<=^version = ")[^"]*' pyproject.toml)
+          fi
+          echo "version=$VERSION" >> $GITHUB_OUTPUT
+          echo "Determined version: $VERSION"
+
+      - name: Prepare Docker tags
+        id: docker
+        run: |
+          VERSION="${{ steps.version.outputs.version }}"
+          TAGS="likanwen/router-maestro:${VERSION},likanwen/router-maestro:latest"
+          echo "tags=$TAGS" >> $GITHUB_OUTPUT
+          echo "Docker tags: $TAGS"
+
+  publish-pypi:
+    name: Publish to PyPI
+    runs-on: ubuntu-latest
+    needs: prepare
+    if: ${{ !inputs.skip_pypi }}
+    environment:
+      name: pypi
+      url: https://pypi.org/project/router-maestro/
+    permissions:
+      id-token: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v5
+
+      - name: Set up Python
+        run: uv python install 3.12
+
+      - name: Build package
+        run: uv build
+
+      - name: Verify build version
+        run: |
+          EXPECTED_VERSION="${{ needs.prepare.outputs.version }}"
+          BUILT_VERSION=$(ls dist/*.tar.gz | grep -Po 'router_maestro-\K[0-9]+\.[0-9]+\.[0-9]+')
+          if [[ "$BUILT_VERSION" != "$EXPECTED_VERSION" ]]; then
+            echo "Version mismatch! Expected: $EXPECTED_VERSION, Built: $BUILT_VERSION"
+            exit 1
+          fi
+          echo "Version verified: $BUILT_VERSION"
+
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@release/v1
+        with:
+          verbose: true
+
+  publish-docker:
+    name: Publish Docker Image
+    runs-on: ubuntu-latest
+    needs: prepare
+    if: ${{ !inputs.skip_docker }}
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Set up QEMU
+        uses: docker/setup-qemu-action@v3
+
+      - name: Set up Docker Buildx
+        uses: docker/setup-buildx-action@v3
+
+      - name: Login to Docker Hub
+        uses: docker/login-action@v3
+        with:
+          username: ${{ secrets.DOCKER_USERNAME }}
+          password: ${{ secrets.DOCKER_TOKEN }}
+
+      - name: Build and push
+        uses: docker/build-push-action@v6
+        with:
+          context: .
+          platforms: linux/amd64,linux/arm64
+          push: true
+          tags: ${{ needs.prepare.outputs.docker_tags }}
+          cache-from: type=gha
+          cache-to: type=gha,mode=max
+
+  create-release:
+    name: Create GitHub Release
+    runs-on: ubuntu-latest
+    needs: [prepare, publish-pypi, publish-docker]
+    if: ${{ github.event_name == 'push' && github.ref_type == 'tag' }}
+    permissions:
+      contents: write
+    steps:
+      - uses: actions/checkout@v4
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          name: v${{ needs.prepare.outputs.version }}
+          generate_release_notes: true
+          draft: false
+          prerelease: false

{router_maestro-0.1.4 → router_maestro-0.1.6}/.gitignore

@@ -101,3 +101,14 @@ dmypy.json
 *.tmp
 *.bak
 *~
+
+# Auto Claude data directory
+.auto-claude/
+
+# Auto Claude generated files
+.auto-claude-security.json
+.auto-claude-status
+.claude_settings.json
+.worktrees/
+.security-key
+logs/security/

{router_maestro-0.1.4 → router_maestro-0.1.6}/CLAUDE.md

@@ -57,7 +57,7 @@ Router-Maestro is a multi-model routing system that exposes both OpenAI-compatib
 - `schemas/` - Pydantic models for both API formats
 
 **CLI (`src/router_maestro/cli/`)**
-- Typer-based CLI with subcommands: `server`, `auth`, `model`, `context`, `config`, `stats`
+- Typer-based CLI with subcommands: `server`, `auth`, `model`, `context`, `config`
 - Each subcommand in its own module registered in `main.py`
 
 ### Data Flow
@@ -72,7 +72,7 @@ Router-Maestro is a multi-model routing system that exposes both OpenAI-compatib
 
 Configuration and data files follow XDG conventions:
 - **Config** (`~/.config/router-maestro/`): `providers.json`, `priorities.json`, `contexts.json`
-- **Data** (`~/.local/share/router-maestro/`): `auth.json`, `server.json`, `stats.db`
+- **Data** (`~/.local/share/router-maestro/`): `auth.json`, `server.json`
 
 ### Model Identification
 

{router_maestro-0.1.4 → router_maestro-0.1.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: router-maestro
-Version: 0.1.4
+Version: 0.1.6
 Summary: Multi-model routing and load balancing system with OpenAI-compatible API
 Author-email: Kanwen Li <likanwen@icloud.com>
 License-Expression: MIT
@@ -37,6 +37,9 @@ Description-Content-Type: text/markdown
 
 # Router-Maestro
 
+[![CI](https://github.com/MadSkittles/Router-Maestro/actions/workflows/ci.yml/badge.svg)](https://github.com/MadSkittles/Router-Maestro/actions/workflows/ci.yml)
+[![Release](https://github.com/MadSkittles/Router-Maestro/actions/workflows/release.yml/badge.svg)](https://github.com/MadSkittles/Router-Maestro/actions/workflows/release.yml)
+
 Multi-model routing router with OpenAI-compatible and Anthropic-compatible APIs. Route LLM requests across GitHub Copilot, OpenAI, Anthropic, and custom providers with intelligent fallback and priority-based selection.
 
 ## TL;DR

{router_maestro-0.1.4 → router_maestro-0.1.6}/README.md

@@ -1,5 +1,8 @@
 # Router-Maestro
 
+[![CI](https://github.com/MadSkittles/Router-Maestro/actions/workflows/ci.yml/badge.svg)](https://github.com/MadSkittles/Router-Maestro/actions/workflows/ci.yml)
+[![Release](https://github.com/MadSkittles/Router-Maestro/actions/workflows/release.yml/badge.svg)](https://github.com/MadSkittles/Router-Maestro/actions/workflows/release.yml)
+
 Multi-model routing router with OpenAI-compatible and Anthropic-compatible APIs. Route LLM requests across GitHub Copilot, OpenAI, Anthropic, and custom providers with intelligent fallback and priority-based selection.
 
 ## TL;DR

{router_maestro-0.1.4 → router_maestro-0.1.6}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "router-maestro"
-version = "0.1.4"
+version = "0.1.6"
 description = "Multi-model routing and load balancing system with OpenAI-compatible API"
 readme = "README.md"
 license = "MIT"

{router_maestro-0.1.4 → router_maestro-0.1.6}/src/router_maestro/__init__.py

@@ -1,3 +1,3 @@
 """Router-Maestro: Multi-model routing and load balancing system."""
 
-__version__ = "0.1.4"
+__version__ = "0.1.6"

{router_maestro-0.1.4 → router_maestro-0.1.6}/src/router_maestro/cli/config.py

@@ -139,19 +139,29 @@ def claude_code_config() -> None:
     )
     anthropic_url = f"{base_url}/api/anthropic"
 
-    config = {
-        "env": {
-            "ANTHROPIC_BASE_URL": anthropic_url,
-            "ANTHROPIC_AUTH_TOKEN": auth_token,
-            "ANTHROPIC_MODEL": main_model,
-            "ANTHROPIC_SMALL_FAST_MODEL": fast_model,
-            "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
-        }
+    env_config = {
+        "ANTHROPIC_BASE_URL": anthropic_url,
+        "ANTHROPIC_AUTH_TOKEN": auth_token,
+        "ANTHROPIC_MODEL": main_model,
+        "ANTHROPIC_SMALL_FAST_MODEL": fast_model,
+        "CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC": "1",
     }
 
+    # Load existing settings to preserve other sections (e.g., MCP servers)
+    existing_config: dict = {}
+    if settings_path.exists():
+        try:
+            with open(settings_path, encoding="utf-8") as f:
+                existing_config = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            pass  # If file is corrupted, start fresh
+
+    # Merge: update env section while preserving other sections
+    existing_config["env"] = env_config
+
     settings_path.parent.mkdir(parents=True, exist_ok=True)
     with open(settings_path, "w", encoding="utf-8") as f:
-        json.dump(config, f, indent=2)
+        json.dump(existing_config, f, indent=2)
 
     console.print(
         Panel(

{router_maestro-0.1.4 → router_maestro-0.1.6}/src/router_maestro/server/routes/anthropic.py

@@ -3,6 +3,7 @@
 import json
 import uuid
 from collections.abc import AsyncGenerator
+from datetime import UTC, datetime
 
 from fastapi import APIRouter, HTTPException
 from fastapi.responses import StreamingResponse
@@ -13,6 +14,8 @@ from router_maestro.server.schemas.anthropic import (
     AnthropicCountTokensRequest,
     AnthropicMessagesRequest,
     AnthropicMessagesResponse,
+    AnthropicModelInfo,
+    AnthropicModelList,
     AnthropicStreamState,
     AnthropicTextBlock,
     AnthropicUsage,
@@ -26,6 +29,7 @@ from router_maestro.utils import (
     get_logger,
     map_openai_stop_reason_to_anthropic,
 )
+from router_maestro.utils.tokens import AnthropicStopReason
 
 logger = get_logger("server.routes.anthropic")
 
@@ -106,7 +110,7 @@ async def count_tokens(request: AnthropicCountTokensRequest):
 
     # Count messages
     for msg in request.messages:
-        content = msg.content if hasattr(msg, "content") else msg.get("content", "")
+        content = msg.content
         if isinstance(content, str):
             total_chars += len(content)
         elif isinstance(content, list):
@@ -115,12 +119,12 @@ async def count_tokens(request: AnthropicCountTokensRequest):
                     if block.get("type") == "text":
                         total_chars += len(block.get("text", ""))
                 elif hasattr(block, "text"):
-                    total_chars += len(block.text)
+                    total_chars += len(block.text)  # type: ignore[union-attr]
 
     return {"input_tokens": estimate_tokens_from_char_count(total_chars)}
 
 
-def _map_finish_reason(reason: str | None) -> str | None:
+def _map_finish_reason(reason: str | None) -> AnthropicStopReason | None:
     """Map OpenAI finish reason to Anthropic stop reason."""
     return map_openai_stop_reason_to_anthropic(reason)
 
@@ -144,7 +148,7 @@ def _estimate_input_tokens(request: AnthropicMessagesRequest) -> int:
 
     # Count messages
     for msg in request.messages:
-        content = msg.content if hasattr(msg, "content") else msg.get("content", "")
+        content = msg.content
         if isinstance(content, str):
             total_chars += len(content)
         elif isinstance(content, list):
@@ -161,7 +165,7 @@ def _estimate_input_tokens(request: AnthropicMessagesRequest) -> int:
                                 if isinstance(tc, dict) and tc.get("type") == "text":
                                     total_chars += len(tc.get("text", ""))
                 elif hasattr(block, "text"):
-                    total_chars += len(block.text)
+                    total_chars += len(block.text)  # type: ignore[union-attr]
 
     # Count tools definitions if present
     if request.tools:
@@ -226,3 +230,93 @@ async def stream_response(
             },
         }
         yield f"event: error\ndata: {json.dumps(error_event)}\n\n"
+
+
+def _generate_display_name(model_id: str) -> str:
+    """Generate a human-readable display name from model ID.
+
+    Transforms model IDs like 'github-copilot/claude-sonnet-4' into
+    'Claude Sonnet 4 (github-copilot)'.
+    """
+    if "/" in model_id:
+        provider, model_name = model_id.split("/", 1)
+    else:
+        provider = ""
+        model_name = model_id
+
+    # Capitalize words and handle common patterns
+    words = model_name.replace("-", " ").replace("_", " ").split()
+    display_words = []
+    for word in words:
+        # Keep version numbers as-is
+        if word.replace(".", "").isdigit():
+            display_words.append(word)
+        else:
+            display_words.append(word.capitalize())
+
+    display_name = " ".join(display_words)
+    if provider:
+        display_name = f"{display_name} ({provider})"
+
+    return display_name
+
+
+@router.get("/api/anthropic/v1/models")
+async def list_models(
+    limit: int = 20,
+    after_id: str | None = None,
+    before_id: str | None = None,
+) -> AnthropicModelList:
+    """List available models in Anthropic format.
+
+    Args:
+        limit: Maximum number of models to return (default 20)
+        after_id: Return models after this ID (for forward pagination)
+        before_id: Return models before this ID (for backward pagination)
+    """
+    model_router = get_router()
+    models = await model_router.list_models()
+
+    # Generate ISO 8601 timestamp for created_at
+    # Using current time since actual creation dates aren't tracked
+    created_at = datetime.now(UTC).strftime("%Y-%m-%dT%H:%M:%SZ")
+
+    # Convert to Anthropic format
+    anthropic_models = [
+        AnthropicModelInfo(
+            id=model.id,
+            created_at=created_at,
+            display_name=_generate_display_name(model.id),
+            type="model",
+        )
+        for model in models
+    ]
+
+    # Handle pagination
+    start_idx = 0
+    if after_id:
+        for i, model in enumerate(anthropic_models):
+            if model.id == after_id:
+                start_idx = i + 1
+                break
+
+    end_idx = len(anthropic_models)
+    if before_id:
+        for i, model in enumerate(anthropic_models):
+            if model.id == before_id:
+                end_idx = i
+                break
+
+    # Apply limit
+    paginated = anthropic_models[start_idx : min(start_idx + limit, end_idx)]
+
+    first_id = paginated[0].id if paginated else None
+    last_id = paginated[-1].id if paginated else None
+    has_more = (start_idx + limit) < end_idx
+
+    return AnthropicModelList(
+        data=paginated,
+        first_id=first_id,
+        last_id=last_id,
+        has_more=has_more,
+    )

{router_maestro-0.1.4 → router_maestro-0.1.6}/src/router_maestro/server/schemas/anthropic.py

@@ -244,3 +244,24 @@ class AnthropicStreamState(BaseModel):
     estimated_input_tokens: int = 0  # Estimated input tokens from request
     last_usage: dict | None = None  # Track the latest usage from stream chunks
     message_complete: bool = False  # Track if message_stop was sent
+
+
+# Models API types
+
+
+class AnthropicModelInfo(BaseModel):
+    """Anthropic model object."""
+
+    id: str
+    created_at: str  # ISO 8601 datetime
+    display_name: str
+    type: Literal["model"] = "model"
+
+
+class AnthropicModelList(BaseModel):
+    """Anthropic models list response with pagination."""
+
+    data: list[AnthropicModelInfo]
+    first_id: str | None = None
+    last_id: str | None = None
+    has_more: bool = False

{router_maestro-0.1.4 → router_maestro-0.1.6}/src/router_maestro/utils/tokens.py

@@ -1,8 +1,14 @@
 """Token estimation utilities."""
 
+from typing import Literal
+
 # Approximate characters per token for English text
 CHARS_PER_TOKEN = 4
 
+AnthropicStopReason = Literal[
+    "end_turn", "max_tokens", "stop_sequence", "tool_use", "pause_turn", "refusal"
+]
+
 
 def estimate_tokens(text: str) -> int:
     """Estimate token count from text.
@@ -31,7 +37,9 @@ def estimate_tokens_from_char_count(char_count: int) -> int:
     return char_count // CHARS_PER_TOKEN
 
 
-def map_openai_stop_reason_to_anthropic(openai_reason: str | None) -> str | None:
+def map_openai_stop_reason_to_anthropic(
+    openai_reason: str | None,
+) -> AnthropicStopReason | None:
     """Map OpenAI finish reason to Anthropic stop reason.
 
     Args:
@@ -42,7 +50,7 @@ def map_openai_stop_reason_to_anthropic(openai_reason: str | None) -> str | None
     """
     if openai_reason is None:
         return None
-    mapping = {
+    mapping: dict[str, AnthropicStopReason] = {
         "stop": "end_turn",
         "length": "max_tokens",
         "tool_calls": "tool_use",

router_maestro-0.1.6/tests/test_anthropic_models.py

@@ -0,0 +1,220 @@
+"""Tests for the Anthropic models endpoint."""
+
+from unittest.mock import AsyncMock, patch
+
+import pytest
+from fastapi import FastAPI
+from fastapi.testclient import TestClient
+
+from router_maestro.providers.base import ModelInfo
+from router_maestro.server.routes.anthropic import (
+    _generate_display_name,
+    list_models,
+    router,
+)
+from router_maestro.server.schemas.anthropic import AnthropicModelInfo, AnthropicModelList
+
+
+class TestGenerateDisplayName:
+    """Tests for display name generation."""
+
+    def test_simple_model_name(self):
+        """Test display name for simple model ID."""
+        result = _generate_display_name("claude-sonnet-4")
+        assert result == "Claude Sonnet 4"
+
+    def test_model_with_provider(self):
+        """Test display name includes provider."""
+        result = _generate_display_name("github-copilot/claude-sonnet-4")
+        assert result == "Claude Sonnet 4 (github-copilot)"
+
+    def test_model_with_version_number(self):
+        """Test display name preserves version numbers."""
+        result = _generate_display_name("openai/gpt-4o")
+        assert result == "Gpt 4o (openai)"
+
+    def test_model_with_underscores(self):
+        """Test display name handles underscores."""
+        result = _generate_display_name("provider/some_model_name")
+        assert result == "Some Model Name (provider)"
+
+
+class TestAnthropicModelInfoSchema:
+    """Tests for AnthropicModelInfo schema."""
+
+    def test_model_info_fields(self):
+        """Test that model info has required fields."""
+        model = AnthropicModelInfo(
+            id="claude-sonnet-4",
+            created_at="2025-02-02T00:00:00Z",
+            display_name="Claude Sonnet 4",
+            type="model",
+        )
+        assert model.id == "claude-sonnet-4"
+        assert model.created_at == "2025-02-02T00:00:00Z"
+        assert model.display_name == "Claude Sonnet 4"
+        assert model.type == "model"
+
+    def test_model_info_default_type(self):
+        """Test that type defaults to 'model'."""
+        model = AnthropicModelInfo(
+            id="test-model",
+            created_at="2025-02-02T00:00:00Z",
+            display_name="Test Model",
+        )
+        assert model.type == "model"
+
+
+class TestAnthropicModelListSchema:
+    """Tests for AnthropicModelList schema."""
+
+    def test_model_list_with_data(self):
+        """Test model list with data."""
+        models = AnthropicModelList(
+            data=[
+                AnthropicModelInfo(
+                    id="model-1",
+                    created_at="2025-02-02T00:00:00Z",
+                    display_name="Model 1",
+                )
+            ],
+            first_id="model-1",
+            last_id="model-1",
+            has_more=False,
+        )
+        assert len(models.data) == 1
+        assert models.first_id == "model-1"
+        assert models.last_id == "model-1"
+        assert models.has_more is False
+
+    def test_model_list_empty(self):
+        """Test empty model list."""
+        models = AnthropicModelList(data=[])
+        assert len(models.data) == 0
+        assert models.first_id is None
+        assert models.last_id is None
+        assert models.has_more is False
+
+    def test_model_list_pagination(self):
+        """Test model list with pagination."""
+        models = AnthropicModelList(
+            data=[],
+            first_id="first",
+            last_id="last",
+            has_more=True,
+        )
+        assert models.has_more is True
+
+
+@pytest.fixture
+def mock_router():
+    """Create a mock router."""
+    mock = AsyncMock()
+    mock.list_models = AsyncMock(
+        return_value=[
+            ModelInfo(
+                id="github-copilot/claude-sonnet-4",
+                name="claude-sonnet-4",
+                provider="github-copilot",
+            ),
+            ModelInfo(
+                id="github-copilot/gpt-4o",
+                name="gpt-4o",
+                provider="github-copilot",
+            ),
+            ModelInfo(id="openai/gpt-4o", name="gpt-4o", provider="openai"),
+        ]
+    )
+    return mock
+
+
+@pytest.fixture
+def app():
+    """Create a test FastAPI app."""
+    app = FastAPI()
+    app.include_router(router)
+    return app
+
+
+@pytest.fixture
+def client(app):
+    """Create a test client."""
+    return TestClient(app)
+
+
+class TestListModelsEndpoint:
+    """Tests for the /api/anthropic/v1/models endpoint."""
+
+    @pytest.mark.anyio
+    async def test_list_models_response_format(self, mock_router):
+        """Test that response matches Anthropic format."""
+        with patch("router_maestro.server.routes.anthropic.get_router", return_value=mock_router):
+            response = await list_models()
+
+        assert isinstance(response, AnthropicModelList)
+        assert len(response.data) == 3
+        assert response.first_id == "github-copilot/claude-sonnet-4"
+        assert response.last_id == "openai/gpt-4o"
+        assert response.has_more is False
+
+    @pytest.mark.anyio
+    async def test_list_models_model_fields(self, mock_router):
+        """Test that each model has required Anthropic fields."""
+        with patch("router_maestro.server.routes.anthropic.get_router", return_value=mock_router):
+            response = await list_models()
+
+        model = response.data[0]
+        assert model.id == "github-copilot/claude-sonnet-4"
+        assert model.type == "model"
+        assert model.display_name == "Claude Sonnet 4 (github-copilot)"
+        # created_at should be ISO 8601 format
+        assert "T" in model.created_at
+        assert model.created_at.endswith("Z")
+
+    @pytest.mark.anyio
+    async def test_list_models_pagination_limit(self, mock_router):
+        """Test pagination with limit parameter."""
+        with patch("router_maestro.server.routes.anthropic.get_router", return_value=mock_router):
+            response = await list_models(limit=2)
+
+        assert len(response.data) == 2
+        assert response.has_more is True
+        assert response.first_id == "github-copilot/claude-sonnet-4"
+        assert response.last_id == "github-copilot/gpt-4o"
+
+    @pytest.mark.anyio
+    async def test_list_models_pagination_after_id(self, mock_router):
+        """Test pagination with after_id parameter."""
+        with patch("router_maestro.server.routes.anthropic.get_router", return_value=mock_router):
+            response = await list_models(after_id="github-copilot/claude-sonnet-4")
+
+        assert len(response.data) == 2
+        assert response.data[0].id == "github-copilot/gpt-4o"
+        assert response.has_more is False
+
+    @pytest.mark.anyio
+    async def test_list_models_empty(self):
+        """Test response when no models available."""
+        mock = AsyncMock()
+        mock.list_models = AsyncMock(return_value=[])
+
+        with patch("router_maestro.server.routes.anthropic.get_router", return_value=mock):
+            response = await list_models()
+
+        assert len(response.data) == 0
+        assert response.first_id is None
+        assert response.last_id is None
+        assert response.has_more is False
+
+    def test_http_endpoint(self, client, mock_router):
+        """Test the HTTP endpoint via test client."""
+        with patch("router_maestro.server.routes.anthropic.get_router", return_value=mock_router):
+            response = client.get("/api/anthropic/v1/models")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert "data" in data
+        assert "first_id" in data
+        assert "last_id" in data
+        assert "has_more" in data
+        assert len(data["data"]) == 3

{router_maestro-0.1.4 → router_maestro-0.1.6}/tests/test_auth.py

@@ -3,8 +3,6 @@
 import tempfile
 from pathlib import Path
 
-import pytest
-
 from router_maestro.auth.storage import ApiKeyCredential, AuthStorage, AuthType, OAuthCredential
 
 
@@ -74,11 +72,14 @@ class TestAuthStorage:
             # Create and save
             storage = AuthStorage()
             storage.set("openai", ApiKeyCredential(key="test-key"))
-            storage.set("github-copilot", OAuthCredential(
-                refresh="refresh",
-                access="access",
-                expires=12345,
-            ))
+            storage.set(
+                "github-copilot",
+                OAuthCredential(
+                    refresh="refresh",
+                    access="access",
+                    expires=12345,
+                ),
+            )
             storage.save(path)
 
             # Load and verify

{router_maestro-0.1.4 → router_maestro-0.1.6}/tests/test_providers.py

@@ -1,7 +1,5 @@
 """Tests for providers module."""
 
-import pytest
-
 from router_maestro.providers import (
     AnthropicProvider,
     ChatRequest,

{router_maestro-0.1.4 → router_maestro-0.1.6}/tests/test_router.py

@@ -19,9 +19,7 @@ class MockProvider(BaseProvider):
     ):
         self._name = name
         self._authenticated = authenticated
-        self._models = models or [
-            ModelInfo(id="test-model", name="Test Model", provider=name)
-        ]
+        self._models = models or [ModelInfo(id="test-model", name="Test Model", provider=name)]
         self._fail_on_request = fail_on_request
 
     @property

{router_maestro-0.1.4 → router_maestro-0.1.6}/tests/test_translation.py

@@ -1,7 +1,10 @@
 """Tests for the translation module."""
 
-import pytest
-
+from router_maestro.server.schemas.anthropic import (
+    AnthropicMessagesRequest,
+    AnthropicTextBlock,
+    AnthropicUserMessage,
+)
 from router_maestro.server.translation import (
     _extract_text_content,
     _map_stop_reason,
@@ -10,11 +13,6 @@ from router_maestro.server.translation import (
     _translate_tools,
     translate_anthropic_to_openai,
 )
-from router_maestro.server.schemas.anthropic import (
-    AnthropicMessagesRequest,
-    AnthropicTextBlock,
-    AnthropicUserMessage,
-)
 
 
 class TestModelNameTranslation:

{router_maestro-0.1.4 → router_maestro-0.1.6}/tests/test_utils.py

@@ -1,7 +1,5 @@
 """Tests for utility functions."""
 
-import pytest
-
 from router_maestro.utils import (
     estimate_tokens,
     estimate_tokens_from_char_count,

{router_maestro-0.1.4 → router_maestro-0.1.6}/uv.lock

@@ -925,7 +925,7 @@ wheels = [
 
 [[package]]
 name = "router-maestro"
-version = "0.1.4"
+version = "0.1.6"
 source = { editable = "." }
 dependencies = [
     { name = "aiosqlite" },