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
Switch LM Studio to the OpenAI chat transport; add context-budget preflight (fixes silent tool-call text leaks and mid-stream truncation) (#979)
jankeydadondc-byte2d265c82eec5
diff --git a/config/provider_catalog.py b/config/provider_catalog.pyindex f3f68729..c4eb23f8 100644--- a/config/provider_catalog.py+++ b/config/provider_catalog.py@@ -267,12 +267,12 @@ PROVIDER_CATALOG: dict[str, ProviderDescriptor] = {"lmstudio": ProviderDescriptor(provider_id="lmstudio",display_name="LM Studio",- transport_type="anthropic_messages",+ transport_type="openai_chat",static_credential="lm-studio",default_base_url=LMSTUDIO_DEFAULT_BASE,base_url_attr="lm_studio_base_url",proxy_attr="lmstudio_proxy",- capabilities=("chat", "streaming", "tools", "native_anthropic", "local"),+ capabilities=("chat", "streaming", "tools", "local"),),"llamacpp": ProviderDescriptor(provider_id="llamacpp",diff --git a/providers/lmstudio/__init__.py b/providers/lmstudio/__init__.pyindex dbcd0f9e..2674a9c8 100644--- a/providers/lmstudio/__init__.py+++ b/providers/lmstudio/__init__.py@@ -1,4 +1,4 @@-"""LM Studio provider - Anthropic-compatible local API."""+"""LM Studio provider - OpenAI-compatible chat completions API."""from .client import LMStudioProviderdiff --git a/providers/lmstudio/client.py b/providers/lmstudio/client.pyindex 4e5bda0e..2291b8f4 100644--- a/providers/lmstudio/client.py+++ b/providers/lmstudio/client.py@@ -1,16 +1,122 @@-"""LM Studio provider implementation."""+"""LM Studio provider implementation (OpenAI-compatible chat completions).+Switched from LM Studio's native Anthropic Messages endpoint (2026-07-04):+the newer ``/v1/messages`` path renders Claude Code conversations through the+model's jinja chat template with strict role-alternation rules and a fragile+``[TOOL_CALLS]`` parser — observed leaking control tokens into tool names+(``[TOOL_CALLS]Read``) and dumping whole tool calls into text+(``Read[ARGS]{...}``), which ends agent runs silently. The OpenAI+``/v1/chat/completions`` path is LM Studio's mature parsing route, and fcc's+OpenAI transport layers its own tool-call assembly, think-tag parsing, and+heuristic recovery on top.+"""++import time+from typing import Any++import httpx+from loguru import logger++from core.anthropic import (+ ReasoningReplayMode,+ build_base_request_body,+ get_token_count,+)+from core.anthropic.conversion import OpenAIConversionErrorfrom providers.base import ProviderConfigfrom providers.defaults import LMSTUDIO_DEFAULT_BASE-from providers.transports.anthropic_messages import AnthropicMessagesTransport+from providers.exceptions import InvalidRequestError+from providers.transports.openai_chat import OpenAIChatTransport-class LMStudioProvider(AnthropicMessagesTransport):- """LM Studio provider using native Anthropic Messages endpoint."""+class LMStudioProvider(OpenAIChatTransport):+ """LM Studio via its OpenAI-compatible chat completions endpoint."""++ # LM Studio truncates the stream silently (no terminal event) when the+ # prompt exceeds the loaded context. Refuse clearly over-budget prompts+ # up front with the same "prompt is too long" invalid_request_error the+ # real Anthropic API uses, so Claude Code can compact/retry instead of+ # dying mid-stream.+ _CONTEXT_CACHE_TTL_S = 30.0def __init__(self, config: ProviderConfig):super().__init__(config,provider_name="LMSTUDIO",- default_base_url=LMSTUDIO_DEFAULT_BASE,+ base_url=config.base_url or LMSTUDIO_DEFAULT_BASE,+ api_key=config.api_key or "lm-studio",)+ self._loaded_context_cache: tuple[float, int | None] = (0.0, None)++ def _build_request_body(+ self, request: Any, thinking_enabled: bool | None = None+ ) -> dict:+ """Build an OpenAI chat body from the Anthropic request.++ Prior-turn thinking is never replayed: Mistral-family templates have+ no assistant reasoning field, and replaying ``<think>`` text inflates+ the local context for no benefit. New-response thinking still streams+ back via ``reasoning_content``/``<think>`` parsing in the transport.+ """+ try:+ return build_base_request_body(+ request,+ reasoning_replay=ReasoningReplayMode.DISABLED,+ )+ except OpenAIConversionError as exc:+ raise InvalidRequestError(str(exc)) from exc++ def preflight_stream(+ self, request: Any, *, thinking_enabled: bool | None = None+ ) -> None:+ super().preflight_stream(request, thinking_enabled=thinking_enabled)+ self._preflight_context_budget(request)++ def _preflight_context_budget(self, request: Any) -> None:+ loaded_context = self._loaded_context_length()+ if loaded_context is None:+ return+ estimate = get_token_count(+ getattr(request, "messages", []) or [],+ getattr(request, "system", None),+ getattr(request, "tools", None),+ )+ # The estimate is cl100k-based and undercounts local tokenizers+ # (observed ~8% low vs devstral); a request above 90% of the loaded+ # context is already past where client-side compaction should have+ # fired, and letting it through risks a silent LM Studio truncation.+ budget = int(loaded_context * 0.9)+ if estimate > budget:+ raise InvalidRequestError(+ f"prompt is too long: {estimate} tokens > {budget} "+ f"maximum (90% of loaded LM Studio context {loaded_context})"+ )++ def _loaded_context_length(self) -> int | None:+ """Best-effort loaded context length from LM Studio's REST API, cached."""+ cached_at, cached_value = self._loaded_context_cache+ if time.monotonic() - cached_at < self._CONTEXT_CACHE_TTL_S:+ return cached_value++ value: int | None = None+ try:+ root = self._base_url+ root = root[: -len("/v1")] if root.endswith("/v1") else root+ response = httpx.get(f"{root}/api/v0/models", timeout=2.0)+ response.raise_for_status()+ loaded = [+ model.get("loaded_context_length")+ for model in response.json().get("data", [])+ if model.get("state") == "loaded"+ and isinstance(model.get("loaded_context_length"), int)+ ]+ # ponytail: single-model setups in practice; with several loaded+ # models the most generous ceiling still makes a valid backstop.+ value = max(loaded) if loaded else None+ except Exception as error: # backstop only — never block the request+ logger.debug(+ "LMSTUDIO context preflight unavailable: {}", type(error).__name__+ )+ value = None+ self._loaded_context_cache = (time.monotonic(), value)+ return valuediff --git a/pyproject.toml b/pyproject.tomlindex 211c59d1..ecbbc8a7 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "2.5.0"+version = "2.5.1"description = "Middleware between Claude Code CLI (Anthropic API) and NVIDIA NIM"readme = "README.md"requires-python = ">=3.14.0"diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex 6749bb16..4c01a8b6 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -1,15 +1,15 @@-"""Tests for LM Studio native Anthropic provider."""+"""Tests for LM Studio (OpenAI-compatible chat completions) provider."""+from contextlib import asynccontextmanagerfrom unittest.mock import AsyncMock, MagicMock, patchimport httpximport pytest-from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS-from core.anthropic.stream_contracts import parse_sse_textfrom providers.base import ProviderConfig+from providers.exceptions import InvalidRequestErrorfrom providers.lmstudio import LMStudioProvider-from tests.stream_contract import assert_canonical_stream_error_envelope+from providers.lmstudio.client import LMSTUDIO_DEFAULT_BASEclass MockMessage:@@ -28,28 +28,17 @@ class MockRequest:self.system = "System prompt"self.stop_sequences = Noneself.tools = []- self.extra_body = {}self.thinking = MagicMock()self.thinking.enabled = True- for k, v in kwargs.items():- setattr(self, k, v)-- def model_dump(self, exclude_none=True):- return {- "model": self.model,- "messages": [{"role": m.role, "content": m.content} for m in self.messages],- "max_tokens": self.max_tokens,- "temperature": self.temperature,- "extra_body": self.extra_body,- "thinking": {"enabled": self.thinking.enabled} if self.thinking else None,- }+ for key, value in kwargs.items():+ setattr(self, key, value)@pytest.fixturedef lmstudio_config():return ProviderConfig(api_key="lm-studio",- base_url="http://localhost:1234/v1",+ base_url=LMSTUDIO_DEFAULT_BASE,rate_limit=10,rate_window=60,)@@ -58,16 +47,19 @@ def lmstudio_config():@pytest.fixture(autouse=True)def mock_rate_limiter():"""Mock the global rate limiter to prevent waiting."""- with patch(- "providers.transports.anthropic_messages.transport.GlobalRateLimiter"- ) as mock:++ @asynccontextmanager+ async def _slot():+ yield++ with patch("providers.transports.openai_chat.transport.GlobalRateLimiter") as mock:instance = mock.get_scoped_instance.return_value- instance.wait_if_blocked = AsyncMock(return_value=False)async def _passthrough(fn, *args, **kwargs):return await fn(*args, **kwargs)instance.execute_with_retry = AsyncMock(side_effect=_passthrough)+ instance.concurrency_slot.side_effect = _slotyield instance@@ -78,337 +70,151 @@ def lmstudio_provider(lmstudio_config):def test_init(lmstudio_config):"""Test provider initialization."""- with patch("httpx.AsyncClient"):+ with patch("providers.transports.openai_chat.transport.AsyncOpenAI") as mock_openai:provider = LMStudioProvider(lmstudio_config)- assert provider._base_url == "http://localhost:1234/v1"+ assert provider._api_key == "lm-studio"+ assert provider._base_url == LMSTUDIO_DEFAULT_BASEassert provider._provider_name == "LMSTUDIO"+ mock_openai.assert_called_once()-def test_init_uses_configurable_timeouts():- """Test that provider passes configurable read/write/connect timeouts to client."""- config = ProviderConfig(- api_key="lm-studio",- base_url="http://localhost:1234/v1",- http_read_timeout=600.0,- http_write_timeout=15.0,- http_connect_timeout=5.0,- )- with patch("httpx.AsyncClient") as mock_client:- LMStudioProvider(config)- call_kwargs = mock_client.call_args[1]- timeout = call_kwargs["timeout"]- assert timeout.read == 600.0- assert timeout.write == 15.0- assert timeout.connect == 5.0---def test_init_base_url_strips_trailing_slash():- """Config with base_url trailing slash is stored without it."""- config = ProviderConfig(- api_key="lm-studio",- base_url="http://localhost:1234/v1/",- rate_limit=10,- rate_window=60,- )- with patch("httpx.AsyncClient"):- provider = LMStudioProvider(config)- assert provider._base_url == "http://localhost:1234/v1"+def test_default_base_url_constant():+ assert LMSTUDIO_DEFAULT_BASE == "http://localhost:1234/v1"-async def test_stream_response_omits_thinking_when_globally_disabled(lmstudio_config):- provider = LMStudioProvider(- lmstudio_config.model_copy(update={"enable_thinking": False})- )+def test_build_request_body_basic(lmstudio_provider):req = MockRequest()+ body = lmstudio_provider._build_request_body(req)- mock_response = MagicMock()- mock_response.status_code = 200+ assert body["model"] == "lmstudio-community/qwen2.5-7b-instruct"+ assert body["messages"][0]["role"] == "system"- async def empty_aiter():- if False:- yield ""- mock_response.aiter_lines = empty_aiter-- with (- patch.object(provider._client, "build_request") as mock_build,- patch.object(- provider._client,- "send",- new_callable=AsyncMock,- return_value=mock_response,- ),- ):- [e async for e in provider.stream_response(req)]+def test_build_request_body_never_replays_prior_thinking(lmstudio_provider):+ """Mistral-family templates have no assistant reasoning field; prior-turn+ thinking must never be replayed regardless of the enable_thinking setting."""+ req = MockRequest(+ messages=[+ MockMessage("user", "hi"),+ MockMessage(+ "assistant",+ [{"type": "thinking", "thinking": "prior reasoning", "signature": "s"}],+ ),+ ]+ )+ body = lmstudio_provider._build_request_body(req)- _, kwargs = mock_build.call_args- assert "thinking" not in kwargs["json"]+ roles = [m.get("role") for m in body.get("messages", [])]+ assert "assistant_reasoning_content" not in roles+ assert "prior reasoning" not in str(body)@pytest.mark.asyncio-async def test_stream_response_omits_thinking_when_request_disables_it(- lmstudio_provider,-):+async def test_stream_response_text(lmstudio_provider):+ """Text content deltas are emitted as text blocks (via the OpenAI chat transport)."""req = MockRequest()- req.thinking.enabled = False- mock_response = MagicMock()- mock_response.status_code = 200+ mock_chunk = MagicMock()+ mock_chunk.choices = [+ MagicMock(+ delta=MagicMock(+ content="Hello back!", reasoning_content=None, tool_calls=None+ ),+ finish_reason="stop",+ )+ ]+ mock_chunk.usage = MagicMock(completion_tokens=5, prompt_tokens=10)- async def empty_aiter():- if False:- yield ""+ async def mock_stream():+ yield mock_chunk- mock_response.aiter_lines = empty_aiter+ with patch.object(+ lmstudio_provider._client.chat.completions, "create", new_callable=AsyncMock+ ) as mock_create:+ mock_create.return_value = mock_stream()- with (- patch.object(lmstudio_provider._client, "build_request") as mock_build,- patch.object(- lmstudio_provider._client,- "send",- new_callable=AsyncMock,- return_value=mock_response,- ),- ):- [e async for e in lmstudio_provider.stream_response(req)]+ events = [event async for event in lmstudio_provider.stream_response(req)]- _, kwargs = mock_build.call_args- assert "thinking" not in kwargs["json"]+ assert any(+ '"text_delta"' in event and "Hello back!" in event for event in events+ )@pytest.mark.asyncio-async def test_stream_response(lmstudio_provider):- """Test streaming native Anthropic response."""- req = MockRequest()+async def test_cleanup(lmstudio_provider):+ lmstudio_provider._client = AsyncMock()+ await lmstudio_provider.cleanup()- mock_response = MagicMock()- mock_response.status_code = 200- async def mock_aiter_lines():- yield "event: message_start"- yield 'data: {"type":"message_start","message":{}}'- yield ""- yield "event: content_block_delta"- yield 'data: {"type":"content_block_delta","delta":{"type":"text_delta","text":"Hello World"}}'- yield ""- yield "event: message_stop"- yield 'data: {"type":"message_stop"}'- yield ""+# --- Context-budget preflight (new: guards against LM Studio's silent+# mid-stream truncation when a prompt exceeds the loaded model's context) ---- mock_response.aiter_lines = mock_aiter_lines- with (- patch.object(- lmstudio_provider._client, "build_request", return_value=MagicMock()- ) as mock_build,- patch.object(- lmstudio_provider._client,- "send",- new_callable=AsyncMock,- return_value=mock_response,- ),- ):- events = [e async for e in lmstudio_provider.stream_response(req)]-- # Verify request construction- mock_build.assert_called_once()- args, kwargs = mock_build.call_args- assert args[0] == "POST"- assert args[1] == "/messages"- assert kwargs["json"]["model"] == "lmstudio-community/qwen2.5-7b-instruct"- # Verify internal fields are popped- assert "extra_body" not in kwargs["json"]- assert kwargs["json"]["max_tokens"] == 100-- # Verify internal ThinkingConfig is mapped to Anthropic API format- assert kwargs["json"]["thinking"] == {"type": "enabled"}-- assert [event.event for event in parse_sse_text("".join(events))] == [- "message_start",- "content_block_delta",- "message_stop",- ]- assert "Hello World" in "".join(events)+def test_preflight_context_budget_noop_when_context_length_unknown(lmstudio_provider):+ """No LM Studio /api/v0/models data available -> preflight is a no-op (fail open)."""+ with patch.object(lmstudio_provider, "_loaded_context_length", return_value=None):+ lmstudio_provider._preflight_context_budget(MockRequest()) # must not raise-async def test_stream_response_adds_max_tokens_if_missing(lmstudio_provider):- """Fallback max_tokens to 81920 if not present."""- req = MockRequest()- mock_response = MagicMock()- mock_response.status_code = 200-- async def empty_aiter():- if False:- yield ""-- mock_response.aiter_lines = empty_aiter-- with (- patch.object(req, "model_dump", return_value={"model": "test"}),- patch.object(lmstudio_provider._client, "build_request") as mock_build,- patch.object(- lmstudio_provider._client,- "send",- new_callable=AsyncMock,- return_value=mock_response,- ),+def test_preflight_context_budget_allows_request_under_budget(lmstudio_provider):+ with patch.object(+ lmstudio_provider, "_loaded_context_length", return_value=100_000):- # Just run the generator to completion- [e async for e in lmstudio_provider.stream_response(req)]-- _, kwargs = mock_build.call_args- assert kwargs["json"]["max_tokens"] == ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS---async def test_stream_error_status_code(lmstudio_provider):- """Non-200 status code raises an error that gets caught and yielded as an SSE API error."""- req = MockRequest()+ req = MockRequest(messages=[MockMessage("user", "hi")], system=None, tools=[])+ lmstudio_provider._preflight_context_budget(req) # must not raise- mock_response = MagicMock()- mock_response.status_code = 500- mock_response.aread = AsyncMock(return_value=b"Internal Server Error")- mock_response.raise_for_status = MagicMock(- side_effect=httpx.HTTPStatusError(- "Internal Server Error", request=MagicMock(), response=mock_response- )- )+def test_preflight_context_budget_rejects_request_over_90_percent(lmstudio_provider):with (- patch.object(- lmstudio_provider._client, "build_request", return_value=MagicMock()- ),- patch.object(- lmstudio_provider._client,- "send",- new_callable=AsyncMock,- return_value=mock_response,+ patch.object(lmstudio_provider, "_loaded_context_length", return_value=1000),+ patch(+ "providers.lmstudio.client.get_token_count",+ return_value=901,),+ pytest.raises(InvalidRequestError, match="prompt is too long"),):- events = [- e- async for e in lmstudio_provider.stream_response(req, request_id="TEST_ID")- ]-- assert_canonical_stream_error_envelope(- events, user_message_substr="Provider API request failed"- )- assert "TEST_ID" in "".join(events)-+ lmstudio_provider._preflight_context_budget(MockRequest())-async def test_stream_network_error(lmstudio_provider):- """Network errors are caught and yielded as SSE API error events."""- req = MockRequest()- with (- patch.object(- lmstudio_provider._client, "build_request", return_value=MagicMock()- ),- patch.object(- lmstudio_provider._client,- "send",- new_callable=AsyncMock,- side_effect=httpx.ConnectError("Connection refused"),- ),- ):- events = [- e- async for e in lmstudio_provider.stream_response(req, request_id="TEST_ID2")+def test_loaded_context_length_reads_max_across_loaded_models(lmstudio_provider):+ response = MagicMock()+ response.raise_for_status = MagicMock()+ response.json.return_value = {+ "data": [+ {"state": "loaded", "loaded_context_length": 40960},+ {"state": "loaded", "loaded_context_length": 8192},+ {"state": "not-loaded", "loaded_context_length": 999999},]+ }+ with patch(+ "providers.lmstudio.client.httpx.get", return_value=response+ ) as mock_get:+ value = lmstudio_provider._loaded_context_length()- blob = "".join(events)- assert_canonical_stream_error_envelope(- events, user_message_substr="Connection refused"- )- assert "TEST_ID2" in blob+ assert value == 40960+ mock_get.assert_called_once()+ assert mock_get.call_args[0][0] == "http://localhost:1234/api/v0/models"-async def test_stream_error_405_mentions_upstream_provider(lmstudio_provider):- req = MockRequest()-- mock_response = MagicMock()- mock_response.status_code = 405- mock_response.aread = AsyncMock(return_value=b"Method Not Allowed")- mock_response.raise_for_status = MagicMock(- side_effect=httpx.HTTPStatusError(- "Method Not Allowed", request=MagicMock(), response=mock_response- )- )-- with (- patch.object(- lmstudio_provider._client, "build_request", return_value=MagicMock()- ),- patch.object(- lmstudio_provider._client,- "send",- new_callable=AsyncMock,- return_value=mock_response,- ),+def test_loaded_context_length_fails_open_on_error(lmstudio_provider):+ with patch(+ "providers.lmstudio.client.httpx.get",+ side_effect=httpx.ConnectError("refused"),):- events = [- e async for e in lmstudio_provider.stream_response(req, request_id="REQ405")- ]-- blob = "".join(events)- assert (- "Upstream provider LMSTUDIO rejected the request method or endpoint (HTTP 405)."- in blob- )- assert "REQ405" in blob+ assert lmstudio_provider._loaded_context_length() is None-def test_build_request_body_disabled_thinking_strips_native_thinking_history(- lmstudio_config,-):- """Disabled thinking must omit prior assistant thinking/redacted blocks in JSON."""- provider = LMStudioProvider(- lmstudio_config.model_copy(update={"enable_thinking": False})- )- req = MockRequest(- system=None,- messages=[- MockMessage("user", "hi"),- MockMessage(- "assistant",- [- {"type": "thinking", "thinking": "t"},- {"type": "redacted_thinking", "data": "opaque"},- ],- ),- ],- )- body = provider._build_request_body(req, thinking_enabled=False)- assert body["messages"][1]["content"] == ""- assert "redacted_thinking" not in str(body)-+def test_loaded_context_length_is_cached_within_ttl(lmstudio_provider):+ response = MagicMock()+ response.raise_for_status = MagicMock()+ response.json.return_value = {+ "data": [{"state": "loaded", "loaded_context_length": 40960}]+ }+ with patch(+ "providers.lmstudio.client.httpx.get", return_value=response+ ) as mock_get:+ first = lmstudio_provider._loaded_context_length()+ second = lmstudio_provider._loaded_context_length()-def test_build_request_body_preserves_signed_thinking_native_history(lmstudio_config):- """When thinking is enabled, signed thinking blocks are kept; unsigned stripped."""- provider = LMStudioProvider(lmstudio_config)- req = MockRequest(- system=None,- messages=[- MockMessage("user", "hi"),- MockMessage(- "assistant",- [- {- "type": "thinking",- "thinking": "signed",- "signature": "sig",- },- {"type": "redacted_thinking", "data": "opaque"},- ],- ),- ],- )- body = provider._build_request_body(req, thinking_enabled=True)- c = body["messages"][1]["content"]- assert isinstance(c, list)- assert any(isinstance(b, dict) and b.get("type") == "thinking" for b in c)- assert any(isinstance(b, dict) and b.get("type") == "redacted_thinking" for b in c)+ assert first == second == 40960+ mock_get.assert_called_once()diff --git a/tests/providers/test_model_validation.py b/tests/providers/test_model_validation.pyindex 36f2748c..c4d51a3a 100644--- a/tests/providers/test_model_validation.py+++ b/tests/providers/test_model_validation.py@@ -1,523 +1,523 @@-from __future__ import annotations--import asyncio-from collections.abc import AsyncIterator-from types import SimpleNamespace-from typing import Any-from unittest.mock import AsyncMock, patch--import httpx-import pytest--from config.nim import NimSettings-from config.settings import Settings-from providers.base import BaseProvider, ProviderConfig-from providers.deepseek import DeepSeekProvider-from providers.exceptions import ModelListResponseError, ServiceUnavailableError-from providers.lmstudio import LMStudioProvider-from providers.model_listing import ProviderModelInfo-from providers.nvidia_nim import NvidiaNimProvider-from providers.ollama import OllamaProvider-from providers.open_router import OpenRouterProvider-from providers.runtime import ProviderRuntime-from providers.wafer import WaferProvider---def _settings(- *,- model: str = "nvidia_nim/nim-model",- 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 = "",- wafer_api_key: str = "",- opencode_api_key: str = "",- zai_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,- wafer_api_key=wafer_api_key,- opencode_api_key=opencode_api_key,- zai_api_key=zai_api_key,- log_api_error_tracebacks=False,- )---def _response(status_code: int, payload: object) -> httpx.Response:- return httpx.Response(- status_code,- json=payload,- request=httpx.Request("GET", "https://example.test/models"),- )---async def test_nim_lists_openai_compatible_model_ids() -> None:- config = ProviderConfig(api_key="test-key")- with patch("providers.transports.openai_chat.transport.AsyncOpenAI"):- provider = NvidiaNimProvider(config, nim_settings=NimSettings())-- with patch.object(- provider._client.models,- "list",- new_callable=AsyncMock,- return_value=SimpleNamespace(data=[SimpleNamespace(id="nvidia/model")]),- ):- assert await provider.list_model_ids() == frozenset({"nvidia/model"})---async def test_native_openai_compatible_provider_lists_model_ids() -> None:- provider = LMStudioProvider(- ProviderConfig(api_key="lm-studio", base_url="http://localhost:1234/v1")- )- with patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(200, {"data": [{"id": "local/model"}]}),- ) as mock_get:- assert await provider.list_model_ids() == frozenset({"local/model"})-- mock_get.assert_awaited_once_with("/models", headers={})---async def test_deepseek_lists_models_from_root_endpoint() -> None:- provider = DeepSeekProvider(ProviderConfig(api_key="deepseek-key"))- with patch.object(- provider._client.models,- "list",- new_callable=AsyncMock,- return_value=SimpleNamespace(data=[SimpleNamespace(id="deepseek-chat")]),- ) as mock_list:- assert await provider.list_model_ids() == frozenset({"deepseek-chat"})-- mock_list.assert_awaited_once_with()---async def test_wafer_lists_models_from_default_models_endpoint() -> None:- provider = WaferProvider(ProviderConfig(api_key="wafer-key"))- with patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(200, {"data": [{"id": "DeepSeek-V4-Pro"}]}),- ) as mock_get:- assert await provider.list_model_ids() == frozenset({"DeepSeek-V4-Pro"})-- mock_get.assert_awaited_once_with(- "/models", headers={"Authorization": "Bearer wafer-key"}- )---async def test_openrouter_lists_only_tool_capable_models() -> None:- provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))- with patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(- 200,- {- "data": [- {- "id": "tool-model",- "supported_parameters": ["tools", "max_tokens"],- },- {- "id": "tool-choice-model",- "supported_parameters": ["tool_choice"],- },- {- "id": "chat-only",- "supported_parameters": ["max_tokens", "temperature"],- },- {"id": "missing-metadata"},- ]- },- ),- ) as mock_get:- assert await provider.list_model_ids() == frozenset(- {"tool-model", "tool-choice-model"}- )-- mock_get.assert_awaited_once_with(- "/models", headers={"Authorization": "Bearer open-router-key"}- )---async def test_openrouter_lists_tool_metadata_with_thinking_support() -> None:- provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))- with patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(- 200,- {- "data": [- {- "id": "reasoning-tool-model",- "supported_parameters": [- "tools",- "reasoning",- "include_reasoning",- ],- },- {- "id": "plain-tool-model",- "supported_parameters": ["tool_choice", "include_reasoning"],- },- {- "id": "chat-only",- "supported_parameters": ["reasoning", "max_tokens"],- },- ]- },- ),- ):- infos = await provider.list_model_infos()-- assert infos == frozenset(- {- ProviderModelInfo("reasoning-tool-model", supports_thinking=True),- ProviderModelInfo("plain-tool-model", supports_thinking=False),- }- )---async def test_openrouter_lists_empty_set_when_no_tool_capable_models() -> None:- provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))- with patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(- 200,- {- "data": [- {"id": "chat-only", "supported_parameters": ["max_tokens"]},- {"id": "missing-metadata"},- ]- },- ),- ):- assert await provider.list_model_ids() == frozenset()---async def test_openrouter_model_metadata_rejects_malformed_ids() -> None:- provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))- with (- patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(- 200,- {"data": [{"supported_parameters": ["tools", "reasoning"]}]},- ),- ),- pytest.raises(ModelListResponseError, match="malformed"),- ):- await provider.list_model_infos()---async def test_ollama_lists_native_tag_model_ids() -> None:- provider = OllamaProvider(- ProviderConfig(api_key="ollama", base_url="http://localhost:11434")- )- with patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(- 200,- {- "models": [- {"name": "llama3.1:latest", "model": "llama3.1:latest"},- {"name": "qwen3"},- ]- },- ),- ) as mock_get:- assert await provider.list_model_ids() == frozenset(- {"llama3.1:latest", "qwen3"}- )-- mock_get.assert_awaited_once_with("http://localhost:11434/api/tags")---async def test_model_listing_rejects_malformed_payload() -> None:- provider = LMStudioProvider(- ProviderConfig(api_key="lm-studio", base_url="http://localhost:1234/v1")- )- with (- patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(200, {"data": [{}]}),- ),- pytest.raises(ModelListResponseError, match="malformed"),- ):- await provider.list_model_ids()---async def test_model_listing_raises_http_status_errors() -> None:- provider = LMStudioProvider(- ProviderConfig(api_key="lm-studio", base_url="http://localhost:1234/v1")- )- with (- patch.object(- provider._client,- "get",- new_callable=AsyncMock,- return_value=_response(503, {"error": "down"}),- ),- pytest.raises(httpx.HTTPStatusError),- ):- await provider.list_model_ids()---class FakeProvider(BaseProvider):- def __init__(- self,- model_ids: frozenset[str] | None = None,- *,- model_infos: frozenset[ProviderModelInfo] | None = None,- error: BaseException | None = None,- started: asyncio.Event | None = None,- peer_started: asyncio.Event | None = None,- ):- super().__init__(ProviderConfig(api_key="test"))- self._model_ids = model_ids or frozenset()- self._model_infos = model_infos- self._error = error- self._started = started- self._peer_started = peer_started- self.cleaned = False-- async def cleanup(self) -> None:- self.cleaned = True-- async def _before_model_list(self) -> None:- if self._started is not None:- self._started.set()- if self._peer_started is not None:- await self._peer_started.wait()- if self._error is not None:- raise self._error-- async def list_model_ids(self) -> frozenset[str]:- await self._before_model_list()- if self._model_infos is not None:- return frozenset(info.model_id for info in self._model_infos)- return self._model_ids-- async def list_model_infos(self) -> frozenset[ProviderModelInfo]:- await self._before_model_list()- if self._model_infos is not None:- return self._model_infos- return frozenset(ProviderModelInfo(model_id) for model_id in self._model_ids)-- async def stream_response(- self,- request: Any,- input_tokens: int = 0,- *,- request_id: str | None = None,- thinking_enabled: bool | None = None,- ) -> AsyncIterator[str]:- if False:- yield ""---async def test_runtime_validation_succeeds_for_all_configured_models() -> None:- settings = _settings(model_opus="open_router/anthropic/claude-opus")- runtime = ProviderRuntime(- settings,- {- "nvidia_nim": FakeProvider(frozenset({"nim-model"})),- "open_router": FakeProvider(frozenset({"anthropic/claude-opus"})),- },- )-- await runtime.validate_configured_models()-- assert runtime.cached_model_ids() == {- "nvidia_nim": frozenset({"nim-model"}),- "open_router": frozenset({"anthropic/claude-opus"}),- }---async def test_runtime_validation_reports_missing_model_with_sources() -> None:- settings = _settings(model_sonnet="nvidia_nim/nim-model")- runtime = ProviderRuntime(- settings,- {"nvidia_nim": FakeProvider(frozenset({"different-model"}))},- )-- with pytest.raises(ServiceUnavailableError) as exc_info:- await runtime.validate_configured_models()-- message = exc_info.value.message- assert "sources=MODEL,MODEL_SONNET" in message- assert "provider=nvidia_nim" in message- assert "model=nim-model" in message- assert "problem=missing model" in message---async def test_runtime_validation_aggregates_multiple_failures() -> None:- settings = _settings(model_opus="open_router/anthropic/claude-opus")- runtime = ProviderRuntime(- settings,- {- "nvidia_nim": FakeProvider(frozenset({"different-model"})),- "open_router": FakeProvider(- error=ModelListResponseError("bad model-list shape")- ),- },- )-- with pytest.raises(ServiceUnavailableError) as exc_info:- await runtime.validate_configured_models()-- message = exc_info.value.message- assert "sources=MODEL provider=nvidia_nim model=nim-model" in message- assert "problem=missing model" in message- assert "sources=MODEL_OPUS provider=open_router model=anthropic/claude-opus" in (- message- )- assert "problem=malformed model-list response" in message---async def test_runtime_validation_queries_providers_concurrently() -> None:- nim_started = asyncio.Event()- router_started = asyncio.Event()- settings = _settings(model_opus="open_router/anthropic/claude-opus")- runtime = ProviderRuntime(- settings,- {- "nvidia_nim": FakeProvider(- frozenset({"nim-model"}),- started=nim_started,- peer_started=router_started,- ),- "open_router": FakeProvider(- frozenset({"anthropic/claude-opus"}),- started=router_started,- peer_started=nim_started,- ),- },- )-- await asyncio.wait_for(runtime.validate_configured_models(), timeout=1.0)---async def test_runtime_refresh_model_list_cache_uses_configured_remote_keys_and_referenced_local() -> (- None-):- settings = _settings(- model="lmstudio/local-qwen",- open_router_api_key="open-router-key",- )- runtime = ProviderRuntime(- settings,- {- "open_router": FakeProvider(frozenset({"anthropic/claude-sonnet"})),- "lmstudio": FakeProvider(frozenset({"local-qwen"})),- "ollama": FakeProvider(frozenset({"llama3.1"})),- },- )-- await runtime.refresh_model_list_cache()-- assert runtime.cached_model_ids() == {- "open_router": frozenset({"anthropic/claude-sonnet"}),- "lmstudio": frozenset({"local-qwen"}),- }---async def test_runtime_refresh_model_list_cache_keeps_prior_cache_on_failure() -> None:- settings = _settings(- model="nvidia_nim/cached-model",- nvidia_nim_api_key="nim-key",- )- runtime = ProviderRuntime(- settings,- {"nvidia_nim": FakeProvider(error=RuntimeError("upstream down"))},- )- runtime.cache_model_ids("nvidia_nim", {"cached-model"})-- await runtime.refresh_model_list_cache()-- assert runtime.cached_model_ids() == {"nvidia_nim": frozenset({"cached-model"})}---def test_runtime_metadata_cache_exposes_ids_and_prefixed_infos() -> None:- runtime = ProviderRuntime(_settings())- runtime.cache_model_infos(- "open_router",- {- ProviderModelInfo("reasoning-model", supports_thinking=True),- ProviderModelInfo("plain-model", supports_thinking=False),- },- )-- assert runtime.cached_model_ids() == {- "open_router": frozenset({"reasoning-model", "plain-model"})- }- assert (- runtime.cached_model_supports_thinking("open_router", "reasoning-model") is True- )- assert runtime.cached_model_supports_thinking("open_router", "plain-model") is False- assert runtime.cached_prefixed_model_infos() == (- ProviderModelInfo("open_router/plain-model", supports_thinking=False),- ProviderModelInfo("open_router/reasoning-model", supports_thinking=True),- )---def test_runtime_model_id_cache_keeps_unknown_thinking_support() -> None:- runtime = ProviderRuntime(_settings())- runtime.cache_model_ids("open_router", {"plain-model"})-- assert runtime.cached_model_ids() == {"open_router": frozenset({"plain-model"})}- assert runtime.cached_model_supports_thinking("open_router", "plain-model") is None- assert runtime.cached_prefixed_model_infos() == (- ProviderModelInfo("open_router/plain-model", supports_thinking=None),- )---def test_runtime_cached_prefixed_model_refs_are_deterministic() -> None:- runtime = ProviderRuntime(_settings())- runtime.cache_model_ids("deepseek", {"deepseek-chat"})- runtime.cache_model_ids("open_router", {"z-model", "a-model"})-- assert runtime.cached_prefixed_model_refs() == (- "open_router/a-model",- "open_router/z-model",- "deepseek/deepseek-chat",- )+from __future__ import annotations++import asyncio+from collections.abc import AsyncIterator+from types import SimpleNamespace+from typing import Any+from unittest.mock import AsyncMock, patch++import httpx+import pytest++from config.nim import NimSettings+from config.settings import Settings+from providers.base import BaseProvider, ProviderConfig+from providers.deepseek import DeepSeekProvider+from providers.exceptions import ModelListResponseError, ServiceUnavailableError+from providers.llamacpp import LlamaCppProvider+from providers.model_listing import ProviderModelInfo+from providers.nvidia_nim import NvidiaNimProvider+from providers.ollama import OllamaProvider+from providers.open_router import OpenRouterProvider+from providers.runtime import ProviderRuntime+from providers.wafer import WaferProvider+++def _settings(+ *,+ model: str = "nvidia_nim/nim-model",+ 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 = "",+ wafer_api_key: str = "",+ opencode_api_key: str = "",+ zai_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,+ wafer_api_key=wafer_api_key,+ opencode_api_key=opencode_api_key,+ zai_api_key=zai_api_key,+ log_api_error_tracebacks=False,+ )+++def _response(status_code: int, payload: object) -> httpx.Response:+ return httpx.Response(+ status_code,+ json=payload,+ request=httpx.Request("GET", "https://example.test/models"),+ )+++async def test_nim_lists_openai_compatible_model_ids() -> None:+ config = ProviderConfig(api_key="test-key")+ with patch("providers.transports.openai_chat.transport.AsyncOpenAI"):+ provider = NvidiaNimProvider(config, nim_settings=NimSettings())++ with patch.object(+ provider._client.models,+ "list",+ new_callable=AsyncMock,+ return_value=SimpleNamespace(data=[SimpleNamespace(id="nvidia/model")]),+ ):+ assert await provider.list_model_ids() == frozenset({"nvidia/model"})+++async def test_native_anthropic_messages_provider_lists_model_ids() -> None:+ provider = LlamaCppProvider(+ ProviderConfig(api_key="llamacpp", base_url="http://localhost:8080/v1")+ )+ with patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(200, {"data": [{"id": "local/model"}]}),+ ) as mock_get:+ assert await provider.list_model_ids() == frozenset({"local/model"})++ mock_get.assert_awaited_once_with("/models", headers={})+++async def test_deepseek_lists_models_from_root_endpoint() -> None:+ provider = DeepSeekProvider(ProviderConfig(api_key="deepseek-key"))+ with patch.object(+ provider._client.models,+ "list",+ new_callable=AsyncMock,+ return_value=SimpleNamespace(data=[SimpleNamespace(id="deepseek-chat")]),+ ) as mock_list:+ assert await provider.list_model_ids() == frozenset({"deepseek-chat"})++ mock_list.assert_awaited_once_with()+++async def test_wafer_lists_models_from_default_models_endpoint() -> None:+ provider = WaferProvider(ProviderConfig(api_key="wafer-key"))+ with patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(200, {"data": [{"id": "DeepSeek-V4-Pro"}]}),+ ) as mock_get:+ assert await provider.list_model_ids() == frozenset({"DeepSeek-V4-Pro"})++ mock_get.assert_awaited_once_with(+ "/models", headers={"Authorization": "Bearer wafer-key"}+ )+++async def test_openrouter_lists_only_tool_capable_models() -> None:+ provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))+ with patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(+ 200,+ {+ "data": [+ {+ "id": "tool-model",+ "supported_parameters": ["tools", "max_tokens"],+ },+ {+ "id": "tool-choice-model",+ "supported_parameters": ["tool_choice"],+ },+ {+ "id": "chat-only",+ "supported_parameters": ["max_tokens", "temperature"],+ },+ {"id": "missing-metadata"},+ ]+ },+ ),+ ) as mock_get:+ assert await provider.list_model_ids() == frozenset(+ {"tool-model", "tool-choice-model"}+ )++ mock_get.assert_awaited_once_with(+ "/models", headers={"Authorization": "Bearer open-router-key"}+ )+++async def test_openrouter_lists_tool_metadata_with_thinking_support() -> None:+ provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))+ with patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(+ 200,+ {+ "data": [+ {+ "id": "reasoning-tool-model",+ "supported_parameters": [+ "tools",+ "reasoning",+ "include_reasoning",+ ],+ },+ {+ "id": "plain-tool-model",+ "supported_parameters": ["tool_choice", "include_reasoning"],+ },+ {+ "id": "chat-only",+ "supported_parameters": ["reasoning", "max_tokens"],+ },+ ]+ },+ ),+ ):+ infos = await provider.list_model_infos()++ assert infos == frozenset(+ {+ ProviderModelInfo("reasoning-tool-model", supports_thinking=True),+ ProviderModelInfo("plain-tool-model", supports_thinking=False),+ }+ )+++async def test_openrouter_lists_empty_set_when_no_tool_capable_models() -> None:+ provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))+ with patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(+ 200,+ {+ "data": [+ {"id": "chat-only", "supported_parameters": ["max_tokens"]},+ {"id": "missing-metadata"},+ ]+ },+ ),+ ):+ assert await provider.list_model_ids() == frozenset()+++async def test_openrouter_model_metadata_rejects_malformed_ids() -> None:+ provider = OpenRouterProvider(ProviderConfig(api_key="open-router-key"))+ with (+ patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(+ 200,+ {"data": [{"supported_parameters": ["tools", "reasoning"]}]},+ ),+ ),+ pytest.raises(ModelListResponseError, match="malformed"),+ ):+ await provider.list_model_infos()+++async def test_ollama_lists_native_tag_model_ids() -> None:+ provider = OllamaProvider(+ ProviderConfig(api_key="ollama", base_url="http://localhost:11434")+ )+ with patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(+ 200,+ {+ "models": [+ {"name": "llama3.1:latest", "model": "llama3.1:latest"},+ {"name": "qwen3"},+ ]+ },+ ),+ ) as mock_get:+ assert await provider.list_model_ids() == frozenset(+ {"llama3.1:latest", "qwen3"}+ )++ mock_get.assert_awaited_once_with("http://localhost:11434/api/tags")+++async def test_model_listing_rejects_malformed_payload() -> None:+ provider = LlamaCppProvider(+ ProviderConfig(api_key="llamacpp", base_url="http://localhost:8080/v1")+ )+ with (+ patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(200, {"data": [{}]}),+ ),+ pytest.raises(ModelListResponseError, match="malformed"),+ ):+ await provider.list_model_ids()+++async def test_model_listing_raises_http_status_errors() -> None:+ provider = LlamaCppProvider(+ ProviderConfig(api_key="llamacpp", base_url="http://localhost:8080/v1")+ )+ with (+ patch.object(+ provider._client,+ "get",+ new_callable=AsyncMock,+ return_value=_response(503, {"error": "down"}),+ ),+ pytest.raises(httpx.HTTPStatusError),+ ):+ await provider.list_model_ids()+++class FakeProvider(BaseProvider):+ def __init__(+ self,+ model_ids: frozenset[str] | None = None,+ *,+ model_infos: frozenset[ProviderModelInfo] | None = None,+ error: BaseException | None = None,+ started: asyncio.Event | None = None,+ peer_started: asyncio.Event | None = None,+ ):+ super().__init__(ProviderConfig(api_key="test"))+ self._model_ids = model_ids or frozenset()+ self._model_infos = model_infos+ self._error = error+ self._started = started+ self._peer_started = peer_started+ self.cleaned = False++ async def cleanup(self) -> None:+ self.cleaned = True++ async def _before_model_list(self) -> None:+ if self._started is not None:+ self._started.set()+ if self._peer_started is not None:+ await self._peer_started.wait()+ if self._error is not None:+ raise self._error++ async def list_model_ids(self) -> frozenset[str]:+ await self._before_model_list()+ if self._model_infos is not None:+ return frozenset(info.model_id for info in self._model_infos)+ return self._model_ids++ async def list_model_infos(self) -> frozenset[ProviderModelInfo]:+ await self._before_model_list()+ if self._model_infos is not None:+ return self._model_infos+ return frozenset(ProviderModelInfo(model_id) for model_id in self._model_ids)++ async def stream_response(+ self,+ request: Any,+ input_tokens: int = 0,+ *,+ request_id: str | None = None,+ thinking_enabled: bool | None = None,+ ) -> AsyncIterator[str]:+ if False:+ yield ""+++async def test_runtime_validation_succeeds_for_all_configured_models() -> None:+ settings = _settings(model_opus="open_router/anthropic/claude-opus")+ runtime = ProviderRuntime(+ settings,+ {+ "nvidia_nim": FakeProvider(frozenset({"nim-model"})),+ "open_router": FakeProvider(frozenset({"anthropic/claude-opus"})),+ },+ )++ await runtime.validate_configured_models()++ assert runtime.cached_model_ids() == {+ "nvidia_nim": frozenset({"nim-model"}),+ "open_router": frozenset({"anthropic/claude-opus"}),+ }+++async def test_runtime_validation_reports_missing_model_with_sources() -> None:+ settings = _settings(model_sonnet="nvidia_nim/nim-model")+ runtime = ProviderRuntime(+ settings,+ {"nvidia_nim": FakeProvider(frozenset({"different-model"}))},+ )++ with pytest.raises(ServiceUnavailableError) as exc_info:+ await runtime.validate_configured_models()++ message = exc_info.value.message+ assert "sources=MODEL,MODEL_SONNET" in message+ assert "provider=nvidia_nim" in message+ assert "model=nim-model" in message+ assert "problem=missing model" in message+++async def test_runtime_validation_aggregates_multiple_failures() -> None:+ settings = _settings(model_opus="open_router/anthropic/claude-opus")+ runtime = ProviderRuntime(+ settings,+ {+ "nvidia_nim": FakeProvider(frozenset({"different-model"})),+ "open_router": FakeProvider(+ error=ModelListResponseError("bad model-list shape")+ ),+ },+ )++ with pytest.raises(ServiceUnavailableError) as exc_info:+ await runtime.validate_configured_models()++ message = exc_info.value.message+ assert "sources=MODEL provider=nvidia_nim model=nim-model" in message+ assert "problem=missing model" in message+ assert "sources=MODEL_OPUS provider=open_router model=anthropic/claude-opus" in (+ message+ )+ assert "problem=malformed model-list response" in message+++async def test_runtime_validation_queries_providers_concurrently() -> None:+ nim_started = asyncio.Event()+ router_started = asyncio.Event()+ settings = _settings(model_opus="open_router/anthropic/claude-opus")+ runtime = ProviderRuntime(+ settings,+ {+ "nvidia_nim": FakeProvider(+ frozenset({"nim-model"}),+ started=nim_started,+ peer_started=router_started,+ ),+ "open_router": FakeProvider(+ frozenset({"anthropic/claude-opus"}),+ started=router_started,+ peer_started=nim_started,+ ),+ },+ )++ await asyncio.wait_for(runtime.validate_configured_models(), timeout=1.0)+++async def test_runtime_refresh_model_list_cache_uses_configured_remote_keys_and_referenced_local() -> (+ None+):+ settings = _settings(+ model="lmstudio/local-qwen",+ open_router_api_key="open-router-key",+ )+ runtime = ProviderRuntime(+ settings,+ {+ "open_router": FakeProvider(frozenset({"anthropic/claude-sonnet"})),+ "lmstudio": FakeProvider(frozenset({"local-qwen"})),+ "ollama": FakeProvider(frozenset({"llama3.1"})),+ },+ )++ await runtime.refresh_model_list_cache()++ assert runtime.cached_model_ids() == {+ "open_router": frozenset({"anthropic/claude-sonnet"}),+ "lmstudio": frozenset({"local-qwen"}),+ }+++async def test_runtime_refresh_model_list_cache_keeps_prior_cache_on_failure() -> None:+ settings = _settings(+ model="nvidia_nim/cached-model",+ nvidia_nim_api_key="nim-key",+ )+ runtime = ProviderRuntime(+ settings,+ {"nvidia_nim": FakeProvider(error=RuntimeError("upstream down"))},+ )+ runtime.cache_model_ids("nvidia_nim", {"cached-model"})++ await runtime.refresh_model_list_cache()++ assert runtime.cached_model_ids() == {"nvidia_nim": frozenset({"cached-model"})}+++def test_runtime_metadata_cache_exposes_ids_and_prefixed_infos() -> None:+ runtime = ProviderRuntime(_settings())+ runtime.cache_model_infos(+ "open_router",+ {+ ProviderModelInfo("reasoning-model", supports_thinking=True),+ ProviderModelInfo("plain-model", supports_thinking=False),+ },+ )++ assert runtime.cached_model_ids() == {+ "open_router": frozenset({"reasoning-model", "plain-model"})+ }+ assert (+ runtime.cached_model_supports_thinking("open_router", "reasoning-model") is True+ )+ assert runtime.cached_model_supports_thinking("open_router", "plain-model") is False+ assert runtime.cached_prefixed_model_infos() == (+ ProviderModelInfo("open_router/plain-model", supports_thinking=False),+ ProviderModelInfo("open_router/reasoning-model", supports_thinking=True),+ )+++def test_runtime_model_id_cache_keeps_unknown_thinking_support() -> None:+ runtime = ProviderRuntime(_settings())+ runtime.cache_model_ids("open_router", {"plain-model"})++ assert runtime.cached_model_ids() == {"open_router": frozenset({"plain-model"})}+ assert runtime.cached_model_supports_thinking("open_router", "plain-model") is None+ assert runtime.cached_prefixed_model_infos() == (+ ProviderModelInfo("open_router/plain-model", supports_thinking=None),+ )+++def test_runtime_cached_prefixed_model_refs_are_deterministic() -> None:+ runtime = ProviderRuntime(_settings())+ runtime.cache_model_ids("deepseek", {"deepseek-chat"})+ runtime.cache_model_ids("open_router", {"z-model", "a-model"})++ assert runtime.cached_prefixed_model_refs() == (+ "open_router/a-model",+ "open_router/z-model",+ "deepseek/deepseek-chat",+ )diff --git a/uv.lock b/uv.lockindex c70f17e5..e560f392 100644--- a/uv.lock+++ b/uv.lock@@ -561,7 +561,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "2.5.0"+version = "2.5.1"source = { editable = "." }dependencies = [{ name = "aiohttp" },