Skip to content

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

Python

Make LM Studio validation async and fix SDK stream cleanup (#1801)

Ali Khokhar37ea947f40d5
diff --git a/pyproject.toml b/pyproject.toml
index 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.py
index 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, and
heuristic recovery on top.
"""
+import asyncio
+import sys
import time
from collections.abc import AsyncIterator, Mapping
-import httpx
+import httpx2
from loguru import logger
+from openai import Omit
from free_claude_code.application.model_metadata import ProviderModelInfo
from free_claude_code.core.anthropic import ReasoningReplayMode, get_token_count
@@ -35,6 +38,7 @@ from free_claude_code.providers.endpoint_types import EndpointContext
from free_claude_code.providers.failure_policy import (
context_window_exceeded_provider_failure,
)
+from free_claude_code.providers.http import close_provider_stream
from 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 stream
def 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 value
diff --git a/src/free_claude_code/providers/mistral/reasoning.py b/src/free_claude_code/providers/mistral/reasoning.py
index 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 sys
from collections.abc import AsyncIterator, Mapping, Sequence
from copy import deepcopy
from types import SimpleNamespace
@@ -9,7 +10,7 @@ from typing import Any
import openai
from 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_stream
MISTRAL_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.py
index 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 OpenAIStreamAdapter
from 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:
raise
finally:
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_failure
diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.py
index 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 OpenAIStreamAdapter
from 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 = True
async for upstream_event in stream:
diff --git a/src/free_claude_code/providers/openai_stream.py b/src/free_claude_code/providers/openai_stream.py
new file mode 100644
index 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.py
index 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 ReasoningCapability
from 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 = starved
self.error = error
self.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.error
for text, reasoning, finish in (
diff --git a/tests/providers/support.py b/tests/providers/support.py
index 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, Callable
import httpx2
from openai import AsyncOpenAI
from free_claude_code.application.reasoning import client_reasoning_policy
from free_claude_code.core.anthropic.models import MessagesRequest
+from free_claude_code.core.async_iterators import AsyncCloseable
from free_claude_code.core.reasoning import ReasoningPolicy
from free_claude_code.providers.admission import ProviderAdmissionController
from 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.py
index 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_BASE
from tests.providers.request_factory import make_messages_request
from 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.py
index 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 = chunks
self.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.py
index 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.py
index 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_BASE
from free_claude_code.core.model_capabilities import ModelInputModality
from tests.providers.request_factory import make_messages_request
from 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.py
index 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 InvalidRequestError
from free_claude_code.config.provider_catalog import COHERE_DEFAULT_BASE
from tests.providers.request_factory import make_messages_request
from 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.py
index 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 DeepSeekProvider
from 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 = [
chunk
diff --git a/tests/providers/test_execution_failure_boundary.py b/tests/providers/test_execution_failure_boundary.py
index 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 NvidiaNimProvider
from tests.providers.request_factory import make_messages_request
from 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 = error
self._close_error = close_error
self.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.py
index 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_request
from 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_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)]
@@ -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.py
index 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_BASE
from free_claude_code.providers.groq import GroqProvider
from tests.providers.request_factory import make_messages_request
from 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.py
index 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_request
from 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 == 1
assert 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.py
index 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 ProviderOperationKind
from free_claude_code.providers.groq import GroqProvider
from free_claude_code.providers.groq.tpm import correct_tpm_completion_budget
from 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.py
index 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 ModelInputModality
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from tests.providers.request_factory import make_messages_request
from 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 = [
event
diff --git a/tests/providers/test_kilo.py b/tests/providers/test_kilo.py
index 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 KiloProvider
from free_claude_code.providers.model_listing import ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from 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 = chunks
self.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.py
index 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 OpenAIChatProvider
from tests.providers.request_factory import make_messages_request
from 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.py
index 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 asynccontextmanager
from unittest.mock import AsyncMock, MagicMock, patch
import httpx
+import httpx2
import pytest
+from openai import AsyncOpenAI
from free_claude_code.application.errors import InvalidRequestError
from 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 ProviderAdmissionController
from 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_request
from tests.providers.support import (
REASONING_OFF,
REASONING_ON,
+ SDKStreamDouble,
immediate_admission,
make_provider_config,
)
@@ -44,11 +57,103 @@ def lmstudio_config():
@pytest.fixture
def 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, wire
context.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_EXCEEDED
admission.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.asyncio
async 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.value
assert failure.kind is FailureKind.CONTEXT_WINDOW_EXCEEDED
@@ -371,7 +552,8 @@ def test_validate_context_budget_rejects_request_over_90_percent(lmstudio_provid
assert "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 == 40960
mock_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 == 40960
mock_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() == 8192
diff --git a/tests/providers/test_minimax.py b/tests/providers/test_minimax.py
index 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 OpenAIChatProvider
from 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 = chunks
self.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.py
index 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 MistralProvider
from tests.providers.request_factory import make_messages_request
from 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.py
index 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_request
from 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_config
with 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_provide
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)]
@@ -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_prov
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)]
@@ -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_duplication
side_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_provid
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)]
@@ -1265,7 +1275,7 @@ async def test_stream_messages_restores_nested_aliased_tool_arguments(nim_provid
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)]
@@ -1311,7 +1321,7 @@ async def test_stream_messages_task_tool_still_forces_background_false(nim_provi
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)]
@@ -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.py
index 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 NvidiaNimProvider
from free_claude_code.providers.open_router import OpenRouterProvider
from 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.py
index 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 OpenAIChatProvider
from tests.providers.request_factory import make_messages_request
from 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.py
index 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 OpenAIChatProvider
from tests.providers.request_factory import make_messages_request
from 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 = chunks
self.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.py
index 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_request
from 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 == 1
diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.py
index 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_request
from 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_mo
provider = _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.py
index 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 ExecutionFailure
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from tests.providers.request_factory import make_messages_request
from 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 == 2
diff --git a/tests/providers/test_sambanova.py b/tests/providers/test_sambanova.py
index 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_BASE
from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy
from tests.providers.request_factory import make_messages_request
from 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.py
new file mode 100644
index 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.py
index 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 TruncatedProviderStreamEr
from tests.providers.request_factory import make_messages_request
from 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 = chunks
self._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 = 0
self._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.py
index 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_B
from free_claude_code.core.model_capabilities import ModelInputModality
from tests.providers.request_factory import make_messages_request
from 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.py
index 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 ModelListResponseError
from free_claude_code.providers.openai_chat import OpenAIChatProvider
from 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 = chunks
self.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.lock
index 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" },