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.mdindex 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 Integrationsdiff --git a/api/model_router.py b/api/model_router.pyindex f49d1065..c36a4002 100644--- a/api/model_router.py+++ b/api/model_router.py@@ -6,10 +6,13 @@ from dataclasses import dataclassfrom loguru import logger+from config.provider_ids import SUPPORTED_PROVIDER_IDSfrom config.settings import Settingsfrom .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 = settingsdef 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.pyindex 39e98371..fe72b010 100644--- a/api/routes.py+++ b/api/routes.py@@ -5,6 +5,7 @@ from loguru import loggerfrom config.settings import Settingsfrom core.anthropic import get_token_count+from providers.registry import ProviderRegistryfrom . import dependenciesfrom .dependencies import get_settings, require_api_key@@ -14,6 +15,9 @@ from .services import ClaudeProxyServicerouter = 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.pyindex 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.pngnew file mode 100644index 00000000..07338133Binary files /dev/null and b/cc-model-picker.png differdiff --git a/claude-pick b/claude-pickdeleted file mode 100755index 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.pyindex 59759946..de4e83ae 100644--- a/providers/registry.py+++ b/providers/registry.py@@ -4,7 +4,8 @@ from __future__ import annotationsimport asynciofrom collections import defaultdict-from collections.abc import Callable, MutableMapping+from collections.abc import Callable, Iterable, MutableMapping+from contextlib import suppressimport httpxfrom 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 = Nonedef 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-raisedas-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.pyindex 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_clientdiff --git a/tests/api/test_model_listing.py b/tests/api/test_model_listing.pynew file mode 100644index 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 idsdiff --git a/tests/api/test_model_router.py b/tests/api/test_model_router.pyindex 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.pyindex 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 textdiff --git a/tests/providers/test_model_validation.py b/tests/providers/test_model_validation.pyindex 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.asyncioasync 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",+ )