Skip to content

Use Claude Code, Codex, VSCode, Pi, and OpenCode (and 6 other harnesses) for free (1.3B+ free tokens) from your terminal, app, IDE, or phone, and now from the browser with native browser sessions (multi-harness + multi-model) like OpenClaw (voice supported + ToS friendly)

Python

Added claude-code native model picker

Alishahryar172b34ad57cdf
diff --git a/README.md b/README.md
index e2d4b0b9..dafda4df 100644
--- a/README.md
+++ b/README.md
@@ -39,6 +39,7 @@ Free Claude Code routes Anthropic Messages API traffic from Claude Code to NVIDI
- Drop-in proxy for Claude Code's Anthropic API calls.
- Six provider backends: NVIDIA NIM, OpenRouter, DeepSeek, LM Studio, llama.cpp, and Ollama.
- Per-model routing: send Opus, Sonnet, Haiku, and fallback traffic to different providers.
+- Native Claude Code `/model` picker support through the proxy's `/v1/models` endpoint.
- Streaming, tool use, reasoning/thinking block handling, and local request optimizations.
- Optional Discord or Telegram bot wrapper for remote coding sessions.
- Optional voice-note transcription through local Whisper or NVIDIA NIM.
@@ -47,7 +48,7 @@ Free Claude Code routes Anthropic Messages API traffic from Claude Code to NVIDI
### 1. Install Requirements
-Install [Claude Code](https://github.com/anthropics/claude-code), then install `uv` and Python 3.14.
+Install [Claude Code](https://github.com/anthropics/claude-code) 2.1.126 or later, then install `uv` and Python 3.14.
macOS/Linux:
@@ -296,19 +297,13 @@ Restart the IDE after changing the file.
### Model Picker
-`claude-pick` lets you choose a model at launch time.
+Claude Code 2.1.126 or later reads this proxy's `/v1/models` endpoint when `ANTHROPIC_BASE_URL` points at the proxy. Start Claude Code normally, run `/model`, and choose any discovered provider model.
-```bash
-brew install fzf
-alias claude-pick="/absolute/path/to/free-claude-code/claude-pick"
-claude-pick
-```
-
-You can also create fixed aliases:
+<div align="center">
+ <img src="cc-model-picker.png" alt="Claude Code model picker showing gateway models" width="700">
+</div>
-```bash
-alias claude-kimi='ANTHROPIC_BASE_URL="http://localhost:8082" ANTHROPIC_AUTH_TOKEN="freecc:moonshotai/kimi-k2.5" claude'
-```
+The proxy lists models for configured provider keys and referenced local providers. Picker-safe IDs are routed back to the real provider/model automatically, so no `.env` edit or separate launcher script is needed after startup.
## Optional Integrations
diff --git a/api/model_router.py b/api/model_router.py
index f49d1065..c36a4002 100644
--- a/api/model_router.py
+++ b/api/model_router.py
@@ -6,10 +6,13 @@ from dataclasses import dataclass
from loguru import logger
+from config.provider_ids import SUPPORTED_PROVIDER_IDS
from config.settings import Settings
from .models.anthropic import MessagesRequest, TokenCountRequest
+GATEWAY_MODEL_ID_PREFIX = "anthropic"
+
@dataclass(frozen=True, slots=True)
class ResolvedModel:
@@ -39,6 +42,25 @@ class ModelRouter:
self._settings = settings
def resolve(self, claude_model_name: str) -> ResolvedModel:
+ direct_provider_id, direct_provider_model = self._direct_provider_model(
+ claude_model_name
+ )
+ if direct_provider_id is not None and direct_provider_model is not None:
+ thinking_enabled = self._settings.resolve_thinking(direct_provider_model)
+ logger.debug(
+ "MODEL DIRECT: '{}' -> provider='{}' model='{}'",
+ claude_model_name,
+ direct_provider_id,
+ direct_provider_model,
+ )
+ return ResolvedModel(
+ original_model=claude_model_name,
+ provider_id=direct_provider_id,
+ provider_model=direct_provider_model,
+ provider_model_ref=claude_model_name,
+ thinking_enabled=thinking_enabled,
+ )
+
provider_model_ref = self._settings.resolve_model(claude_model_name)
thinking_enabled = self._settings.resolve_thinking(claude_model_name)
provider_id = Settings.parse_provider_type(provider_model_ref)
@@ -55,6 +77,30 @@ class ModelRouter:
thinking_enabled=thinking_enabled,
)
+ def _direct_provider_model(self, model_name: str) -> tuple[str | None, str | None]:
+ provider_id, separator, provider_model = model_name.partition("/")
+ if not separator:
+ return None, None
+ if provider_id == GATEWAY_MODEL_ID_PREFIX:
+ return self._gateway_encoded_provider_model(provider_model)
+ if provider_id not in SUPPORTED_PROVIDER_IDS:
+ return None, None
+ if not provider_model:
+ return None, None
+ return provider_id, provider_model
+
+ def _gateway_encoded_provider_model(
+ self, model_name: str
+ ) -> tuple[str | None, str | None]:
+ provider_id, separator, provider_model = model_name.partition("/")
+ if not separator:
+ return None, None
+ if provider_id not in SUPPORTED_PROVIDER_IDS:
+ return None, None
+ if not provider_model:
+ return None, None
+ return provider_id, provider_model
+
def resolve_messages_request(
self, request: MessagesRequest
) -> RoutedMessagesRequest:
diff --git a/api/routes.py b/api/routes.py
index 39e98371..fe72b010 100644
--- a/api/routes.py
+++ b/api/routes.py
@@ -5,6 +5,7 @@ from loguru import logger
from config.settings import Settings
from core.anthropic import get_token_count
+from providers.registry import ProviderRegistry
from . import dependencies
from .dependencies import get_settings, require_api_key
@@ -14,6 +15,9 @@ from .services import ClaudeProxyService
router = APIRouter()
+DISCOVERED_MODEL_CREATED_AT = "1970-01-01T00:00:00Z"
+GATEWAY_MODEL_ID_PREFIX = "anthropic"
+
SUPPORTED_CLAUDE_MODELS = [
ModelResponse(
@@ -73,6 +77,63 @@ def _probe_response(allow: str) -> Response:
return Response(status_code=204, headers={"Allow": allow})
+def _gateway_model_id(provider_model_ref: str) -> str:
+ return f"{GATEWAY_MODEL_ID_PREFIX}/{provider_model_ref}"
+
+
+def _discovered_model_response(model_id: str, *, display_name: str) -> ModelResponse:
+ return ModelResponse(
+ id=model_id,
+ display_name=display_name,
+ created_at=DISCOVERED_MODEL_CREATED_AT,
+ )
+
+
+def _append_unique_model(
+ models: list[ModelResponse], seen: set[str], model: ModelResponse
+) -> None:
+ if model.id in seen:
+ return
+ seen.add(model.id)
+ models.append(model)
+
+
+def _build_models_list_response(
+ settings: Settings, provider_registry: ProviderRegistry | None
+) -> ModelsListResponse:
+ models: list[ModelResponse] = []
+ seen: set[str] = set()
+
+ for ref in settings.configured_chat_model_refs():
+ _append_unique_model(
+ models,
+ seen,
+ _discovered_model_response(
+ _gateway_model_id(ref.model_ref), display_name=ref.model_ref
+ ),
+ )
+
+ if provider_registry is not None:
+ for model_ref in provider_registry.cached_prefixed_model_refs():
+ _append_unique_model(
+ models,
+ seen,
+ _discovered_model_response(
+ _gateway_model_id(model_ref), display_name=model_ref
+ ),
+ )
+
+ for model in SUPPORTED_CLAUDE_MODELS:
+ _append_unique_model(models, seen, model)
+
+ return ModelsListResponse(
+ data=models,
+ first_id=models[0].id if models else None,
+ has_more=False,
+ last_id=models[-1].id if models else None,
+ )
+
+
# =============================================================================
# Routes
# =============================================================================
@@ -139,14 +200,15 @@ async def probe_health():
@router.get("/v1/models", response_model=ModelsListResponse)
-async def list_models(_auth=Depends(require_api_key)):
- """List the Claude model ids this proxy advertises for compatibility."""
- return ModelsListResponse(
- data=SUPPORTED_CLAUDE_MODELS,
- first_id=SUPPORTED_CLAUDE_MODELS[0].id if SUPPORTED_CLAUDE_MODELS else None,
- has_more=False,
- last_id=SUPPORTED_CLAUDE_MODELS[-1].id if SUPPORTED_CLAUDE_MODELS else None,
- )
+async def list_models(
+ request: Request,
+ settings: Settings = Depends(get_settings),
+ _auth=Depends(require_api_key),
+):
+ """List the model ids this proxy advertises to Claude-compatible clients."""
+ registry = getattr(request.app.state, "provider_registry", None)
+ provider_registry = registry if isinstance(registry, ProviderRegistry) else None
+ return _build_models_list_response(settings, provider_registry)
@router.post("/stop")
diff --git a/api/runtime.py b/api/runtime.py
index e35197d2..a4b340bc 100644
--- a/api/runtime.py
+++ b/api/runtime.py
@@ -105,6 +105,7 @@ class AppRuntime:
try:
warn_if_process_auth_token(self.settings)
await self._provider_registry.validate_configured_models(self.settings)
+ self._provider_registry.start_model_list_refresh(self.settings)
await self._start_messaging_if_configured()
self._publish_state()
except Exception as exc:
diff --git a/cc-model-picker.png b/cc-model-picker.png
new file mode 100644
index 00000000..07338133
Binary files /dev/null and b/cc-model-picker.png differ
diff --git a/claude-pick b/claude-pick
deleted file mode 100755
index 409188bb..00000000
--- a/claude-pick
+++ /dev/null
@@ -1,187 +0,0 @@
-#!/usr/bin/env bash
-# claude-pick — Interactive model picker for free-claude-code
-# Usage: claude-pick [extra claude args...]
-
-set -euo pipefail
-
-SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
-MODELS_FILE="$SCRIPT_DIR/nvidia_nim_models.json"
-ENV_FILE="${CLAUDE_PICK_ENV_FILE:-$SCRIPT_DIR/.env}"
-PORT="${CLAUDE_PICK_PORT:-8082}"
-BASE_URL="http://localhost:$PORT"
-OPENROUTER_MODELS_URL="https://openrouter.ai/api/v1/models"
-DEFAULT_LM_STUDIO_BASE_URL="http://localhost:1234/v1"
-DEFAULT_LLAMACPP_BASE_URL="http://localhost:8080/v1"
-
-if ! command -v uv >/dev/null 2>&1; then
- echo "Error: uv is required." >&2
- exit 1
-fi
-
-run_python() {
- uv run python "$@"
-}
-
-read_env_value() {
- local key="$1"
- [[ -f "$ENV_FILE" ]] || return 0
-
- local raw
- raw="$(grep -E "^[[:space:]]*${key}[[:space:]]*=" "$ENV_FILE" | tail -n 1 || true)"
- raw="${raw#*=}"
- raw="${raw%%#*}"
- raw="$(echo "$raw" | xargs || true)"
- raw="${raw%\"}"
- raw="${raw#\"}"
- raw="${raw%\'}"
- raw="${raw#\'}"
- echo "$raw"
-}
-
-if ! command -v fzf >/dev/null 2>&1; then
- echo "Error: fzf is required for the model picker." >&2
- echo "Install it from: https://github.com/junegunn/fzf" >&2
- exit 1
-fi
-
-parse_models_from_json() {
- run_python -c '
-import json, sys
-try:
- payload = json.load(sys.stdin)
-except Exception:
- sys.exit(0)
-for item in payload.get("data", []):
- model_id = item.get("id")
- if model_id:
- print(model_id)
-'
-}
-
-get_nvidia_models() {
- if [[ ! -f "$MODELS_FILE" ]]; then
- echo "Error: $MODELS_FILE not found." >&2
- echo "Run: curl \"https://integrate.api.nvidia.com/v1/models\" > nvidia_nim_models.json" >&2
- exit 1
- fi
-
- run_python -c '
-import json, sys
-with open(sys.argv[1], "r", encoding="utf-8") as f:
- payload = json.load(f)
-for item in payload.get("data", []):
- model_id = item.get("id")
- if model_id:
- print(model_id)
-' "$MODELS_FILE"
-}
-
-get_openrouter_models() {
- if ! command -v curl >/dev/null 2>&1; then
- echo "Error: curl is required for OpenRouter model discovery." >&2
- exit 1
- fi
-
- local openrouter_key
- openrouter_key="${OPENROUTER_API_KEY:-$(read_env_value OPENROUTER_API_KEY)}"
-
- local response
- if [[ -n "$openrouter_key" ]]; then
- if ! response="$(curl -fsSL -H "Authorization: Bearer $openrouter_key" "$OPENROUTER_MODELS_URL")"; then
- echo "Error: Failed to fetch OpenRouter models." >&2
- exit 1
- fi
- else
- if ! response="$(curl -fsSL "$OPENROUTER_MODELS_URL")"; then
- echo "Error: Failed to fetch OpenRouter models." >&2
- exit 1
- fi
- fi
-
- parse_models_from_json <<< "$response"
-}
-
-get_lmstudio_models() {
- if ! command -v curl >/dev/null 2>&1; then
- echo "Error: curl is required for LM Studio model discovery." >&2
- exit 1
- fi
-
- local lm_base
- lm_base="${LM_STUDIO_BASE_URL:-$(read_env_value LM_STUDIO_BASE_URL)}"
- lm_base="${lm_base:-$DEFAULT_LM_STUDIO_BASE_URL}"
-
- local models_url
- if [[ "$lm_base" == */v1 ]]; then
- models_url="${lm_base}/models"
- else
- models_url="${lm_base}/v1/models"
- fi
-
- local response
- if ! response="$(curl -fsSL "$models_url")"; then
- echo "Error: Failed to query LM Studio models at $models_url" >&2
- echo "Start LM Studio server first (Developer tab or: lms server start)." >&2
- exit 1
- fi
-
- parse_models_from_json <<< "$response"
-}
-
-provider="${CLAUDE_PICK_PROVIDER:-$(read_env_value PROVIDER_TYPE)}"
-provider="${provider:-nvidia_nim}"
-
-prompt="Select a model> "
-case "$provider" in
- nvidia_nim)
- models="$(get_nvidia_models)"
- prompt="Select a NVIDIA NIM model> "
- ;;
- open_router|openrouter)
- models="$(get_openrouter_models)"
- prompt="Select an OpenRouter model> "
- ;;
- lmstudio|lm_studio|lm-studio)
- models="$(get_lmstudio_models)"
- prompt="Select an LM Studio model> "
- ;;
- llamacpp|llama.cpp)
- # llama.cpp doesn't have a standardized /models endpoint that returns all loaded models reliably
- # in the same way, but it does support Anthropic routing. We can use a stub model or query if available.
- # For simple picker, we'll just allow passing a default or typing it in, but to match fzf we offer a stub.
- models="local-model\nllama-server"
- prompt="Select a llama.cpp model> "
- ;;
- *)
- echo "Error: Unsupported PROVIDER_TYPE='$provider'." >&2
- echo "Expected one of: nvidia_nim, open_router, lmstudio, llamacpp" >&2
- exit 1
- ;;
-esac
-
-models="$(printf "%s\n" "$models" | sed '/^[[:space:]]*$/d' | sort -u)"
-if [[ -z "$models" ]]; then
- echo "Error: No models found for provider '$provider'." >&2
- exit 1
-fi
-
-model="$(printf "%s\n" "$models" | fzf --prompt="$prompt" --height=40% --reverse)"
-
-if [[ -z "${model:-}" ]]; then
- echo "No model selected." >&2
- exit 1
-fi
-
-# Read auth token from .env or environment
-auth_token="${ANTHROPIC_AUTH_TOKEN:-$(read_env_value ANTHROPIC_AUTH_TOKEN)}"
-if [[ -z "$auth_token" ]]; then
- auth_token="freecc"
-fi
-
-# If auth_token doesn't contain a colon, append ":$model"
-if [[ "$auth_token" != *:* ]]; then
- auth_token="$auth_token:$model"
-fi
-
-echo "Launching Claude with provider: $provider, model: $model" >&2
-ANTHROPIC_AUTH_TOKEN="$auth_token" ANTHROPIC_BASE_URL="$BASE_URL" exec claude "$@"
diff --git a/providers/registry.py b/providers/registry.py
index 59759946..de4e83ae 100644
--- a/providers/registry.py
+++ b/providers/registry.py
@@ -4,7 +4,8 @@ from __future__ import annotations
import asyncio
from collections import defaultdict
-from collections.abc import Callable, MutableMapping
+from collections.abc import Callable, Iterable, MutableMapping
+from contextlib import suppress
import httpx
from loguru import logger
@@ -186,11 +187,44 @@ def _provider_query_failure_reason(
return f"query failure: {type(exc).__name__}"
+def _referenced_provider_ids(settings: Settings) -> frozenset[str]:
+ return frozenset(ref.provider_id for ref in settings.configured_chat_model_refs())
+
+
+def _model_list_provider_ids_for_settings(settings: Settings) -> tuple[str, ...]:
+ """Return providers worth discovering for this process configuration."""
+ referenced_provider_ids = _referenced_provider_ids(settings)
+ provider_ids: list[str] = []
+ for provider_id, descriptor in PROVIDER_DESCRIPTORS.items():
+ if descriptor.static_credential is not None:
+ if provider_id in referenced_provider_ids:
+ provider_ids.append(provider_id)
+ continue
+ if (
+ descriptor.credential_env is not None
+ and _credential_for(descriptor, settings).strip()
+ ):
+ provider_ids.append(provider_id)
+ return tuple(provider_ids)
+
+
+def _log_model_discovery_failure(
+ provider_id: str, exc: BaseException, settings: Settings
+) -> None:
+ logger.warning(
+ "Provider model discovery skipped: provider={} reason={}",
+ provider_id,
+ _provider_query_failure_reason(exc, settings),
+ )
+
+
class ProviderRegistry:
"""Cache and clean up provider instances by provider id."""
def __init__(self, providers: MutableMapping[str, BaseProvider] | None = None):
self._providers = providers if providers is not None else {}
+ self._model_ids_by_provider: dict[str, frozenset[str]] = {}
+ self._model_list_refresh_task: asyncio.Task[None] | None = None
def is_cached(self, provider_id: str) -> bool:
"""Return whether a provider for this id is already in the cache."""
@@ -201,6 +235,105 @@ class ProviderRegistry:
self._providers[provider_id] = create_provider(provider_id, settings)
return self._providers[provider_id]
+ def cache_model_ids(self, provider_id: str, model_ids: Iterable[str]) -> None:
+ """Store a provider model-list result for later instant API responses."""
+ self._model_ids_by_provider[provider_id] = frozenset(
+ model_id for model_id in model_ids if model_id.strip()
+ )
+
+ def cached_model_ids(self) -> dict[str, frozenset[str]]:
+ """Return a copy of cached raw provider model ids."""
+ return dict(self._model_ids_by_provider)
+
+ def cached_prefixed_model_refs(self) -> tuple[str, ...]:
+ """Return cached provider models in user-selectable ``provider/model`` form."""
+ refs: list[str] = []
+ for provider_id in SUPPORTED_PROVIDER_IDS:
+ refs.extend(
+ f"{provider_id}/{model_id}"
+ for model_id in sorted(self._model_ids_by_provider.get(provider_id, ()))
+ )
+ return tuple(refs)
+
+ async def refresh_model_list_cache(
+ self, settings: Settings, *, only_missing: bool = False
+ ) -> None:
+ """Best-effort refresh of model lists for providers usable in this process."""
+ provider_ids = _model_list_provider_ids_for_settings(settings)
+ if only_missing:
+ provider_ids = tuple(
+ provider_id
+ for provider_id in provider_ids
+ if provider_id not in self._model_ids_by_provider
+ )
+ await self._refresh_model_ids(settings, provider_ids)
+
+ def start_model_list_refresh(self, settings: Settings) -> None:
+ """Start a non-blocking cache warmup for missing eligible provider lists."""
+ if (
+ self._model_list_refresh_task is not None
+ and not self._model_list_refresh_task.done()
+ ):
+ return
+
+ provider_ids = tuple(
+ provider_id
+ for provider_id in _model_list_provider_ids_for_settings(settings)
+ if provider_id not in self._model_ids_by_provider
+ )
+ if not provider_ids:
+ logger.info(
+ "Provider model discovery cache already warm: providers={}",
+ len(self._model_ids_by_provider),
+ )
+ return
+
+ self._model_list_refresh_task = asyncio.create_task(
+ self._run_model_list_refresh(settings, provider_ids)
+ )
+
+ async def _run_model_list_refresh(
+ self, settings: Settings, provider_ids: tuple[str, ...]
+ ) -> None:
+ try:
+ await self._refresh_model_ids(settings, provider_ids)
+ except asyncio.CancelledError:
+ raise
+ except Exception as exc:
+ logger.warning(
+ "Provider model discovery task failed: exc_type={}",
+ type(exc).__name__,
+ )
+
+ async def _refresh_model_ids(
+ self, settings: Settings, provider_ids: tuple[str, ...]
+ ) -> None:
+ tasks: dict[str, asyncio.Task[frozenset[str]]] = {}
+ for provider_id in provider_ids:
+ try:
+ provider = self.get(provider_id, settings)
+ except Exception as exc:
+ _log_model_discovery_failure(provider_id, exc, settings)
+ continue
+ tasks[provider_id] = asyncio.create_task(provider.list_model_ids())
+
+ if not tasks:
+ return
+
+ results = await asyncio.gather(*tasks.values(), return_exceptions=True)
+ for (provider_id, _task), result in zip(tasks.items(), results, strict=True):
+ if isinstance(result, BaseException):
+ if isinstance(result, asyncio.CancelledError):
+ raise result
+ _log_model_discovery_failure(provider_id, result, settings)
+ continue
+ self.cache_model_ids(provider_id, result)
+ logger.info(
+ "Provider model discovery cached: provider={} models={}",
+ provider_id,
+ len(result),
+ )
+
async def validate_configured_models(self, settings: Settings) -> None:
"""Fail fast unless every configured chat model exists upstream."""
refs = settings.configured_chat_model_refs()
@@ -233,6 +366,7 @@ class ProviderRegistry:
_format_provider_query_failures(provider_refs, result, settings)
)
continue
+ self.cache_model_ids(provider_id, result)
failures.extend(
_format_missing_model_failure(ref)
for ref in provider_refs
@@ -257,6 +391,14 @@ class ProviderRegistry:
Attempts all providers even if one fails. A single failure is re-raised
as-is; multiple failures are wrapped in :exc:`ExceptionGroup`.
"""
+ if (
+ self._model_list_refresh_task is not None
+ and not self._model_list_refresh_task.done()
+ ):
+ self._model_list_refresh_task.cancel()
+ with suppress(asyncio.CancelledError):
+ await self._model_list_refresh_task
+
items = list(self._providers.items())
errors: list[Exception] = []
try:
@@ -267,6 +409,7 @@ class ProviderRegistry:
errors.append(e)
finally:
self._providers.clear()
+ self._model_ids_by_provider.clear()
if len(errors) == 1:
raise errors[0]
if len(errors) > 1:
diff --git a/tests/api/test_api.py b/tests/api/test_api.py
index b1f00188..ee3784f1 100644
--- a/tests/api/test_api.py
+++ b/tests/api/test_api.py
@@ -34,6 +34,7 @@ def client():
"providers.registry.ProviderRegistry.validate_configured_models",
new_callable=AsyncMock,
),
+ patch("providers.registry.ProviderRegistry.start_model_list_refresh"),
TestClient(app) as test_client,
):
yield test_client
diff --git a/tests/api/test_model_listing.py b/tests/api/test_model_listing.py
new file mode 100644
index 00000000..7e11194e
--- /dev/null
+++ b/tests/api/test_model_listing.py
@@ -0,0 +1,71 @@
+from fastapi.testclient import TestClient
+
+from api.app import create_app
+from api.dependencies import get_settings
+from config.settings import Settings
+from providers.registry import ProviderRegistry
+
+
+def _settings() -> Settings:
+ return Settings.model_construct(
+ model="deepseek/deepseek-chat",
+ model_opus="open_router/anthropic/claude-opus",
+ model_sonnet=None,
+ model_haiku="deepseek/deepseek-chat",
+ anthropic_auth_token="",
+ )
+
+
+def test_models_list_includes_configured_refs_cached_provider_models_and_aliases():
+ app = create_app(lifespan_enabled=False)
+ settings = _settings()
+ registry = ProviderRegistry()
+ registry.cache_model_ids("deepseek", {"deepseek-chat"})
+ registry.cache_model_ids("open_router", {"meta/llama-3.3", "anthropic/claude-opus"})
+ app.state.provider_registry = registry
+ app.dependency_overrides[get_settings] = lambda: settings
+
+ try:
+ response = TestClient(app).get("/v1/models")
+ finally:
+ app.dependency_overrides.clear()
+
+ assert response.status_code == 200
+ data = response.json()
+ ids = [item["id"] for item in data["data"]]
+
+ assert ids[:3] == [
+ "anthropic/deepseek/deepseek-chat",
+ "anthropic/open_router/anthropic/claude-opus",
+ "anthropic/open_router/meta/llama-3.3",
+ ]
+ assert ids.count("anthropic/deepseek/deepseek-chat") == 1
+ assert ids.count("anthropic/open_router/anthropic/claude-opus") == 1
+ display_names = {item["id"]: item["display_name"] for item in data["data"]}
+ assert (
+ display_names["anthropic/open_router/meta/llama-3.3"]
+ == "open_router/meta/llama-3.3"
+ )
+ assert "claude-sonnet-4-20250514" in ids
+ assert data["first_id"] == ids[0]
+ assert data["last_id"] == ids[-1]
+ assert data["has_more"] is False
+
+
+def test_models_list_works_without_provider_registry():
+ app = create_app(lifespan_enabled=False)
+ settings = _settings()
+ app.dependency_overrides[get_settings] = lambda: settings
+
+ try:
+ response = TestClient(app).get("/v1/models")
+ finally:
+ app.dependency_overrides.clear()
+
+ assert response.status_code == 200
+ ids = [item["id"] for item in response.json()["data"]]
+ assert ids[:2] == [
+ "anthropic/deepseek/deepseek-chat",
+ "anthropic/open_router/anthropic/claude-opus",
+ ]
+ assert "claude-sonnet-4-20250514" in ids
diff --git a/tests/api/test_model_router.py b/tests/api/test_model_router.py
index 6bc2cd58..9440c484 100644
--- a/tests/api/test_model_router.py
+++ b/tests/api/test_model_router.py
@@ -93,6 +93,55 @@ def test_model_router_applies_sonnet_override(settings):
)
+def test_model_router_routes_prefixed_provider_model_directly(settings):
+ routed = ModelRouter(settings).resolve_messages_request(
+ MessagesRequest(
+ model="deepseek/deepseek-chat",
+ max_tokens=100,
+ messages=[Message(role="user", content="hello")],
+ )
+ )
+
+ assert routed.request.model == "deepseek-chat"
+ assert routed.resolved.original_model == "deepseek/deepseek-chat"
+ assert routed.resolved.provider_id == "deepseek"
+ assert routed.resolved.provider_model == "deepseek-chat"
+ assert routed.resolved.provider_model_ref == "deepseek/deepseek-chat"
+
+
+def test_model_router_routes_gateway_encoded_provider_model_directly(settings):
+ routed = ModelRouter(settings).resolve_messages_request(
+ MessagesRequest(
+ model="anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro",
+ max_tokens=100,
+ messages=[Message(role="user", content="hello")],
+ )
+ )
+
+ assert routed.request.model == "deepseek-ai/deepseek-v4-pro"
+ assert (
+ routed.resolved.original_model
+ == "anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"
+ )
+ assert routed.resolved.provider_id == "nvidia_nim"
+ assert routed.resolved.provider_model == "deepseek-ai/deepseek-v4-pro"
+ assert (
+ routed.resolved.provider_model_ref
+ == "anthropic/nvidia_nim/deepseek-ai/deepseek-v4-pro"
+ )
+
+
+def test_model_router_direct_prefixed_model_uses_provider_model_for_thinking(settings):
+ settings.enable_model_thinking = False
+ settings.enable_opus_thinking = True
+
+ resolved = ModelRouter(settings).resolve("open_router/anthropic/claude-opus-4")
+
+ assert resolved.provider_id == "open_router"
+ assert resolved.provider_model == "anthropic/claude-opus-4"
+ assert resolved.thinking_enabled is True
+
+
def test_model_router_routes_token_count_request(settings):
settings.model_haiku = "lmstudio/qwen2.5-7b"
diff --git a/tests/cli/test_cli_ownership.py b/tests/cli/test_cli_ownership.py
index 7d16876d..3c837244 100644
--- a/tests/cli/test_cli_ownership.py
+++ b/tests/cli/test_cli_ownership.py
@@ -19,11 +19,3 @@ def test_cli_session_owns_typed_runner_config(tmp_path: Path) -> None:
assert session.config.allowed_dirs == [str(tmp_path)]
assert session.config.plans_directory == ".plans"
assert session.config.claude_bin == "claude-test"
-
-
-def test_claude_pick_uses_project_python_runner() -> None:
- script = Path(__file__).resolve().parents[2] / "claude-pick"
- text = script.read_text(encoding="utf-8")
-
- assert "uv run python" in text
- assert "python3 -c" not in text
diff --git a/tests/providers/test_model_validation.py b/tests/providers/test_model_validation.py
index c4e2af38..6b714156 100644
--- a/tests/providers/test_model_validation.py
+++ b/tests/providers/test_model_validation.py
@@ -26,12 +26,18 @@ def _settings(
model_opus: str | None = None,
model_sonnet: str | None = None,
model_haiku: str | None = None,
+ nvidia_nim_api_key: str = "",
+ open_router_api_key: str = "",
+ deepseek_api_key: str = "",
) -> Settings:
return Settings.model_construct(
model=model,
model_opus=model_opus,
model_sonnet=model_sonnet,
model_haiku=model_haiku,
+ nvidia_nim_api_key=nvidia_nim_api_key,
+ open_router_api_key=open_router_api_key,
+ deepseek_api_key=deepseek_api_key,
log_api_error_tracebacks=False,
)
@@ -204,6 +210,11 @@ async def test_registry_validation_succeeds_for_all_configured_models() -> None:
await registry.validate_configured_models(settings)
+ assert registry.cached_model_ids() == {
+ "nvidia_nim": frozenset({"nim-model"}),
+ "open_router": frozenset({"anthropic/claude-opus"}),
+ }
+
@pytest.mark.asyncio
async def test_registry_validation_reports_missing_model_with_sources() -> None:
@@ -267,3 +278,55 @@ async def test_registry_validation_queries_providers_concurrently() -> None:
settings = _settings(model_opus="open_router/anthropic/claude-opus")
await asyncio.wait_for(registry.validate_configured_models(settings), timeout=1.0)
+
+
+async def test_registry_refresh_model_list_cache_uses_configured_remote_keys_and_referenced_local() -> (
+ None
+):
+ registry = ProviderRegistry(
+ {
+ "open_router": FakeProvider(frozenset({"anthropic/claude-sonnet"})),
+ "lmstudio": FakeProvider(frozenset({"local-qwen"})),
+ "ollama": FakeProvider(frozenset({"llama3.1"})),
+ }
+ )
+ settings = _settings(
+ model="lmstudio/local-qwen",
+ open_router_api_key="open-router-key",
+ )
+
+ await registry.refresh_model_list_cache(settings)
+
+ assert registry.cached_model_ids() == {
+ "open_router": frozenset({"anthropic/claude-sonnet"}),
+ "lmstudio": frozenset({"local-qwen"}),
+ }
+
+
+async def test_registry_refresh_model_list_cache_keeps_prior_cache_on_failure() -> None:
+ registry = ProviderRegistry(
+ {"nvidia_nim": FakeProvider(error=RuntimeError("upstream down"))}
+ )
+ registry.cache_model_ids("nvidia_nim", {"cached-model"})
+ settings = _settings(
+ model="nvidia_nim/cached-model",
+ nvidia_nim_api_key="nim-key",
+ )
+
+ await registry.refresh_model_list_cache(settings)
+
+ assert registry.cached_model_ids() == {"nvidia_nim": frozenset({"cached-model"})}
+
+
+def test_registry_cached_prefixed_model_refs_are_deterministic() -> None:
+ registry = ProviderRegistry()
+ registry.cache_model_ids("deepseek", {"deepseek-chat"})
+ registry.cache_model_ids("open_router", {"z-model", "a-model"})
+
+ assert registry.cached_prefixed_model_refs() == (
+ "open_router/a-model",
+ "open_router/z-model",
+ "deepseek/deepseek-chat",
+ )