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

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.py
index 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__.py
index 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 LMStudioProvider
diff --git a/providers/lmstudio/client.py b/providers/lmstudio/client.py
index 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 OpenAIConversionError
from providers.base import ProviderConfig
from 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.0
def __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 value
diff --git a/pyproject.toml b/pyproject.toml
index 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.py
index 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 asynccontextmanager
from unittest.mock import AsyncMock, MagicMock, patch
import httpx
import pytest
-from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from core.anthropic.stream_contracts import parse_sse_text
from providers.base import ProviderConfig
+from providers.exceptions import InvalidRequestError
from providers.lmstudio import LMStudioProvider
-from tests.stream_contract import assert_canonical_stream_error_envelope
+from providers.lmstudio.client import LMSTUDIO_DEFAULT_BASE
class MockMessage:
@@ -28,28 +28,17 @@ class MockRequest:
self.system = "System prompt"
self.stop_sequences = None
self.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.fixture
def 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 = _slot
yield 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_BASE
assert 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.py
index 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.lock
index 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" },