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
Make LM Studio validation async and fix SDK stream cleanup (#1801)
Ali Khokhar37ea947f40d5
diff --git a/pyproject.toml b/pyproject.tomlindex aab7b242..e1405661 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "6.2.29"+version = "6.2.30"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/src/free_claude_code/providers/lmstudio/client.py b/src/free_claude_code/providers/lmstudio/client.pyindex c989ea80..794385ed 100644--- a/src/free_claude_code/providers/lmstudio/client.py+++ b/src/free_claude_code/providers/lmstudio/client.py@@ -11,11 +11,14 @@ OpenAI provider layers its own tool-call assembly, think-tag parsing, andheuristic recovery on top."""+import asyncio+import sysimport timefrom collections.abc import AsyncIterator, Mapping-import httpx+import httpx2from loguru import logger+from openai import Omitfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayMode, get_token_count@@ -35,6 +38,7 @@ from free_claude_code.providers.endpoint_types import EndpointContextfrom free_claude_code.providers.failure_policy import (context_window_exceeded_provider_failure,)+from free_claude_code.providers.http import close_provider_streamfrom free_claude_code.providers.openai_chat import (NamedEffortReasoning,OpenAIChatProfile,@@ -81,7 +85,8 @@ class LMStudioProvider(OpenAIChatProvider):profile=_PROFILE,admission=admission,)- self._loaded_context_cache: tuple[float, int | None] = (0.0, None)+ self._loaded_context_cache: tuple[float, int | None] | None = None+ self._loaded_context_lock = asyncio.Lock()def stream_messages(self,@@ -105,10 +110,11 @@ class LMStudioProvider(OpenAIChatProvider):endpoint_context=endpoint_context,request_headers=request_headers,)- self._validate_context_budget(- get_token_count(request.messages, request.system, request.tools)+ return self._stream_with_context_budget(+ stream,+ estimate=get_token_count(request.messages, request.system, request.tools),+ request_id=request_id,)- return streamdef stream_responses(self,@@ -130,11 +136,33 @@ class LMStudioProvider(OpenAIChatProvider):endpoint_context=endpoint_context,request_headers=request_headers,)- self._validate_context_budget(estimate_responses_input_tokens(request))- return stream+ return self._stream_with_context_budget(+ stream,+ estimate=estimate_responses_input_tokens(request),+ request_id=request_id,+ )- def _validate_context_budget(self, estimate: int) -> None:- loaded_context = self._loaded_context_length()+ async def _stream_with_context_budget(+ self,+ stream: AsyncIterator[str],+ *,+ estimate: int,+ request_id: str | None,+ ) -> AsyncIterator[str]:+ try:+ await self._validate_context_budget(estimate)+ async for event in stream:+ yield event+ finally:+ await close_provider_stream(+ stream,+ active_error=sys.exception(),+ provider_name=self._provider_name,+ request_id=request_id,+ )++ async def _validate_context_budget(self, estimate: int) -> None:+ loaded_context = await self._loaded_context_length()if loaded_context is None:return# The estimate is cl100k-based and undercounts local tokenizers@@ -149,31 +177,44 @@ class LMStudioProvider(OpenAIChatProvider):f"context {loaded_context}).")- def _loaded_context_length(self) -> int | None:+ async 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+ async with self._loaded_context_lock:+ if self._loaded_context_cache is not None:+ 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 validation unavailable: {}", type(error).__name__- )- value = None- self._loaded_context_cache = (time.monotonic(), value)- return value+ value: int | None = None+ try:+ root = self._base_url+ root = root[: -len("/v1")] if root.endswith("/v1") else root+ response = await self._client.get(+ f"{root}/api/v0/models",+ cast_to=httpx2.Response,+ options={+ "timeout": 2.0,+ "max_retries": 0,+ "follow_redirects": False,+ "headers": {+ "Authorization": Omit(),+ "OpenAI-Organization": Omit(),+ "OpenAI-Project": Omit(),+ },+ },+ )+ 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: # unavailable metadata permits generation+ logger.debug(+ "LMSTUDIO context validation unavailable: {}", type(error).__name__+ )+ self._loaded_context_cache = (time.monotonic(), value)+ return valuediff --git a/src/free_claude_code/providers/mistral/reasoning.py b/src/free_claude_code/providers/mistral/reasoning.pyindex a65f4f96..257d54ad 100644--- a/src/free_claude_code/providers/mistral/reasoning.py+++ b/src/free_claude_code/providers/mistral/reasoning.py@@ -1,6 +1,7 @@"""Mistral La Plateforme reasoning compatibility helpers."""import json+import sysfrom collections.abc import AsyncIterator, Mapping, Sequencefrom copy import deepcopyfrom types import SimpleNamespace@@ -9,7 +10,7 @@ from typing import Anyimport openaifrom free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicy-from free_claude_code.providers.http import maybe_await_aclose+from free_claude_code.providers.http import close_provider_streamMISTRAL_REASONING_EFFORT = "high"@@ -109,7 +110,12 @@ def normalize_mistral_stream(stream: Any) -> AsyncIterator[Any]:async for chunk in stream:yield normalize_mistral_chunk(chunk)finally:- await maybe_await_aclose(stream)+ await close_provider_stream(+ stream,+ active_error=sys.exception(),+ provider_name="MISTRAL",+ request_id=None,+ )return _iter()diff --git a/src/free_claude_code/providers/openai_chat/transport.py b/src/free_claude_code/providers/openai_chat/transport.pyindex dbd6e90d..aebc6e10 100644--- a/src/free_claude_code/providers/openai_chat/transport.py+++ b/src/free_claude_code/providers/openai_chat/transport.py@@ -83,6 +83,7 @@ from free_claude_code.providers.http import (close_provider_stream,maybe_await_aclose,)+from free_claude_code.providers.openai_stream import OpenAIStreamAdapterfrom free_claude_code.providers.reasoning_compatibility import (ReasoningCorrection,prepare_messages_reasoning,@@ -692,9 +693,11 @@ class OpenAIChatTransport:structured_details=self._profile.structured_reasoning_details,),)- stream = await client.chat.completions.create(- **create_body,- stream=True,+ stream = OpenAIStreamAdapter(+ await client.chat.completions.create(+ **create_body,+ stream=True,+ ))stream = self._behavior.normalize_stream(stream, body)retain_attempt = True@@ -727,14 +730,16 @@ class OpenAIChatTransport:raisefinally:if not retain_attempt:- if stream is not None:- await close_provider_stream(- stream,- active_error=sys.exception(),- provider_name=self._provider_name,- request_id=execution.request_id,- )- await attempt.aclose()+ try:+ if stream is not None:+ await close_provider_stream(+ stream,+ active_error=sys.exception(),+ provider_name=self._provider_name,+ request_id=execution.request_id,+ )+ finally:+ await attempt.aclose()if execution.last_failure is not None:raise execution.last_failurediff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex d3640580..88fc9da9 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -59,6 +59,7 @@ from free_claude_code.providers.history_replay import (validate_history,)from free_claude_code.providers.http import ProviderAttemptScope, maybe_await_aclose+from free_claude_code.providers.openai_stream import OpenAIStreamAdapterfrom free_claude_code.providers.reasoning_compatibility import (ReasoningCorrection,prepare_messages_reasoning,@@ -82,22 +83,6 @@ class _TruncatedResponsesStream(RetryableProviderProtocolError):"""A Responses stream ended without a terminal lifecycle event."""-class _ClosableResponsesStream(AsyncIterator[ResponseStreamEvent]):- """Expose the OpenAI SDK stream through the shared ``aclose`` contract."""-- def __init__(self, stream: AsyncStream[ResponseStreamEvent]) -> None:- self._stream = stream-- def __aiter__(self) -> AsyncIterator[ResponseStreamEvent]:- return self-- async def __anext__(self) -> ResponseStreamEvent:- return await anext(self._stream)-- async def aclose(self) -> None:- await self._stream.close()--class OpenAIResponsesTransport:"""Execute public Responses requests with provider-owned retry semantics."""@@ -371,7 +356,7 @@ class OpenAIResponsesTransport:endpoint=endpoint,extra_headers=extra_headers,)- stream = scope.retain(_ClosableResponsesStream(sdk_stream))+ stream = scope.retain(OpenAIStreamAdapter(sdk_stream))stream_opened = Trueasync for upstream_event in stream:diff --git a/src/free_claude_code/providers/openai_stream.py b/src/free_claude_code/providers/openai_stream.pynew file mode 100644index 00000000..28aa42c6--- /dev/null+++ b/src/free_claude_code/providers/openai_stream.py@@ -0,0 +1,21 @@+"""Adapt the OpenAI SDK stream to FCC's asynchronous cleanup contract."""++from collections.abc import AsyncIterator++from openai import AsyncStream+++class OpenAIStreamAdapter[EventT](AsyncIterator[EventT]):+ """Own an SDK response stream without closing its reusable client."""++ def __init__(self, stream: AsyncStream[EventT]) -> None:+ self._stream = stream++ def __aiter__(self) -> AsyncIterator[EventT]:+ return self++ async def __anext__(self) -> EventT:+ return await anext(self._stream)++ async def aclose(self) -> None:+ await self._stream.close()diff --git a/tests/api/test_classifier_provider_compatibility.py b/tests/api/test_classifier_provider_compatibility.pyindex 6c73f21d..e0a065b1 100644--- a/tests/api/test_classifier_provider_compatibility.py+++ b/tests/api/test_classifier_provider_compatibility.py@@ -21,17 +21,22 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.core.reasoning import ReasoningCapabilityfrom free_claude_code.providers.open_router import OpenRouterProvider-from tests.providers.support import immediate_admission, make_provider_config+from tests.providers.support import (+ SDKStreamDouble,+ immediate_admission,+ make_provider_config,+)from tests.web_tools_support import StubWebToolsClient-class ClassifierStream:+class ClassifierStream(SDKStreamDouble):def __init__(self, *, starved: bool = False, error: Exception | None = None):self.starved = starvedself.error = errorself.closed = False+ super().__init__(self._iterate(), close=self.aclose)- async def __aiter__(self):+ async def _iterate(self):if self.error is not None:raise self.errorfor text, reasoning, finish in (diff --git a/tests/providers/support.py b/tests/providers/support.pyindex f6a7e372..63cf6fde 100644--- a/tests/providers/support.py+++ b/tests/providers/support.py@@ -1,12 +1,14 @@"""Provider test helpers with explicit admission ownership."""import json+from collections.abc import AsyncIterable, AsyncIterator, Awaitable, Callableimport httpx2from openai import AsyncOpenAIfrom free_claude_code.application.reasoning import client_reasoning_policyfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.async_iterators import AsyncCloseablefrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -20,6 +22,33 @@ REASONING_ON = ReasoningPolicy.on()REASONING_OFF = ReasoningPolicy.off()+class SDKStreamDouble[EventT](AsyncIterator[EventT]):+ """Model the SDK iterator and async close API at mocked create boundaries."""++ def __init__(+ self,+ source: AsyncIterable[EventT],+ *,+ close: Callable[[], Awaitable[None]] | None = None,+ ) -> None:+ self._iterator = aiter(source)+ self._close = close++ def __aiter__(self) -> AsyncIterator[EventT]:+ return self++ async def __anext__(self) -> EventT:+ return await anext(self._iterator)++ async def close(self) -> None:+ try:+ if isinstance(self._iterator, AsyncCloseable):+ await self._iterator.aclose()+ finally:+ if self._close is not None:+ await self._close()++def make_provider_config(api_key: str | None,base_url: str,diff --git a/tests/providers/test_cerebras.py b/tests/providers/test_cerebras.pyindex 61ed2403..501633e2 100644--- a/tests/providers/test_cerebras.py+++ b/tests/providers/test_cerebras.py@@ -8,6 +8,7 @@ from free_claude_code.config.provider_catalog import CEREBRAS_DEFAULT_BASEfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -217,7 +218,7 @@ async def test_stream_messages_text(cerebras_provider):with patch.object(cerebras_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in cerebras_provider.stream_messages(req)]@@ -250,7 +251,7 @@ async def test_stream_messages_reasoning(cerebras_provider):with patch.object(cerebras_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in cerebras_provider.stream_messages(req)]diff --git a/tests/providers/test_cline_pass.py b/tests/providers/test_cline_pass.pyindex 09da153f..2c982307 100644--- a/tests/providers/test_cline_pass.py+++ b/tests/providers/test_cline_pass.py@@ -26,6 +26,7 @@ from tests.providers.support import (REASONING_DEFAULT,REASONING_OFF,REASONING_ON,+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -82,13 +83,11 @@ def _request(**overrides: JsonValue) -> MessagesRequest:return MessagesRequest.model_validate(payload)-class AsyncStream:+class AsyncStream(SDKStreamDouble):def __init__(self, chunks: list[SimpleNamespace]) -> None:self._chunks = chunksself.closed = False-- def __aiter__(self) -> AsyncIterator[SimpleNamespace]:- return self._iter()+ super().__init__(self._iter(), close=self.aclose)async def _iter(self) -> AsyncIterator[SimpleNamespace]:for chunk in self._chunks:diff --git a/tests/providers/test_cloudflare.py b/tests/providers/test_cloudflare.pyindex 62eacfac..7bcff676 100644--- a/tests/providers/test_cloudflare.py+++ b/tests/providers/test_cloudflare.py@@ -18,6 +18,7 @@ from free_claude_code.providers.cloudflare import (cloudflare_ai_base_url,)from tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,reasoning_for,@@ -222,7 +223,7 @@ async def test_stream_uses_openai_chat_completions(cloudflare_provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=_stream(_chunk(delta)),+ return_value=SDKStreamDouble(_stream(_chunk(delta))),) as mock_create:events = [event async for event in cloudflare_provider.stream_messages(_request())@@ -253,7 +254,7 @@ async def test_stream_maps_cloudflare_reasoning_delta_to_thinking(cloudflare_provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=_stream(_chunk(delta)),+ return_value=SDKStreamDouble(_stream(_chunk(delta))),):events = [event async for event in cloudflare_provider.stream_messages(_request())@@ -304,7 +305,9 @@ async def test_stream_maps_openai_tool_calls_to_tool_use(cloudflare_provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=_stream(_chunk(delta, finish_reason="tool_calls")),+ return_value=SDKStreamDouble(+ _stream(_chunk(delta, finish_reason="tool_calls"))+ ),):events = [event async for event in cloudflare_provider.stream_messages(request)]diff --git a/tests/providers/test_codestral.py b/tests/providers/test_codestral.pyindex ca10871c..18bd740b 100644--- a/tests/providers/test_codestral.py+++ b/tests/providers/test_codestral.py@@ -9,6 +9,7 @@ from free_claude_code.config.provider_catalog import CODESTRAL_DEFAULT_BASEfrom free_claude_code.core.model_capabilities import ModelInputModalityfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -170,7 +171,7 @@ async def test_stream_messages_text(codestral_provider):with patch.object(codestral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in codestral_provider.stream_messages(req)]@@ -203,7 +204,7 @@ async def test_stream_messages_reasoning_content(codestral_provider):with patch.object(codestral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in codestral_provider.stream_messages(req)]diff --git a/tests/providers/test_cohere.py b/tests/providers/test_cohere.pyindex 7de58eed..2e5acb90 100644--- a/tests/providers/test_cohere.py+++ b/tests/providers/test_cohere.py@@ -9,6 +9,7 @@ from free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.provider_catalog import COHERE_DEFAULT_BASEfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -205,7 +206,7 @@ async def test_stream_messages_text(cohere_provider):with patch.object(cohere_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in cohere_provider.stream_messages(make_request())@@ -240,7 +241,7 @@ async def test_stream_messages_tool_call(cohere_provider):with patch.object(cohere_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in cohere_provider.stream_messages(make_request())@@ -275,7 +276,7 @@ async def test_stream_messages_reasoning_content(cohere_provider):with patch.object(cohere_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in cohere_provider.stream_messages(make_request())diff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.pyindex aedd7dd0..593cec26 100644--- a/tests/providers/test_deepseek.py+++ b/tests/providers/test_deepseek.py@@ -27,6 +27,7 @@ from free_claude_code.providers.deepseek import DeepSeekProviderfrom tests.providers.support import (REASONING_OFF,REASONING_ON,+ SDKStreamDouble,capture_openai_chat_wire_body,immediate_admission,make_provider_config,@@ -1156,7 +1157,7 @@ async def test_stream_uses_chat_completions_and_maps_cache_usage(deepseek_provid),)- create = AsyncMock(return_value=fake_stream())+ create = AsyncMock(return_value=SDKStreamDouble(fake_stream()))with patch.object(deepseek_provider._client.chat.completions, "create", create):chunks = [chunk@@ -1222,7 +1223,7 @@ async def test_responses_stream_maps_deepseek_cache_usage(deepseek_provider):),)- create = AsyncMock(return_value=fake_stream())+ create = AsyncMock(return_value=SDKStreamDouble(fake_stream()))with patch.object(deepseek_provider._client.chat.completions, "create", create):chunks = [chunkdiff --git a/tests/providers/test_execution_failure_boundary.py b/tests/providers/test_execution_failure_boundary.pyindex 2cd19c1b..20d27a79 100644--- a/tests/providers/test_execution_failure_boundary.py+++ b/tests/providers/test_execution_failure_boundary.py@@ -19,12 +19,13 @@ from free_claude_code.providers.http import (from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,)-class _FailingStream:+class _FailingStream(SDKStreamDouble[object]):def __init__(self,chunks: list[object],@@ -36,9 +37,7 @@ class _FailingStream:self._error = errorself._close_error = close_errorself.close_calls = 0-- def __aiter__(self) -> AsyncIterator[object]:- return self._iterate()+ super().__init__(self._iterate(), close=self.aclose)async def _iterate(self) -> AsyncIterator[object]:for chunk in self._chunks:diff --git a/tests/providers/test_gemini.py b/tests/providers/test_gemini.pyindex 26854c62..3606b463 100644--- a/tests/providers/test_gemini.py+++ b/tests/providers/test_gemini.py@@ -14,6 +14,7 @@ from free_claude_code.providers.google_openai import ()from tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,reasoning_for,@@ -452,7 +453,7 @@ async def test_stream_messages_text(gemini_provider):with patch.object(gemini_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event@@ -508,7 +509,7 @@ async def test_stream_messages_preserves_tool_call_extra_content(gemini_providerwith patch.object(gemini_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in gemini_provider.stream_messages(req)]@@ -585,7 +586,7 @@ async def test_colliding_stream_tool_id_rekeys_cached_thought_signature(gemini_provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=mock_stream(),+ return_value=SDKStreamDouble(mock_stream()),):events = [event async for event in gemini_provider.stream_messages(request)]@@ -663,7 +664,7 @@ async def test_stream_messages_reasoning_content(gemini_provider):with patch.object(gemini_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in gemini_provider.stream_messages(req)]diff --git a/tests/providers/test_groq.py b/tests/providers/test_groq.pyindex 615fccde..d329f56e 100644--- a/tests/providers/test_groq.py+++ b/tests/providers/test_groq.py@@ -9,6 +9,7 @@ from free_claude_code.config.provider_catalog import GROQ_DEFAULT_BASEfrom free_claude_code.providers.groq import GroqProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,)@@ -238,7 +239,7 @@ async def test_stream_messages_text(groq_provider):with patch.object(groq_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in groq_provider.stream_messages(req)]@@ -271,7 +272,7 @@ async def test_stream_messages_reasoning_content(groq_provider):with patch.object(groq_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in groq_provider.stream_messages(req)]diff --git a/tests/providers/test_groq_reasoning.py b/tests/providers/test_groq_reasoning.pyindex 80e36fbc..0286562a 100644--- a/tests/providers/test_groq_reasoning.py+++ b/tests/providers/test_groq_reasoning.py@@ -28,6 +28,7 @@ from free_claude_code.providers.groq.client import ()from tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,capture_openai_chat_wire_body,immediate_admission,make_provider_config,@@ -122,7 +123,7 @@ async def test_classifier_correction_does_not_change_later_requests(message):sent.append(body)if len(sent) == 1:raise _BadRequest(message, body={"message": message})- return _successful_stream("<severity>0</severity>")+ return SDKStreamDouble(_successful_stream("<severity>0</severity>"))try:with patch.object(provider._client.chat.completions, "create", create):@@ -412,7 +413,9 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:provider = _provider()policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)body = provider._chat._build_request_body(_request(), reasoning=policy)- create = AsyncMock(side_effect=[_vocabulary_error(), object()])+ create = AsyncMock(+ side_effect=[_vocabulary_error(), SDKStreamDouble(_successful_stream())]+ )with patch.object(provider._client.chat.completions, "create", create):_stream, used_body, attempt, _sent_body = await provider._chat._create_stream(@@ -420,6 +423,7 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:provider._admission.start_execution(),ProviderOperationKind.GENERATION,)+ await _stream.aclose()await attempt.aclose()assert create.await_count == 2@@ -430,7 +434,7 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:next_body = provider._chat._build_request_body(_request(), reasoning=policy)assert next_body["reasoning_effort"] == "default"- next_create = AsyncMock(return_value=object())+ next_create = AsyncMock(return_value=SDKStreamDouble(_successful_stream()))with patch.object(provider._client.chat.completions, "create", next_create):(_stream,@@ -442,6 +446,7 @@ async def test_exact_issue_retries_with_default_and_learns_model() -> None:provider._admission.start_execution(),ProviderOperationKind.GENERATION,)+ await _stream.aclose()await next_attempt.aclose()assert next_create.await_count == 1assert next_used_body["reasoning_effort"] == "default"@@ -776,7 +781,9 @@ async def test_reasoning_correction_emits_one_downstream_lifecycle() -> None:provider = _provider()request = _request()policy = ReasoningPolicy.on(effort=ReasoningEffort.HIGH)- create = AsyncMock(side_effect=[_vocabulary_error(), _successful_stream()])+ create = AsyncMock(+ side_effect=[_vocabulary_error(), SDKStreamDouble(_successful_stream())]+ )with patch.object(provider._client.chat.completions, "create", create):raw = "".join(diff --git a/tests/providers/test_groq_tpm.py b/tests/providers/test_groq_tpm.pyindex 857011da..4a1c47cf 100644--- a/tests/providers/test_groq_tpm.py+++ b/tests/providers/test_groq_tpm.py@@ -14,7 +14,11 @@ from free_claude_code.providers.admission import ProviderOperationKindfrom free_claude_code.providers.groq import GroqProviderfrom free_claude_code.providers.groq.tpm import correct_tpm_completion_budgetfrom tests.providers.request_factory import make_messages_request-from tests.providers.support import immediate_admission, make_provider_config+from tests.providers.support import (+ SDKStreamDouble,+ immediate_admission,+ make_provider_config,+)_MODEL = "openai/gpt-oss-120b"_LIMIT = 8_000@@ -222,7 +226,9 @@ def test_non_authoritative_tpm_rejection_is_not_corrected(async def test_tpm_correction_emits_one_downstream_lifecycle() -> None:provider = _provider()request = make_messages_request(_MODEL, max_tokens=_ORIGINAL_MAX)- create = AsyncMock(side_effect=[_status_error(), _successful_stream()])+ create = AsyncMock(+ side_effect=[_status_error(), SDKStreamDouble(_successful_stream())]+ )with patch.object(provider._client.chat.completions, "create", create):raw = "".join(diff --git a/tests/providers/test_huggingface.py b/tests/providers/test_huggingface.pyindex 2aee9e8d..f460d97a 100644--- a/tests/providers/test_huggingface.py+++ b/tests/providers/test_huggingface.py@@ -13,6 +13,7 @@ from free_claude_code.core.model_capabilities import ModelInputModalityfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -262,7 +263,7 @@ async def test_stream_messages_text(huggingface_provider):with patch.object(huggingface_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event@@ -296,7 +297,7 @@ async def test_stream_messages_reasoning_content(huggingface_provider):with patch.object(huggingface_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [eventdiff --git a/tests/providers/test_kilo.py b/tests/providers/test_kilo.pyindex 9d179c0a..37fd73b0 100644--- a/tests/providers/test_kilo.py+++ b/tests/providers/test_kilo.py@@ -22,6 +22,7 @@ from free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,reasoning_for,@@ -46,13 +47,11 @@ def kilo_provider(kilo_config):)-class AsyncStream:+class AsyncStream(SDKStreamDouble):def __init__(self, chunks):self._chunks = chunksself.closed = False-- def __aiter__(self):- return self._iter()+ super().__init__(self._iter(), close=self.aclose)async def _iter(self):for chunk in self._chunks:diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.pyindex fa2174ce..2f0cbfdd 100644--- a/tests/providers/test_llamacpp.py+++ b/tests/providers/test_llamacpp.py@@ -10,6 +10,7 @@ from free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -134,7 +135,7 @@ async def test_stream_messages_uses_shared_openai_chat_provider(provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=stream(),+ return_value=SDKStreamDouble(stream()),) as create:output = "".join([diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex 49dca413..4b762b6e 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -1,10 +1,15 @@"""Tests for LM Studio (OpenAI-compatible chat completions) provider."""import asyncio+import json+import time+from contextlib import asynccontextmanagerfrom unittest.mock import AsyncMock, MagicMock, patchimport httpx+import httpx2import pytest+from openai import AsyncOpenAIfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.execution import ProviderExecutor@@ -16,12 +21,20 @@ from free_claude_code.core.openai_responses import (estimate_responses_input_tokens,)from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.lmstudio import LMStudioProvider-from tests.application.test_execution import _routed_request, _routed_responses_request+from tests.application.test_execution import (+ FakeProvider,+ ResponsesFakeProvider,+ _routed_request,+ _routed_responses_request,+ _target,+)from tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,+ SDKStreamDouble,immediate_admission,make_provider_config,)@@ -44,11 +57,103 @@ def lmstudio_config():@pytest.fixturedef lmstudio_provider(lmstudio_config):provider = LMStudioProvider(lmstudio_config, admission=immediate_admission())+ with patch.object(+ provider._client,+ "get",+ side_effect=httpx2.ConnectError("offline test"),+ ):+ yield provider+++def metadata_response(context=100_000):+ return httpx2.Response(+ 200, json={"data": [{"state": "loaded", "loaded_context_length": context}]}+ )+++@asynccontextmanager+async def provider_with_http(handler, *, base_url=LMSTUDIO_DEFAULT_BASE):+ config = make_provider_config(api_key="lm-studio", base_url=base_url)+ client = AsyncOpenAI(+ api_key=config.api_key,+ base_url=base_url,+ organization="test-org",+ project="test-project",+ max_retries=3,+ timeout=17.0,+ http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(handler)),+ )with patch(- "free_claude_code.providers.lmstudio.client.httpx.get",- side_effect=httpx.ConnectError("offline test"),+ "free_claude_code.providers.openai_chat.provider.create_chat_client",+ return_value=client,):+ provider = LMStudioProvider(+ config,+ admission=ProviderAdmissionController(+ provider_name="LMSTUDIO",+ rate_limit=1_000_000,+ rate_window=1.0,+ max_concurrency=1,+ ),+ )+ try:yield provider+ finally:+ await provider.cleanup()+++class GatedBody(httpx2.AsyncByteStream):+ def __init__(+ self,+ *,+ prefix=b"",+ content=b'{"data": [{"state": "loaded", "loaded_context_length": 1000}]}',+ ):+ self.prefix = prefix+ self.content = content+ self.started = asyncio.Event()+ self.release = asyncio.Event()+ self.close_count = 0++ async def __aiter__(self):+ if self.prefix:+ yield self.prefix+ self.started.set()+ await self.release.wait()+ yield self.content++ async def aclose(self):+ self.close_count += 1+++def stream_request(provider, wire):+ request = (+ make_request()+ if wire == "messages"+ else OpenAIResponsesRequest(model="model", input="hello")+ )+ return getattr(provider, f"stream_{wire}")(request)+++def completion_chunk(*, finish_reason="stop", content="hello"):+ chunk = {+ "id": "chat_test",+ "object": "chat.completion.chunk",+ "created": 0,+ "model": "model",+ "choices": [+ {"index": 0, "delta": {"content": content}, "finish_reason": finish_reason}+ ],+ }+ return f"data: {json.dumps(chunk)}\n\n".encode()+++def completion_response():+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ content=completion_chunk() + b"data: [DONE]\n\n",+ )def test_init(lmstudio_config):@@ -67,6 +172,53 @@ def test_default_base_url_constant():assert LMSTUDIO_DEFAULT_BASE == "http://localhost:1234/v1"[email protected]("wire", ["messages", "responses"])+async def test_context_metadata_wait_keeps_event_loop_responsive(+ lmstudio_provider, wire+):+ events = []+ loop = asyncio.get_running_loop()+ response = httpx.Response(+ 200,+ request=httpx.Request("GET", "http://localhost:1234/api/v0/models"),+ json={"data": [{"state": "loaded", "loaded_context_length": 1}]},+ )++ def synchronous_lookup(*args, **kwargs):+ loop.call_soon_threadsafe(events.append, "peer ran")+ time.sleep(0.02)+ events.append("metadata returned")+ return response++ async def asynchronous_lookup(*args, **kwargs):+ loop.call_soon_threadsafe(events.append, "peer ran")+ await asyncio.sleep(0)+ events.append("metadata returned")+ return response++ request = (+ make_request()+ if wire == "messages"+ else OpenAIResponsesRequest(model="model", input="hello")+ )+ stream = None+ with (+ patch("httpx.get", side_effect=synchronous_lookup),+ patch.object(lmstudio_provider._client, "get", side_effect=asynchronous_lookup),+ ):+ try:+ with pytest.raises(ExecutionFailure) as error:+ stream = getattr(lmstudio_provider, f"stream_{wire}")(request)+ await anext(stream)+ assert error.value.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED+ finally:+ if stream is not None:+ await stream.aclose()+ await asyncio.sleep(0)+ assert events == ["peer ran", "metadata returned"]++def test_build_request_body_basic(lmstudio_provider):req = make_request()body = lmstudio_provider._chat._build_request_body(req)@@ -125,8 +277,9 @@ def test_build_request_body_never_replays_prior_thinking(lmstudio_provider):assert "prior reasoning" in str(body)@pytest.mark.parametrize("wire", ["messages", "responses"])-def test_startup_builds_before_context_budget_and_preserves_policy(+async def test_startup_builds_before_context_budget_and_preserves_policy(lmstudio_provider, wire):request = (@@ -145,8 +298,9 @@ def test_startup_builds_before_context_budget_and_preserves_policy(calls.append(("build", reasoning))return original(request_arg, reasoning=reasoning)- def check_context(estimate):+ async def check_context(estimate):calls.append(("context", estimate))+ raise RuntimeError("stop before generation")with (patch.object(lmstudio_provider._chat, name, side_effect=build),@@ -157,7 +311,12 @@ def test_startup_builds_before_context_budget_and_preserves_policy(lmstudio_provider._chat._admission, "start_execution") as admission,):- getattr(lmstudio_provider, f"stream_{wire}")(request, reasoning=REASONING_OFF)+ stream = getattr(lmstudio_provider, f"stream_{wire}")(+ request, reasoning=REASONING_OFF+ )+ assert calls == [("build", REASONING_OFF)]+ with pytest.raises(RuntimeError, match="stop before generation"):+ await anext(stream)estimate = (get_token_count(request.messages, request.system, request.tools)if isinstance(request, MessagesRequest)@@ -192,8 +351,9 @@ def test_startup_conversion_failure_skips_context_budget(lmstudio_provider, wirecontext.assert_not_called()@pytest.mark.parametrize("wire", ["messages", "responses"])-def test_context_rejection_never_starts_admission_or_generation(+async def test_context_rejection_never_starts_admission_or_generation(lmstudio_provider, wire):request = (@@ -202,7 +362,9 @@ def test_context_rejection_never_starts_admission_or_generation(else OpenAIResponsesRequest(model="model", input="hello"))with (- patch.object(lmstudio_provider, "_loaded_context_length", return_value=1),+ patch.object(+ lmstudio_provider, "_loaded_context_length", new=AsyncMock(return_value=1)+ ),patch.object(lmstudio_provider._chat._admission, "start_execution") as admission,@@ -211,7 +373,7 @@ def test_context_rejection_never_starts_admission_or_generation() as generation,pytest.raises(ExecutionFailure) as error,):- getattr(lmstudio_provider, f"stream_{wire}")(request)+ await anext(getattr(lmstudio_provider, f"stream_{wire}")(request))assert error.value.kind is FailureKind.CONTEXT_WINDOW_EXCEEDEDadmission.assert_not_called()generation.assert_not_called()@@ -220,40 +382,42 @@ def test_context_rejection_never_starts_admission_or_generation(@pytest.mark.asyncio@pytest.mark.parametrize("wire", ["messages", "responses"])async def test_primary_context_validation_counts_toward_progress_timeout(- lmstudio_provider, wire+ wire,):- loop = asyncio.get_running_loop()- now = loop.time()-- def slow_lookup():- nonlocal now- now += 2- return 100_000+ body = GatedBody()+ requests = []++ def handler(request):+ requests.append(request)+ return (+ httpx2.Response(200, stream=body)+ if len(requests) == 1+ else metadata_response()+ )- executor = ProviderExecutor(- AsyncMock(side_effect=lambda _: lmstudio_provider), progress_timeout_seconds=1- )- routed = _routed_request() if wire == "messages" else _routed_responses_request()- with (- patch.object(loop, "time", side_effect=lambda: now),- patch.object(- lmstudio_provider, "_loaded_context_length", side_effect=slow_lookup- ),- patch.object(- lmstudio_provider._chat._admission, "start_execution"- ) as admission,- patch.object(- lmstudio_provider._client.chat.completions, "create"- ) as generation,- ):+ async with provider_with_http(handler) as provider:+ fallback = FakeProvider() if wire == "messages" else ResponsesFakeProvider()+ providers = {"provider": provider, "fallback": fallback}+ executor = ProviderExecutor(+ AsyncMock(side_effect=lambda name: providers[name]),+ progress_timeout_seconds=0.05,+ )+ route = _routed_request if wire == "messages" else _routed_responses_request+ routed = route(_target("fallback", "fallback-model"))stream = getattr(executor, f"stream_{wire}")(routed, raw_log_payload={}, request_id="context-timeout")- with pytest.raises(ExecutionFailure) as error:- await anext(stream)- assert error.value.kind is FailureKind.TIMEOUT- admission.assert_not_called()- generation.assert_not_called()+ async with asyncio.timeout(2):+ with pytest.raises(ExecutionFailure) as error:+ await anext(stream)+ assert error.value.kind is FailureKind.TIMEOUT+ assert body.started.is_set()+ assert body.close_count == 1+ assert fallback.stream_calls == []+ assert [request.url.path for request in requests] == ["/api/v0/models"]+ async with asyncio.timeout(1):+ assert await provider._loaded_context_length() == 100_000+ assert len(requests) == 2@pytest.mark.asyncio@@ -278,7 +442,7 @@ async def test_stream_messages_text(lmstudio_provider):with patch.object(lmstudio_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in lmstudio_provider.stream_messages(req)]@@ -312,7 +476,7 @@ async def test_stream_messages_passes_exact_reasoning_budget_via_extra_body(with patch.object(lmstudio_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event@@ -332,33 +496,50 @@ async def test_stream_messages_passes_exact_reasoning_budget_via_extra_body(@pytest.mark.asyncioasync def test_cleanup(lmstudio_provider):- lmstudio_provider._client = AsyncMock()+ assert not lmstudio_provider._client.is_closed()await lmstudio_provider.cleanup()+ assert lmstudio_provider._client.is_closed()# --- Context-budget validation (new: guards against LM Studio's silent# mid-stream truncation when a prompt exceeds the loaded model's context) ----def test_validate_context_budget_noop_when_context_length_unknown(lmstudio_provider):+async def test_validate_context_budget_noop_when_context_length_unknown(+ lmstudio_provider,+):"""No LM Studio /api/v0/models data available -> validation is a no-op (fail open)."""- with patch.object(lmstudio_provider, "_loaded_context_length", return_value=None):- lmstudio_provider._validate_context_budget(1) # must not raise+ with patch.object(+ lmstudio_provider, "_loaded_context_length", new=AsyncMock(return_value=None)+ ):+ await lmstudio_provider._validate_context_budget(1)-def test_validate_context_budget_allows_request_under_budget(lmstudio_provider):[email protected]("estimate", [1, 90_000])+async def test_validate_context_budget_allows_request_under_budget(+ lmstudio_provider, estimate+):with patch.object(- lmstudio_provider, "_loaded_context_length", return_value=100_000+ lmstudio_provider, "_loaded_context_length", new=AsyncMock(return_value=100_000)):- lmstudio_provider._validate_context_budget(1) # must not raise+ await lmstudio_provider._validate_context_budget(estimate)-def test_validate_context_budget_rejects_request_over_90_percent(lmstudio_provider):+async def test_validate_context_budget_rejects_request_over_90_percent(+ lmstudio_provider,+):with (- patch.object(lmstudio_provider, "_loaded_context_length", return_value=1000),+ patch.object(+ lmstudio_provider,+ "_loaded_context_length",+ new=AsyncMock(return_value=1000),+ ),pytest.raises(ExecutionFailure) as exc_info,):- lmstudio_provider._validate_context_budget(901)+ await lmstudio_provider._validate_context_budget(901)failure = exc_info.valueassert failure.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED@@ -371,7 +552,8 @@ def test_validate_context_budget_rejects_request_over_90_percent(lmstudio_providassert "prompt is too long" not in failure.message-def test_loaded_context_length_reads_max_across_loaded_models(lmstudio_provider):+async def test_loaded_context_length_reads_max_across_loaded_models(lmstudio_provider):response = MagicMock()response.raise_for_status = MagicMock()response.json.return_value = {@@ -381,35 +563,342 @@ def test_loaded_context_length_reads_max_across_loaded_models(lmstudio_provider){"state": "not-loaded", "loaded_context_length": 999999},]}- with patch(- "free_claude_code.providers.lmstudio.client.httpx.get", return_value=response+ with patch.object(+ lmstudio_provider._client, "get", return_value=response) as mock_get:- value = lmstudio_provider._loaded_context_length()+ value = await lmstudio_provider._loaded_context_length()assert value == 40960mock_get.assert_called_once()assert mock_get.call_args[0][0] == "http://localhost:1234/api/v0/models"-def test_loaded_context_length_fails_open_on_error(lmstudio_provider):- with patch(- "free_claude_code.providers.lmstudio.client.httpx.get",- side_effect=httpx.ConnectError("refused"),+async def test_loaded_context_length_fails_open_on_error(lmstudio_provider):+ with patch.object(+ lmstudio_provider._client,+ "get",+ side_effect=httpx2.ConnectError("refused"),):- assert lmstudio_provider._loaded_context_length() is None+ assert await lmstudio_provider._loaded_context_length() is None-def test_loaded_context_length_is_cached_within_ttl(lmstudio_provider):+async 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(- "free_claude_code.providers.lmstudio.client.httpx.get", return_value=response+ with patch.object(+ lmstudio_provider._client, "get", return_value=response) as mock_get:- first = lmstudio_provider._loaded_context_length()- second = lmstudio_provider._loaded_context_length()+ first = await lmstudio_provider._loaded_context_length()+ second = await lmstudio_provider._loaded_context_length()assert first == second == 40960mock_get.assert_called_once()+++ ("provider_url", "metadata_url"),+ [+ ("http://localhost:1234/v1", "http://localhost:1234/api/v0/models"),+ (+ "http://localhost:1234/prefix/v1/",+ "http://localhost:1234/prefix/api/v0/models",+ ),+ ("http://localhost:1234", "http://localhost:1234/api/v0/models"),+ ],+)[email protected]("content_type", [None, "text/plain"])+async def test_metadata_http_policy_preserves_the_generation_client(+ provider_url, metadata_url, content_type+):+ requests = []++ def handler(request):+ requests.append(request)+ if request.url.path.endswith("/api/v0/models"):+ return httpx2.Response(+ 200,+ headers={"content-type": content_type} if content_type else {},+ content=b'{"data": [{"state": "loaded", "loaded_context_length": 4096}]}',+ )+ return completion_response()++ async with provider_with_http(handler, base_url=provider_url) as provider:+ assert await provider._loaded_context_length() == 4096+ output = "".join(+ [event async for event in stream_request(provider, "messages")]+ )+ assert "hello" in output+ assert "message_stop" in output+ assert len(requests) == 2+ metadata, generation = requests+ assert str(metadata.url) == metadata_url+ assert not {+ "authorization",+ "openai-organization",+ "openai-project",+ }.intersection(metadata.headers)+ assert metadata.extensions["timeout"] == {+ "connect": 2.0,+ "read": 2.0,+ "write": 2.0,+ "pool": 2.0,+ }+ assert generation.headers["authorization"] == "Bearer lm-studio"+ assert generation.headers["openai-organization"] == "test-org"+ assert generation.headers["openai-project"] == "test-project"+ assert generation.extensions["timeout"]["read"] == 17.0+ assert not provider._client.is_closed()+ assert provider._client.is_closed()+++ "failure", ["timeout", "status", "redirect", "json", "shape", "empty"]+)+async def test_metadata_failure_is_cached_without_retry_and_allows_generation(failure):+ requests = []++ def handler(request):+ requests.append(request)+ if not request.url.path.endswith("/api/v0/models"):+ return completion_response()+ if failure == "timeout":+ raise httpx2.ReadTimeout("metadata unavailable", request=request)+ if failure == "status":+ return httpx2.Response(503, json={"error": "unavailable"})+ if failure == "redirect":+ return httpx2.Response(+ 302, headers={"location": "http://other.invalid/models"}+ )+ if failure == "json":+ return httpx2.Response(200, content=b"not JSON")+ return httpx2.Response(200, json={"data": None if failure == "shape" else []})++ async with provider_with_http(handler) as provider:+ assert await provider._loaded_context_length() is None+ assert await provider._loaded_context_length() is None+ output = "".join(+ [event async for event in stream_request(provider, "messages")]+ )+ assert "hello" in output+ assert "message_stop" in output+ assert [request.url.path for request in requests] == [+ "/api/v0/models",+ "/v1/chat/completions",+ ]+++async def test_context_cache_expires_from_lookup_completion(monkeypatch):+ from types import SimpleNamespace++ now = 0.0+ calls = 0++ def handler(request):+ nonlocal now, calls+ calls += 1+ now += 10.0+ return metadata_response(4096 * calls)++ monkeypatch.setattr(+ "free_claude_code.providers.lmstudio.client.time",+ SimpleNamespace(monotonic=lambda: now),+ )+ async with provider_with_http(handler) as provider:+ assert await provider._loaded_context_length() == 4096+ now = 39.9+ assert await provider._loaded_context_length() == 4096+ now = 40.0+ assert await provider._loaded_context_length() == 8192+ assert calls == 2+++async def test_concurrent_requests_share_lookup_but_validate_their_own_prompt():+ body = GatedBody()+ calls = 0++ def handler(request):+ nonlocal calls+ calls += 1+ return httpx2.Response(200, stream=body)++ async def validate(provider, estimate):+ try:+ await provider._validate_context_budget(estimate)+ except ExecutionFailure as failure:+ return failure.kind+ return None++ async with provider_with_http(handler) as provider, asyncio.TaskGroup() as group:+ small = group.create_task(validate(provider, 1))+ await asyncio.wait_for(body.started.wait(), 2)+ large = group.create_task(validate(provider, 901))+ await asyncio.sleep(0)+ assert not small.done() and not large.done()+ assert calls == 1+ body.release.set()+ assert await small is None+ assert await large is FailureKind.CONTEXT_WINDOW_EXCEEDED+ assert calls == 1+ assert body.close_count == 1++[email protected]("cancel_owner", [False, True])+async def test_cancelled_context_lookup_does_not_poison_other_requests(cancel_owner):+ body = GatedBody()+ calls = 0++ def handler(request):+ nonlocal calls+ calls += 1+ return (+ httpx2.Response(200, stream=body) if calls == 1 else metadata_response(4096)+ )++ async with provider_with_http(handler) as provider, asyncio.TaskGroup() as group:+ owner = group.create_task(provider._loaded_context_length())+ await asyncio.wait_for(body.started.wait(), 2)+ waiter = group.create_task(provider._loaded_context_length())+ await asyncio.sleep(0)+ cancelled = owner if cancel_owner else waiter+ cancelled.cancel()+ with pytest.raises(asyncio.CancelledError):+ await cancelled+ if cancel_owner:+ assert await asyncio.wait_for(waiter, 2) == 4096+ assert calls == 2+ else:+ assert not owner.done()+ assert body.close_count == 0+ body.release.set()+ assert await owner == 1000+ assert calls == 1+ assert body.close_count == 1+ assert not provider._client.is_closed()++[email protected]("wire", ["messages", "responses"])+async def test_request_timeout_while_waiting_for_cache_leaves_refresh_running(wire):+ body = GatedBody()+ calls = 0++ def handler(request):+ nonlocal calls+ calls += 1+ return httpx2.Response(200, stream=body)++ async with provider_with_http(handler) as provider, asyncio.TaskGroup() as group:+ owner = group.create_task(provider._loaded_context_length())+ await asyncio.wait_for(body.started.wait(), 2)+ executor = ProviderExecutor(+ AsyncMock(return_value=provider), progress_timeout_seconds=0.05+ )+ routed = (+ _routed_request() if wire == "messages" else _routed_responses_request()+ )+ stream = getattr(executor, f"stream_{wire}")(+ routed, raw_log_payload={}, request_id="cache-wait-timeout"+ )+ async with asyncio.timeout(2):+ with pytest.raises(ExecutionFailure) as error:+ await anext(stream)+ assert error.value.kind is FailureKind.TIMEOUT+ assert not owner.done()+ assert body.close_count == 0+ body.release.set()+ assert await owner == 1000+ assert calls == 1++[email protected]("wire", ["messages", "responses"])+async def test_closing_validated_stream_closes_upstream_and_releases_admission(wire):+ # Cross the transport's 64 KiB holdback before closing a publicly started stream.+ body = GatedBody(+ prefix=completion_chunk(finish_reason=None, content="hello " * 12_000),+ content=b"data: [DONE]\n\n",+ )+ generations = 0++ def handler(request):+ nonlocal generations+ if request.url.path.endswith("/api/v0/models"):+ return metadata_response()+ generations += 1+ if generations > 1:+ return completion_response()+ return httpx2.Response(+ 200, headers={"content-type": "text/event-stream"}, stream=body+ )++ async with provider_with_http(handler) as provider:+ stream = stream_request(provider, wire)+ try:+ async with asyncio.timeout(2):+ first = await anext(stream)+ assert (+ "message_start" in first+ if wire == "messages"+ else "response.created" in first+ )+ finally:+ await stream.aclose()+ assert body.close_count == 1+ assert not provider._client.is_closed()+ async with asyncio.timeout(2):+ output = "".join([event async for event in stream_request(provider, wire)])+ assert "hello" in output+ assert generations == 2++[email protected]("wire", ["messages", "responses"])+async def test_context_rejection_before_first_event_allows_fallback(wire):+ requests = []++ def handler(request):+ requests.append(request)+ return metadata_response(1)++ async with provider_with_http(handler) as provider:+ fallback = FakeProvider() if wire == "messages" else ResponsesFakeProvider()+ providers = {"provider": provider, "fallback": fallback}+ executor = ProviderExecutor(+ AsyncMock(side_effect=lambda name: providers[name]),+ progress_timeout_seconds=2,+ )+ route = _routed_request if wire == "messages" else _routed_responses_request+ stream = getattr(executor, f"stream_{wire}")(+ route(_target("fallback", "fallback-model")),+ raw_log_payload={},+ request_id="context-fallback",+ )+ output = [event async for event in stream]+ assert output == [+ "event: message_stop\ndata: {}\n\n"+ if wire == "messages"+ else "event: response.completed\ndata: {}\n\n"+ ]+ assert len(fallback.stream_calls) == 1+ assert fallback.stream_close_calls == 1+ assert [request.url.path for request in requests] == ["/api/v0/models"]+++async def test_context_cache_belongs_to_each_provider_instance():+ async with (+ provider_with_http(lambda request: metadata_response(4096)) as first,+ provider_with_http(lambda request: metadata_response(8192)) as second,+ ):+ assert await first._loaded_context_length() == 4096+ assert await second._loaded_context_length() == 8192diff --git a/tests/providers/test_minimax.py b/tests/providers/test_minimax.pyindex d98e4d19..21570795 100644--- a/tests/providers/test_minimax.py+++ b/tests/providers/test_minimax.py@@ -17,6 +17,7 @@ from free_claude_code.core.anthropic.stream_contracts import (from free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.support import (REASONING_OFF,+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -24,13 +25,11 @@ from tests.providers.support import ()-class AsyncStream:+class AsyncStream(SDKStreamDouble):def __init__(self, chunks):self._chunks = chunksself.closed = False-- def __aiter__(self):- return self._iter()+ super().__init__(self._iter(), close=self.aclose)async def _iter(self):for chunk in self._chunks:diff --git a/tests/providers/test_mistral.py b/tests/providers/test_mistral.pyindex d84d70a1..e3b05443 100644--- a/tests/providers/test_mistral.py+++ b/tests/providers/test_mistral.py@@ -15,6 +15,7 @@ from free_claude_code.providers.mistral import MistralProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,+ SDKStreamDouble,immediate_admission,make_provider_config,reasoning_for,@@ -279,7 +280,7 @@ async def test_stream_messages_text(mistral_provider):with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -312,7 +313,7 @@ async def test_stream_messages_reasoning_content(mistral_provider):with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -349,7 +350,7 @@ async def test_stream_messages_native_mistral_thinking_chunk(mistral_provider):with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -381,7 +382,7 @@ async def test_stream_messages_native_mistral_text_chunk(mistral_provider):with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -415,7 +416,7 @@ async def test_stream_messages_preserves_native_thinking_and_string_text(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -453,7 +454,7 @@ async def test_stream_messages_preserves_native_reasoning_and_string_text(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -493,7 +494,7 @@ async def test_stream_messages_preserves_mixed_native_content_array(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -532,7 +533,7 @@ async def test_stream_messages_ignores_unknown_native_content_chunks(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in mistral_provider.stream_messages(req)]@@ -572,7 +573,7 @@ async def test_stream_messages_suppresses_native_mistral_thinking_when_disabled(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event@@ -637,7 +638,7 @@ async def test_stream_messages_retries_without_mistral_reasoning_on_rejection(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [error, mock_stream()]+ mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]events = [e@@ -708,7 +709,7 @@ async def test_stream_messages_reasoning_retry_preserves_visible_text_and_tools(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [error, mock_stream()]+ mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]events = [e@@ -750,7 +751,7 @@ async def test_stream_messages_retries_on_mistral_422_reasoning_rejection(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [error, mock_stream()]+ mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]events = [e@@ -807,7 +808,7 @@ async def test_stream_messages_retries_when_model_disables_reasoning_input(with patch.object(mistral_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [error, mock_stream()]+ mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]events = [e async for e in mistral_provider.stream_messages(req)]diff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.pyindex 133b76f3..7a8df114 100644--- a/tests/providers/test_nvidia_nim.py+++ b/tests/providers/test_nvidia_nim.py@@ -28,6 +28,7 @@ from tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,REASONING_ON,+ SDKStreamDouble,immediate_admission,make_provider_config,reasoning_for,@@ -563,7 +564,7 @@ async def test_stream_messages_text(nim_provider):with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in nim_provider.stream_messages(req)]@@ -611,7 +612,7 @@ async def test_stream_messages_thinking_reasoning_content(nim_provider):with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in nim_provider.stream_messages(req)]@@ -653,7 +654,7 @@ async def test_stream_messages_suppresses_thinking_when_disabled(provider_configwith patch.object(provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in provider.stream_messages(req, reasoning=REASONING_OFF)@@ -700,7 +701,7 @@ async def test_stream_messages_retries_without_chat_template(provider_config):with patch.object(provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [first_error, mock_stream()]+ mock_create.side_effect = [first_error, SDKStreamDouble(mock_stream())]events = [e async for e in provider.stream_messages(req, reasoning=REASONING_ON)@@ -757,7 +758,7 @@ async def test_stream_messages_retries_without_chat_template_kwargs_issue_993(with patch.object(provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [first_error, mock_stream()]+ mock_create.side_effect = [first_error, SDKStreamDouble(mock_stream())]events = [e async for e in provider.stream_messages(req, reasoning=REASONING_ON)@@ -830,7 +831,7 @@ async def test_tool_call_stream(nim_provider):with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in nim_provider.stream_messages(req)]@@ -872,7 +873,7 @@ async def test_native_minimax_tool_markup_becomes_anthropic_tool_use(nim_providewith patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in nim_provider.stream_messages(req)]@@ -920,7 +921,7 @@ async def test_native_minimax_reasoning_markup_becomes_anthropic_tool_use(with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in nim_provider.stream_messages(req)]@@ -951,8 +952,11 @@ async def test_native_minimax_markup_without_tools_retries_without_leaking(async def recovered_stream():yield _content_chunk("Recovered safely.", finish_reason="stop")- attempts = [native_stream() for _ in range(UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS - 1)]- attempts.append(recovered_stream())+ attempts = [+ SDKStreamDouble(native_stream())+ for _ in range(UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS - 1)+ ]+ attempts.append(SDKStreamDouble(recovered_stream()))with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:@@ -1001,7 +1005,7 @@ async def test_native_minimax_tool_markup_restores_nim_argument_aliases(nim_provwith patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in nim_provider.stream_messages(req)]@@ -1052,7 +1056,10 @@ async def test_malformed_native_minimax_tool_call_retries_without_leaking(with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [malformed_stream(), recovered_stream()]+ mock_create.side_effect = [+ SDKStreamDouble(malformed_stream()),+ SDKStreamDouble(recovered_stream()),+ ]events = [event async for event in nim_provider.stream_messages(req)]@@ -1118,7 +1125,10 @@ async def test_midstream_native_tool_suffix_failure_recovers_without_duplicationside_effect=immediate_holdback,),):- mock_create.side_effect = [malformed_stream(), recovered_stream()]+ mock_create.side_effect = [+ SDKStreamDouble(malformed_stream()),+ SDKStreamDouble(recovered_stream()),+ ]events = [event async for event in nim_provider.stream_messages(req)]@@ -1162,7 +1172,7 @@ async def test_stream_messages_restores_aliased_tool_arguments(nim_provider):with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in nim_provider.stream_messages(req)]@@ -1219,7 +1229,7 @@ async def test_stream_messages_buffers_chunked_aliased_tool_arguments(nim_providwith patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in nim_provider.stream_messages(req)]@@ -1265,7 +1275,7 @@ async def test_stream_messages_restores_nested_aliased_tool_arguments(nim_providwith patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in nim_provider.stream_messages(req)]@@ -1311,7 +1321,7 @@ async def test_stream_messages_task_tool_still_forces_background_false(nim_proviwith patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [e async for e in nim_provider.stream_messages(req)]@@ -1341,7 +1351,7 @@ async def test_stream_messages_retries_without_reasoning_budget(nim_provider):with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [error, mock_stream()]+ mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]events = [e@@ -1388,7 +1398,7 @@ async def test_stream_messages_retries_without_budget_for_thinking_token_error(with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [error, mock_stream()]+ mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]events = [e@@ -1456,7 +1466,7 @@ async def test_stream_messages_retries_without_reasoning_content(nim_provider):with patch.object(nim_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.side_effect = [error, mock_stream()]+ mock_create.side_effect = [error, SDKStreamDouble(mock_stream())]events = [e async for e in nim_provider.stream_messages(req)]diff --git a/tests/providers/test_nvidia_nim_degraded_retry.py b/tests/providers/test_nvidia_nim_degraded_retry.pyindex 13d0db90..fef34494 100644--- a/tests/providers/test_nvidia_nim_degraded_retry.py+++ b/tests/providers/test_nvidia_nim_degraded_retry.py@@ -21,7 +21,7 @@ from free_claude_code.providers.failure_policy import (from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.open_router import OpenRouterProviderfrom tests.providers.request_factory import make_messages_request-from tests.providers.support import make_provider_config+from tests.providers.support import SDKStreamDouble, make_provider_config_FUNCTION_ID = "87ea0ddc-cff1-4bca-bf8b-3bd98a35ddd0"_DEGRADED_DETAIL = f"Function id '{_FUNCTION_ID}': DEGRADED function cannot be invoked"@@ -112,7 +112,7 @@ def _successful_stream(text: str = "Recovered"):async def stream():yield chunk- return stream()+ return SDKStreamDouble(stream())def _nim(admission: ProviderAdmissionController) -> NvidiaNimProvider:diff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.pyindex c2c1a15e..80577ac2 100644--- a/tests/providers/test_ollama.py+++ b/tests/providers/test_ollama.py@@ -16,6 +16,7 @@ from free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -190,7 +191,7 @@ async def test_stream_messages_uses_shared_openai_chat_provider() -> None:provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=stream(),+ return_value=SDKStreamDouble(stream()),) as create:output = "".join([@@ -230,7 +231,7 @@ async def test_cloud_stream_maps_ollama_reasoning_delta_to_anthropic_thinking()client._client.chat.completions,"create",new_callable=AsyncMock,- return_value=stream(),+ return_value=SDKStreamDouble(stream()),):output = "".join([diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.pyindex a82d290b..0be5ae83 100644--- a/tests/providers/test_open_router.py+++ b/tests/providers/test_open_router.py@@ -22,19 +22,18 @@ from free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,+ SDKStreamDouble,immediate_admission,make_provider_config,reasoning_for,)-class AsyncStream:+class AsyncStream(SDKStreamDouble):def __init__(self, chunks):self._chunks = chunksself.closed = False-- def __aiter__(self):- return self._iter()+ super().__init__(self._iter(), close=self.aclose)async def _iter(self):for chunk in self._chunks:diff --git a/tests/providers/test_openai_chat_output_cap.py b/tests/providers/test_openai_chat_output_cap.pyindex 3e044842..0e953cb5 100644--- a/tests/providers/test_openai_chat_output_cap.py+++ b/tests/providers/test_openai_chat_output_cap.py@@ -18,6 +18,7 @@ from free_claude_code.providers.openai_chat.output_cap import ()from tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,)@@ -262,7 +263,7 @@ async def test_create_stream_clamps_and_learns_on_cap_rejection(groq_provider):"param": "max_completion_tokens",},)- create = AsyncMock(side_effect=[error, object()])+ create = AsyncMock(side_effect=[error, SDKStreamDouble(AsyncMock())])with patch.object(groq_provider._client.chat.completions, "create", create):(@@ -275,6 +276,7 @@ async def test_create_stream_clamps_and_learns_on_cap_rejection(groq_provider):groq_provider._admission.start_execution(),ProviderOperationKind.GENERATION,)+ await _stream.aclose()await attempt.aclose()assert create.call_count == 2@@ -295,7 +297,7 @@ async def test_learned_cap_clamps_next_request_without_a_400(groq_provider):model = body["model"]groq_provider._chat._model_output_caps[model] = 40960- create = AsyncMock(return_value=object())+ create = AsyncMock(return_value=SDKStreamDouble(AsyncMock()))with patch.object(groq_provider._client.chat.completions, "create", create):(_stream,@@ -307,6 +309,7 @@ async def test_learned_cap_clamps_next_request_without_a_400(groq_provider):groq_provider._admission.start_execution(),ProviderOperationKind.GENERATION,)+ await _stream.aclose()await attempt.aclose()assert create.call_count == 1diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.pyindex 7c3471b1..94f0afc9 100644--- a/tests/providers/test_openai_chat_usage.py+++ b/tests/providers/test_openai_chat_usage.py@@ -33,6 +33,7 @@ from free_claude_code.providers.openai_chat.usage import ()from tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,)@@ -370,12 +371,14 @@ async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokens),)create = AsyncMock(- return_value=_stream(- [- _chunk(content="hello"),- _chunk(finish_reason="stop"),- _chunk(usage=usage),- ]+ return_value=SDKStreamDouble(+ _stream(+ [+ _chunk(content="hello"),+ _chunk(finish_reason="stop"),+ _chunk(usage=usage),+ ]+ )))@@ -422,12 +425,14 @@ async def test_openai_chat_nonstream_message_uses_final_cache_partition():),)create = AsyncMock(- return_value=_stream(- [- _chunk(content="hello"),- _chunk(finish_reason="stop"),- _chunk(usage=usage),- ]+ return_value=SDKStreamDouble(+ _stream(+ [+ _chunk(content="hello"),+ _chunk(finish_reason="stop"),+ _chunk(usage=usage),+ ]+ )))@@ -459,12 +464,14 @@ async def test_openai_chat_responses_stream_preserves_cache_write_usage():),)create = AsyncMock(- return_value=_stream(- [- _chunk(content="hello"),- _chunk(finish_reason="stop"),- _chunk(usage=usage),- ]+ return_value=SDKStreamDouble(+ _stream(+ [+ _chunk(content="hello"),+ _chunk(finish_reason="stop"),+ _chunk(usage=usage),+ ]+ )))@@ -495,11 +502,13 @@ async def test_openai_chat_stream_keeps_response_model_separate_from_upstream_moprovider = _UsageTestProvider()request = make_messages_request(model="upstream/model")create = AsyncMock(- return_value=_stream(- [- _chunk(content="hello"),- _chunk(finish_reason="stop"),- ]+ return_value=SDKStreamDouble(+ _stream(+ [+ _chunk(content="hello"),+ _chunk(finish_reason="stop"),+ ]+ )))diff --git a/tests/providers/test_openai_compat_5xx_retry.py b/tests/providers/test_openai_compat_5xx_retry.pyindex 86cc0894..b848335b 100644--- a/tests/providers/test_openai_compat_5xx_retry.py+++ b/tests/providers/test_openai_compat_5xx_retry.py@@ -12,6 +12,7 @@ from free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,)@@ -71,7 +72,10 @@ async def test_nim_stream_retries_on_openai_5xx_then_streams(status_code):new_callable=AsyncMock,) as mock_create,):- mock_create.side_effect = [_internal_5xx(status_code), mock_stream()]+ mock_create.side_effect = [+ _internal_5xx(status_code),+ SDKStreamDouble(mock_stream()),+ ]events = [e async for e in provider.stream_messages(req)]assert mock_create.await_count == 2@@ -115,7 +119,7 @@ async def test_nim_stream_retries_on_pre_stream_connection_error_then_streams():new_callable=AsyncMock,) as mock_create,):- mock_create.side_effect = [_connection_error(), mock_stream()]+ mock_create.side_effect = [_connection_error(), SDKStreamDouble(mock_stream())]events = [e async for e in provider.stream_messages(req)]assert mock_create.await_count == 2diff --git a/tests/providers/test_sambanova.py b/tests/providers/test_sambanova.pyindex aa84e760..dc82b219 100644--- a/tests/providers/test_sambanova.py+++ b/tests/providers/test_sambanova.py@@ -9,6 +9,7 @@ from free_claude_code.config.provider_catalog import SAMBANOVA_DEFAULT_BASEfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -127,7 +128,7 @@ async def test_stream_messages_text(sambanova_provider):with patch.object(sambanova_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in sambanova_provider.stream_messages(make_request())@@ -162,7 +163,7 @@ async def test_stream_messages_tool_call(sambanova_provider):with patch.object(sambanova_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in sambanova_provider.stream_messages(make_request())@@ -198,7 +199,7 @@ async def test_stream_messages_reasoning_content(sambanova_provider):with patch.object(sambanova_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in sambanova_provider.stream_messages(make_request())diff --git a/tests/providers/test_sdk_stream_lifecycle.py b/tests/providers/test_sdk_stream_lifecycle.pynew file mode 100644index 00000000..37082ae8--- /dev/null+++ b/tests/providers/test_sdk_stream_lifecycle.py@@ -0,0 +1,396 @@+"""Real SDK response ownership across provider stream boundaries."""++import asyncio+from contextlib import asynccontextmanager+from unittest.mock import patch++import httpx2+import pytest+from openai import AsyncOpenAI++from free_claude_code.config.nim import NimSettings+from free_claude_code.core.async_iterators import AsyncCloseable+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY+from free_claude_code.providers.admission import (+ ProviderAdmissionController,+ ProviderOperationKind,+)+from free_claude_code.providers.mistral import MistralProvider+from free_claude_code.providers.mistral.reasoning import normalize_mistral_stream+from free_claude_code.providers.nvidia_nim import NvidiaNimProvider+from free_claude_code.providers.nvidia_nim.native_tool_stream import (+ NimNativeToolProtocolError,+)+from free_claude_code.providers.openai_responses import OpenAIResponsesTransport+from free_claude_code.providers.openai_stream import OpenAIStreamAdapter+from tests.providers.request_factory import make_messages_request+from tests.providers.support import make_provider_config, profiled_provider+from tests.providers.test_openai_responses_transport import (+ _completed_event,+ _sse,+ _text_delta,+)+++class ResponseBody(httpx2.AsyncByteStream):+ def __init__(self, prefix=b"", suffix=b"", *, close_error=None, block_close=False):+ self.prefix = prefix+ self.suffix = suffix+ self.read_started = asyncio.Event()+ self.read_release = asyncio.Event()+ self.close_started = asyncio.Event()+ self.close_release = asyncio.Event()+ self.close_error = close_error+ self.block_close = block_close+ self.close_count = 0++ async def __aiter__(self):+ if self.prefix:+ yield self.prefix+ self.read_started.set()+ await self.read_release.wait()+ yield self.suffix++ async def aclose(self):+ self.close_count += 1+ self.close_started.set()+ if self.block_close:+ await self.close_release.wait()+ if self.close_error is not None:+ raise self.close_error+++def _chat_chunk(text, *, finish_reason=None):+ return _sse(+ {+ "id": "chat_test",+ "object": "chat.completion.chunk",+ "created": 0,+ "model": "model",+ "choices": [+ {"index": 0, "delta": {"content": text}, "finish_reason": finish_reason}+ ],+ }+ ).encode()+++def _chunks(kind, text):+ if kind == "responses":+ return _sse(_text_delta(text)).encode(), _sse(_completed_event()).encode()+ return _chat_chunk(text), _chat_chunk(+ "", finish_reason="stop"+ ) + b"data: [DONE]\n\n"+++def _response(body):+ return httpx2.Response(+ 200, headers={"content-type": "text/event-stream"}, stream=body+ )+++@asynccontextmanager+async def _harness(kind, handler):+ client = AsyncOpenAI(+ api_key="test",+ base_url="https://provider.invalid/v1",+ max_retries=0,+ http_client=httpx2.AsyncClient(transport=httpx2.MockTransport(handler)),+ )+ admission = ProviderAdmissionController(+ provider_name="TEST",+ rate_limit=1_000_000,+ rate_window=1.0,+ max_concurrency=1,+ base_delay=0.0,+ max_delay=0.0,+ jitter=0.0,+ )+ retained_sdk_streams = []+ endpoint = client.responses if kind == "responses" else client.chat.completions+ create = endpoint.create++ async def retain_stream(**kwargs):+ stream = await create(**kwargs)+ retained_sdk_streams.append(stream)+ return stream++ try:+ with (+ patch.object(endpoint, "create", side_effect=retain_stream),+ patch(+ "free_claude_code.providers.openai_chat.provider.create_chat_client",+ return_value=client,+ ),+ ):+ config = make_provider_config(+ api_key="test", base_url="https://provider.invalid/v1"+ )+ if kind == "responses":+ provider = OpenAIResponsesTransport(+ client=client,+ admission=admission,+ provider_name="TEST",+ read_timeout_s=2.0,+ log_raw_sse_events=False,+ )+ elif kind == "mistral":+ provider = MistralProvider(config, admission=admission)+ elif kind == "nim":+ provider = NvidiaNimProvider(+ config, nim_settings=NimSettings(), admission=admission+ )+ else:+ provider = profiled_provider("cerebras", config, admission=admission)+ yield provider, client, admission+ finally:+ # Keep references until after assertions; GC must not conceal missing cleanup.+ for stream in retained_sdk_streams:+ await stream.close()+ await client.close()+++def _public_stream(provider, wire):+ kwargs = {}+ if isinstance(provider, OpenAIResponsesTransport):+ kwargs = {+ "input_tokens": 1,+ "request_id": "lifecycle",+ "response_model": "model",+ "reasoning": DEFAULT_REASONING_POLICY,+ }+ request = (+ make_messages_request("model")+ if wire == "messages"+ else OpenAIResponsesRequest(model="model", input="hello")+ )+ return getattr(provider, f"stream_{wire}")(request, **kwargs)+++async def _assert_admission_available(admission):+ async with asyncio.timeout(1):+ attempt = await admission.start_execution().open_attempt(+ ProviderOperationKind.GENERATION+ )+ await attempt.aclose()++[email protected]("kind", ["chat", "mistral", "nim", "responses"])[email protected]("wire", ["messages", "responses"])[email protected]("termination", ["close", "cancel", "complete"])+async def test_sdk_body_lifetime(kind, wire, termination):+ prefix, suffix = _chunks(kind, "x" * 70_000)+ body = ResponseBody(prefix if termination != "cancel" else b"", suffix)+ if termination == "complete":+ body.read_release.set()++ def handler(request):+ if request.url.path.endswith("/health"):+ return httpx2.Response(200, json={"ok": True})+ return _response(body)++ async with _harness(kind, handler) as (+ provider,+ client,+ admission,+ ):+ stream = _public_stream(provider, wire)+ assert isinstance(stream, AsyncCloseable)+ task = None+ try:+ if termination == "cancel":+ task = asyncio.create_task(anext(stream))+ await asyncio.wait_for(body.read_started.wait(), timeout=2)+ task.cancel()+ with pytest.raises(asyncio.CancelledError):+ await task+ elif termination == "complete":+ async with asyncio.timeout(2):+ output = "".join([event async for event in stream])+ assert "x" * 100 in output+ else:+ async with asyncio.timeout(2):+ assert await anext(stream)+ await stream.aclose()+ await stream.aclose()+ assert body.close_count == 1+ assert not client.is_closed()+ await _assert_admission_available(admission)+ # The same client must still be able to make another SDK request.+ body.read_release.set()+ fresh = await client.get("/health", cast_to=httpx2.Response)+ assert fresh.status_code == 200+ finally:+ if task is not None and not task.done():+ task.cancel()+ await asyncio.gather(task, return_exceptions=True)+ body.read_release.set()+ await stream.aclose()+++async def test_cancelled_normalizer_construction_cleanup_releases_admission():+ body = ResponseBody(block_close=True)+ async with _harness("chat", lambda request: _response(body)) as (+ provider,+ client,+ admission,+ ):+ task = None+ with patch.object(+ provider._behavior,+ "normalize_stream",+ side_effect=ValueError("invalid normalization"),+ ):+ try:+ task = asyncio.create_task(+ provider._chat._create_stream(+ {"model": "model", "messages": []},+ admission.start_execution(),+ ProviderOperationKind.GENERATION,+ )+ )+ await asyncio.wait_for(body.close_started.wait(), timeout=2)+ task.cancel()+ with pytest.raises(asyncio.CancelledError):+ await task+ await _assert_admission_available(admission)+ assert not client.is_closed()+ finally:+ body.close_release.set()+ if task is not None:+ if not task.done():+ task.cancel()+ await asyncio.gather(task, return_exceptions=True)+++async def test_mistral_cleanup_preserves_normalization_error():+ body = ResponseBody(+ _chat_chunk("hello"), close_error=RuntimeError("cleanup secret-token")+ )+ client = AsyncOpenAI(+ api_key="test",+ base_url="https://provider.invalid/v1",+ max_retries=0,+ http_client=httpx2.AsyncClient(+ transport=httpx2.MockTransport(lambda request: _response(body))+ ),+ )+ sdk_stream = await client.chat.completions.create(+ model="model", messages=[], stream=True+ )+ source = OpenAIStreamAdapter(sdk_stream)+ stream = normalize_mistral_stream(source)+ original = ValueError("invalid normalization")+ try:+ with (+ patch(+ "free_claude_code.providers.mistral.reasoning.normalize_mistral_chunk",+ side_effect=original,+ ),+ patch("free_claude_code.providers.http.trace_event") as trace,+ pytest.raises(ValueError) as caught,+ ):+ await anext(stream)+ assert caught.value is original+ assert body.close_count == 1+ assert not client.is_closed()+ assert trace.call_args.kwargs["preserved_exc_type"] == "ValueError"+ assert trace.call_args.kwargs["close_exc_type"] == "RuntimeError"+ assert "secret-token" not in repr(trace.call_args)+ finally:+ body.close_error = None+ body.read_release.set()+ assert isinstance(stream, AsyncCloseable)+ await stream.aclose()+ await sdk_stream.close()+ await client.close()++[email protected]("wire", ["messages", "responses"])+async def test_nim_parser_failure_closes_response_before_retry(wire):+ namespace = "]<]minimax[>["+ malformed = (+ f"{namespace}<tool_call>"+ f'{namespace}<invoke name="">'+ f"{namespace}</invoke>"+ f"{namespace}</tool_call>"+ )+ body = ResponseBody(_chat_chunk(malformed, finish_reason="stop"))+ requests = 0++ def handler(request):+ nonlocal requests+ requests += 1+ if requests == 1:+ return _response(body)+ assert body.close_count == 1+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ content=_chat_chunk("recovered", finish_reason="stop")+ + b"data: [DONE]\n\n",+ )++ async with _harness("nim", handler) as (provider, client, admission):+ async with asyncio.timeout(2):+ output = "".join([event async for event in _public_stream(provider, wire)])+ assert "recovered" in output+ assert namespace not in output+ assert requests == 2+ assert not client.is_closed()+ await _assert_admission_available(admission)+++ "operation",+ [+ ProviderOperationKind.GENERATION,+ ProviderOperationKind.CONTINUATION,+ ProviderOperationKind.TOOL_REPAIR,+ ],+)+async def test_normalizer_construction_failure_closes_response_before_retry(operation):+ bodies = [ResponseBody(), ResponseBody()]+ remaining = iter(bodies)++ def handler(request):+ body = next(remaining)+ if body is bodies[1]:+ assert bodies[0].close_count == 1+ return _response(body)++ async with _harness("chat", handler) as (provider, client, admission):+ normalize = provider._behavior.normalize_stream+ calls = 0++ def fail_once(stream, body):+ nonlocal calls+ calls += 1+ if calls == 1:+ raise NimNativeToolProtocolError("invalid normalization")+ assert bodies[0].close_count == 1+ return normalize(stream, body)++ with patch.object(+ provider._behavior, "normalize_stream", side_effect=fail_once+ ):+ async with asyncio.timeout(2):+ stream, _, attempt, _ = await provider._chat._create_stream(+ {"model": "model", "messages": []},+ admission.start_execution(),+ operation,+ )+ try:+ assert calls == 2+ assert bodies[0].close_count == 1+ assert not client.is_closed()+ finally:+ await stream.aclose()+ await attempt.aclose()+ assert bodies[1].close_count == 1+ await _assert_admission_available(admission)diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 18c614a5..ed3f5c29 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -45,6 +45,7 @@ from free_claude_code.providers.stream_recovery import TruncatedProviderStreamErfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -57,15 +58,13 @@ from tests.providers.test_nvidia_nim import ()-class AsyncStreamMock:+class AsyncStreamMock(SDKStreamDouble):"""Async iterable mock that yields chunks then optionally raises."""def __init__(self, chunks, error=None):self._chunks = chunksself._error = error-- def __aiter__(self):- return self._aiter()+ super().__init__(self._aiter())async def _aiter(self):for chunk in self._chunks:@@ -97,17 +96,19 @@ class ClosableAsyncStreamMock(AsyncStreamMock):if self._close_error is not None:raise self._close_error+ async def close(self):+ await super().close()+ await self.aclose()+-class BlockingClosableAsyncStreamMock:+class BlockingClosableAsyncStreamMock(SDKStreamDouble):"""Async stream that blocks until its consumer is cancelled."""def __init__(self, *, close_error=None):self.entered = asyncio.Event()self.close_calls = 0self._close_error = close_error-- def __aiter__(self):- return self._aiter()+ super().__init__(self._aiter(), close=self.aclose)async def _aiter(self):self.entered.set()@@ -1658,14 +1659,14 @@ class TestStreamingExceptionHandling:"""A truncated text stream is continued and duplicate overlap is trimmed."""provider = _make_provider()request = _make_request()- stream_mock = AsyncStreamMock([_make_chunk(content="hello wor")])-with (patch.object(provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=stream_mock,+ side_effect=lambda **kwargs: AsyncStreamMock(+ [_make_chunk(content="hello wor")]+ ),),patch.object(_OpenAIChatStreamRunner,@@ -2435,14 +2436,12 @@ class TestStreamingExceptionHandling:tool_chunk = _make_tool_calls_chunk(name="echo_smoke", arguments='{"message":', tool_id="call_repair")- stream_mock = AsyncStreamMock([tool_chunk])-with (patch.object(provider._client.chat.completions,"create",new_callable=AsyncMock,- return_value=stream_mock,+ side_effect=lambda **kwargs: AsyncStreamMock([tool_chunk]),),patch.object(_OpenAIChatStreamRunner,diff --git a/tests/providers/test_vercel.py b/tests/providers/test_vercel.pyindex 91843eaf..daaa3883 100644--- a/tests/providers/test_vercel.py+++ b/tests/providers/test_vercel.py@@ -11,6 +11,7 @@ from free_claude_code.config.provider_catalog import VERCEL_AI_GATEWAY_DEFAULT_Bfrom free_claude_code.core.model_capabilities import ModelInputModalityfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -163,7 +164,7 @@ async def test_stream_messages_text(vercel_provider):with patch.object(vercel_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in vercel_provider.stream_messages(make_request())@@ -195,7 +196,7 @@ async def test_stream_messages_reasoning_content(vercel_provider):with patch.object(vercel_provider._client.chat.completions, "create", new_callable=AsyncMock) as mock_create:- mock_create.return_value = mock_stream()+ mock_create.return_value = SDKStreamDouble(mock_stream())events = [event async for event in vercel_provider.stream_messages(make_request())diff --git a/tests/providers/test_zenmux.py b/tests/providers/test_zenmux.pyindex 5eaed095..91cd6031 100644--- a/tests/providers/test_zenmux.py+++ b/tests/providers/test_zenmux.py@@ -28,6 +28,7 @@ from free_claude_code.core.reasoning import (from free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProviderfrom tests.providers.support import (+ SDKStreamDouble,immediate_admission,make_provider_config,profiled_provider,@@ -58,13 +59,11 @@ def _request(**overrides: Any) -> MessagesRequest:return MessagesRequest.model_validate(payload)-class AsyncStream:+class AsyncStream(SDKStreamDouble):def __init__(self, chunks: list[Any]) -> None:self._chunks = chunksself.closed = False-- def __aiter__(self):- return self._iter()+ super().__init__(self._iter(), close=self.aclose)async def _iter(self):for chunk in self._chunks:diff --git a/uv.lock b/uv.lockindex 59db4e58..05ebf75c 100644--- a/uv.lock+++ b/uv.lock@@ -598,7 +598,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "6.2.29"+version = "6.2.30"source = { editable = "." }dependencies = [{ name = "aiohttp" },