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
Preserve provider outcomes during transport cleanup (#1510)
Ali Khokharee4f4ca4b9ee
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.mdindex eb517914..dbcd4c90 100644--- a/ARCHITECTURE.md+++ b/ARCHITECTURE.md@@ -230,9 +230,10 @@ new places to add unrelated behavior:behavior. It separates immutable vendor profiles from per-request streamexecution, recovery, request policy, and tool-call assembly. Within onerequest, the runner owns logical orchestration, a replaceable stream assembler- owns one replay epoch's ledger and parser state, the returned-attempt scope- owns physical stream cleanup, and `RecoveryController` alone owns downstream- commit policy. Shared protocol rules belong in [src/free_claude_code/core/](src/free_claude_code/core/).+ owns one replay epoch's ledger and parser state, the shared+ `ProviderAttemptScope` owns each returned physical stream and attempt, and+ `RecoveryController` alone owns downstream commit policy. Shared protocol+ rules belong in [src/free_claude_code/core/](src/free_claude_code/core/).- [messaging/workflow.py](src/free_claude_code/messaging/workflow.py) coordinates messaging runtimedependencies. Inbound turn intake, queued node execution, slash commanddependencies, and tree queue internals live in separate modules so new@@ -722,6 +723,14 @@ three scopes are explicit:its opaque execution claim, admission permit, concurrency lease, acceptancestate, one idempotent outcome, and exact-once close.+[providers/http.py](src/free_claude_code/providers/http.py) composes one+`ProviderAttempt` with at most one retained transport resource through the+idempotent `ProviderAttemptScope`. Resource cleanup is diagnostic-only: a close+failure emits redacted type metadata but cannot replace established success,+retry, terminal failure, or cancellation. Attempt cleanup remains authoritative+and always runs in the scope's `finally`, releasing the execution claim and+concurrency lease even when transport cleanup fails.+Only `ProviderExecution.open_attempt()` can enter physical provider I/O. Astrict sliding window admits the call before the concurrency bulkhead; thebulkhead is held only while that call or stream is active, never during retrydiff --git a/pyproject.toml b/pyproject.tomlindex 47e7b5ba..86ed3dce 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.13.4"+version = "5.13.5"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/http.py b/src/free_claude_code/providers/http.pyindex 1a83abb9..02f5cff8 100644--- a/src/free_claude_code/providers/http.py+++ b/src/free_claude_code/providers/http.py@@ -1,11 +1,15 @@"""Shared HTTP lifecycle helpers for upstream provider clients."""+import asyncioimport inspect-from typing import Any+from typing import Any, TypeVarfrom loguru import loggerfrom free_claude_code.core.trace import trace_event+from free_claude_code.providers.admission import ProviderAttempt++_ResourceT = TypeVar("_ResourceT")async def maybe_await_aclose(response: Any) -> None:@@ -28,7 +32,15 @@ async def close_provider_stream("""Close one stream without letting cleanup change its established outcome."""try:await maybe_await_aclose(stream)- except Exception as close_error:+ except (Exception, asyncio.CancelledError) as close_error:+ if isinstance(close_error, asyncio.CancelledError):+ current_task = asyncio.current_task()+ if (+ isinstance(active_error, asyncio.CancelledError)+ or current_task is None+ or current_task.cancelling()+ ):+ raiseactive_error_type = (type(active_error).__name__ if active_error is not None else None)@@ -49,3 +61,45 @@ async def close_provider_stream(type(close_error).__name__,active_error_type,)+++class ProviderAttemptScope:+ """Own one admitted provider attempt and its optional transport resource."""++ def __init__(+ self,+ attempt: ProviderAttempt,+ *,+ provider_name: str,+ request_id: str | None,+ ) -> None:+ self.attempt = attempt+ self._resource: object | None = None+ self._provider_name = provider_name+ self._request_id = request_id+ self._closed = False++ def retain(self, resource: _ResourceT) -> _ResourceT:+ """Retain and return the sole transport resource owned by this scope."""+ if self._closed:+ raise RuntimeError("provider attempt scope is already closed")+ if self._resource is not None:+ raise RuntimeError("provider attempt scope already owns a resource")+ self._resource = resource+ return resource++ async def aclose(self, *, active_error: BaseException | None) -> None:+ """Close transport state without masking the established operation outcome."""+ if self._closed:+ return+ self._closed = True+ try:+ if self._resource is not None:+ await close_provider_stream(+ self._resource,+ active_error=active_error,+ provider_name=self._provider_name,+ request_id=self._request_id,+ )+ finally:+ await self.attempt.aclose()diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.pyindex 0e3d3554..97b47467 100644--- a/src/free_claude_code/providers/openai_chat/provider.py+++ b/src/free_claude_code/providers/openai_chat/provider.py@@ -50,6 +50,7 @@ from free_claude_code.providers.failure_policy import (underlying_provider_error,)from free_claude_code.providers.http import (+ ProviderAttemptScope,close_provider_stream,maybe_await_aclose,)@@ -157,38 +158,6 @@ class _OpenAIChatFailureResolution:failure: ExecutionFailure | None = None-class _OpenAIChatAttemptScope:- """Own one returned provider stream and its admitted attempt."""-- def __init__(- self,- stream: Any,- attempt: ProviderAttempt,- *,- provider_name: str,- request_id: str | None,- ) -> None:- self.stream = stream- self.attempt = attempt- self._provider_name = provider_name- self._request_id = request_id- self._closed = False-- async def aclose(self, *, active_error: BaseException | None) -> None:- if self._closed:- return- self._closed = True- try:- await close_provider_stream(- self.stream,- active_error=active_error,- provider_name=self._provider_name,- request_id=self._request_id,- )- finally:- await self.attempt.aclose()--class _OpenAIChatStreamAssembler:"""Own one discardable OpenAI-chat replay epoch."""@@ -891,23 +860,23 @@ class _OpenAIChatStreamRunner:for event in assembler.start_events():for out_event in hold_event(event):yield out_event- scope: _OpenAIChatAttemptScope | None = None+ scope: ProviderAttemptScope | None = Nonetry:stream, body, attempt = await self._provider._create_stream(body,execution,ProviderOperationKind.GENERATION,)- scope = _OpenAIChatAttemptScope(- stream,+ scope = ProviderAttemptScope(attempt,provider_name=tag,request_id=self._request_id,)+ stream = scope.retain(stream)assembler.bind_tool_argument_aliases(self._provider._tool_argument_aliases(body))- async for chunk in scope.stream:+ async for chunk in stream:if not scope.attempt.accepted:await scope.attempt.accept()for event in assembler.feed(chunk):@@ -984,7 +953,7 @@ class _OpenAIChatStreamRunner:self,*,error: Exception,- scope: _OpenAIChatAttemptScope | None,+ scope: ProviderAttemptScope | None,assembler: _OpenAIChatStreamAssembler,body: dict[str, Any],execution: ProviderExecution,@@ -1118,21 +1087,26 @@ class _OpenAIChatStreamRunner:"""Collect one complete buffered continuation response."""last_error: Exception | None = Nonewhile execution.can_attempt:- stream: Any | None = None- attempt: ProviderAttempt | None = None+ scope: ProviderAttemptScope | None = Nonetry:stream, accepted_body, attempt = await self._provider._create_stream(body,execution,operation_kind,)+ scope = ProviderAttemptScope(+ attempt,+ provider_name=self._provider._provider_name,+ request_id=self._request_id,+ )+ stream = scope.retain(stream)text_parts: list[str] = []thinking_parts: list[str] = []tool_calls = OpenAIToolCallCollector()terminal_seen = Falseasync for chunk in stream:- if not attempt.accepted:- await attempt.accept()+ if not scope.attempt.accepted:+ await scope.attempt.accept()if not getattr(chunk, "choices", None):continuechoice = chunk.choices[0]@@ -1176,8 +1150,8 @@ class _OpenAIChatStreamRunner:except Exception as error:last_error = errorretryable = is_retryable_stream_error(error)- if attempt is not None and not attempt.accepted:- failure = await attempt.fail(+ if scope is not None and not scope.attempt.accepted:+ failure = await scope.attempt.fail(error,provider_failure_override=(self._provider._provider_failure_override@@ -1197,10 +1171,8 @@ class _OpenAIChatStreamRunner:exc_type=type(error).__name__,)finally:- if stream is not None:- await maybe_await_aclose(stream)- if attempt is not None:- await attempt.aclose()+ if scope is not None:+ await scope.aclose(active_error=sys.exception())if last_error is not None:raise last_errorreturn _CollectedRecoveryOutput(text="", thinking="", tool_calls=())diff --git a/src/free_claude_code/providers/openai_codex/provider.py b/src/free_claude_code/providers/openai_codex/provider.pyindex 5ab57cb7..9bc69b17 100644--- a/src/free_claude_code/providers/openai_codex/provider.py+++ b/src/free_claude_code/providers/openai_codex/provider.py@@ -2,6 +2,7 @@import asyncioimport json+import sysimport uuidfrom collections.abc import AsyncIteratorfrom importlib.metadata import PackageNotFoundError, version@@ -32,7 +33,6 @@ from free_claude_code.core.reasoning import (from free_claude_code.core.trace import trace_eventfrom free_claude_code.providers.admission import (ProviderAdmissionController,- ProviderAttempt,ProviderCorrectionAction,ProviderExecution,ProviderOperationKind,@@ -43,7 +43,7 @@ from free_claude_code.providers.failure_policy import (classify_provider_failure,is_retryable_stream_error,)-from free_claude_code.providers.http import maybe_await_aclose+from free_claude_code.providers.http import ProviderAttemptScope, maybe_await_aclosefrom free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -118,55 +118,54 @@ class OpenAICodexProvider(BaseProvider):execution = self._admission.start_execution()authentication_recovered = Falsewhile execution.can_attempt:- response: httpx.Response | None = None- attempt: ProviderAttempt | None = None+ scope: ProviderAttemptScope | None = Nonetry:access = await self._auth.access()attempt = await execution.open_attempt(ProviderOperationKind.MODEL_DISCOVERY)- response = await self._client.get(- "models",- params={"client_version": FCC_VERSION},- headers={**self._client_headers, **_auth_headers(access)},+ scope = ProviderAttemptScope(+ attempt,+ provider_name="OpenAI",+ request_id=execution.request_id,+ )+ response = scope.retain(+ await self._client.get(+ "models",+ params={"client_version": FCC_VERSION},+ headers={**self._client_headers, **_auth_headers(access)},+ ))if response.status_code == 401 and not authentication_recovered:error = await _response_status_error(response)- correction = await attempt.correct(error)+ correction = await scope.attempt.correct(error)+ closing_scope = scope+ scope = None+ await closing_scope.aclose(active_error=error)if correction is ProviderCorrectionAction.FINAL:- await response.aclose()- response = None- await attempt.aclose()- attempt = Noneraise error- await response.aclose()- response = None- await attempt.aclose()- attempt = Noneawait self._auth.recover_unauthorized(access.access_token)authentication_recovered = Truecontinueif not response.is_success:raise await _response_status_error(response)payload = response.json()- await attempt.accept()+ await scope.attempt.accept()execution.succeed()return payloadexcept asyncio.CancelledError:execution.abandon()raiseexcept Exception as error:- if attempt is not None and not attempt.accepted:- decision = await attempt.fail(error)+ if scope is not None and not scope.attempt.accepted:+ decision = await scope.attempt.fail(error)if decision.retry_allowed:continueexecution.fail(error)raisefinally:- if response is not None:- await response.aclose()- if attempt is not None:- await attempt.aclose()+ if scope is not None:+ await scope.aclose(active_error=sys.exception())if execution.last_failure is not None:raise execution.last_failure@@ -282,33 +281,38 @@ class OpenAICodexProvider(BaseProvider):for held in recovery.push(event):yield held- response: httpx.Response | None = None- attempt: ProviderAttempt | None = None+ scope: ProviderAttemptScope | None = Nonestream_opened = Falsetry:access = await self._auth.access()attempt = await execution.open_attempt(ProviderOperationKind.GENERATION)- response = await self._client.send(- self._client.build_request(- "POST",- "responses",- json=body,- headers={- **self._client_headers,- **_auth_headers(access),- "Accept": "text/event-stream",- "session_id": session_id,- },- ),- stream=True,+ scope = ProviderAttemptScope(+ attempt,+ provider_name="OpenAI",+ request_id=request_id,+ )+ response = scope.retain(+ await self._client.send(+ self._client.build_request(+ "POST",+ "responses",+ json=body,+ headers={+ **self._client_headers,+ **_auth_headers(access),+ "Accept": "text/event-stream",+ "session_id": session_id,+ },+ ),+ stream=True,+ ))if response.status_code == 401 and not authentication_recovered:error = await _response_status_error(response)- correction = await attempt.correct(error)- await response.aclose()- response = None- await attempt.aclose()- attempt = None+ correction = await scope.attempt.correct(error)+ closing_scope = scope+ scope = None+ await closing_scope.aclose(active_error=error)if correction is ProviderCorrectionAction.FINAL:raise errorrecovery.discard()@@ -332,8 +336,8 @@ class OpenAICodexProvider(BaseProvider):stream_opened = Trueasync for event_type, payload in _iter_sse(response):- if not attempt.accepted:- await attempt.accept()+ if not scope.attempt.accepted:+ await scope.attempt.accept()for event in stream.feed(event_type, payload):for held in recovery.push(event):yield held@@ -356,8 +360,8 @@ class OpenAICodexProvider(BaseProvider):except Exception as raw_error:error = _effective_error(raw_error)attempt_failure = None- if attempt is not None and not attempt.accepted:- attempt_failure = await attempt.fail(error)+ if scope is not None and not scope.attempt.accepted:+ attempt_failure = await scope.attempt.fail(error)if attempt_failure is not None and attempt_failure.retry_allowed:recovery.discard()trace_event(@@ -414,10 +418,8 @@ class OpenAICodexProvider(BaseProvider):yield eventraise failure from raw_errorfinally:- if response is not None:- await response.aclose()- if attempt is not None:- await attempt.aclose()+ if scope is not None:+ await scope.aclose(active_error=sys.exception())if execution.last_failure is not None:raise execution.last_failurediff --git a/tests/providers/test_execution_failure_boundary.py b/tests/providers/test_execution_failure_boundary.pyindex ccc4f9a9..434ca634 100644--- a/tests/providers/test_execution_failure_boundary.py+++ b/tests/providers/test_execution_failure_boundary.py@@ -1,5 +1,6 @@"""Provider streams raise canonical failures after closing committed blocks."""+import asynciofrom collections import dequefrom collections.abc import AsyncIteratorfrom unittest.mock import AsyncMock, MagicMock, patch@@ -10,7 +11,11 @@ from free_claude_code.config.nim import NimSettingsfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.async_iterators import AsyncCloseablefrom free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.providers.http import close_provider_stream+from free_claude_code.providers.admission import ProviderOperationKind+from free_claude_code.providers.http import (+ ProviderAttemptScope,+ close_provider_stream,+)from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (@@ -25,7 +30,7 @@ class _FailingStream:chunks: list[object],error: Exception | None,*,- close_error: Exception | None = None,+ close_error: BaseException | None = None,) -> None:self._chunks = chunksself._error = error@@ -189,7 +194,67 @@ async def test_stream_close_failure_without_active_error_is_observability_only()@pytest.mark.asyncio-async def test_completed_stream_close_failure_preserves_success_lifecycle() -> None:+ "close_error",+ [+ pytest.param(RuntimeError("cleanup api_key=SECRET"), id="exception"),+ pytest.param(+ asyncio.CancelledError("cleanup api_key=SECRET"),+ id="cleanup-cancellation",+ ),+ ],+)+async def test_attempt_scope_releases_attempt_when_resource_close_fails(+ close_error: BaseException,+) -> None:+ controller = immediate_admission()+ execution = controller.start_execution(request_id="req_scope_close")+ attempt = await execution.open_attempt(ProviderOperationKind.CONTINUATION)+ stream = _FailingStream(+ [],+ None,+ close_error=close_error,+ )+ scope = ProviderAttemptScope(+ attempt,+ provider_name="TEST",+ request_id="req_scope_close",+ )+ assert scope.retain(stream) is stream++ with patch("free_claude_code.providers.http.trace_event") as trace_event:+ await scope.aclose(active_error=ValueError("original"))+ await scope.aclose(active_error=None)++ replacement = await execution.open_attempt(ProviderOperationKind.CONTINUATION)+ await replacement.aclose()+ assert stream.close_calls == 1+ trace_event.assert_called_once_with(+ stage="provider",+ event="provider.stream.close_failed",+ source="provider",+ provider="TEST",+ request_id="req_scope_close",+ close_exc_type=type(close_error).__name__,+ preserved_exc_type="ValueError",+ )+ assert "SECRET" not in repr(trace_event.call_args)+++ "close_error",+ [+ pytest.param(RuntimeError("cleanup api_key=SECRET"), id="exception"),+ pytest.param(+ asyncio.CancelledError("cleanup api_key=SECRET"),+ id="cleanup-cancellation",+ ),+ ],+)+async def test_completed_stream_close_failure_preserves_success_lifecycle(+ close_error: BaseException,+) -> None:provider = _provider()request = make_messages_request("test-model",@@ -199,7 +264,7 @@ async def test_completed_stream_close_failure_preserves_success_lifecycle() -> Nstream = _FailingStream([_chunk(content="complete", finish_reason="stop")],None,- close_error=RuntimeError("cleanup api_key=SECRET"),+ close_error=close_error,)with (@@ -230,12 +295,43 @@ async def test_completed_stream_close_failure_preserves_success_lifecycle() -> Nsource="provider",provider="NIM",request_id="req_successful_close_failure",- close_exc_type="RuntimeError",+ close_exc_type=type(close_error).__name__,preserved_exc_type=None,)assert "SECRET" not in repr(trace_event.call_args)+async def test_caller_cancellation_during_stream_close_propagates() -> None:+ class BlockingClose:+ def __init__(self) -> None:+ self.started = asyncio.Event()+ self.close_calls = 0++ async def aclose(self) -> None:+ self.close_calls += 1+ self.started.set()+ await asyncio.Event().wait()++ stream = BlockingClose()+ with patch("free_claude_code.providers.http.trace_event") as trace_event:+ close_task = asyncio.create_task(+ close_provider_stream(+ stream,+ active_error=None,+ provider_name="TEST",+ request_id="req_cancelled_close",+ )+ )+ await asyncio.wait_for(stream.started.wait(), timeout=1)+ close_task.cancel()+ with pytest.raises(asyncio.CancelledError):+ await close_task++ assert stream.close_calls == 1+ trace_event.assert_not_called()++@pytest.mark.asyncioasync def test_closing_public_openai_stream_closes_raw_stream_once() -> None:provider = _provider()diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.pyindex c4757721..bd54e995 100644--- a/tests/providers/test_openai_codex_provider.py+++ b/tests/providers/test_openai_codex_provider.py@@ -1,3 +1,4 @@+import asyncioimport jsonfrom collections.abc import AsyncIteratorfrom typing import Any@@ -43,6 +44,37 @@ class _FakeAuth(OpenAIAuthManager):return OpenAIAccess(self.current_token, "account_1", False)+class _CloseTrackingResponse(httpx.Response):+ """HTTPX response that records close order and can fail during cleanup."""++ def __init__(+ self,+ status_code: int,+ *,+ close_error: Exception | None = None,+ **kwargs: Any,+ ) -> None:+ super().__init__(status_code, **kwargs)+ self.close_calls = 0+ self._close_error = close_error++ async def aclose(self) -> None:+ self.close_calls += 1+ await super().aclose()+ if self._close_error is not None:+ raise self._close_error+++class _CloseAwareAuth(_FakeAuth):+ def __init__(self, responses: list[_CloseTrackingResponse]) -> None:+ super().__init__()+ self._responses = responses++ async def recover_unauthorized(self, rejected_token: str) -> OpenAIAccess:+ assert self._responses[-1].close_calls == 1+ return await super().recover_unauthorized(rejected_token)++def _config() -> ProviderConfig:return make_provider_config(api_key="",@@ -53,12 +85,12 @@ def _config() -> ProviderConfig:)-def _admission() -> ProviderAdmissionController:+def _admission(*, max_concurrency: int = 2) -> ProviderAdmissionController:return ProviderAdmissionController(provider_name="openai",rate_limit=100,rate_window=1,- max_concurrency=2,+ max_concurrency=max_concurrency,base_delay=0,max_delay=0,jitter=0,@@ -197,6 +229,127 @@ async def test_provider_uses_subscription_headers_and_visible_model_catalog() ->await client.aclose()+async def test_model_discovery_close_failure_preserves_success_and_permit() -> None:+ responses: list[_CloseTrackingResponse] = []++ def handler(request: httpx.Request) -> httpx.Response:+ response = _CloseTrackingResponse(+ 200,+ json={+ "models": [+ {+ "slug": "gpt-visible",+ "visibility": "list",+ "supported_in_api": False,+ }+ ]+ },+ request=request,+ close_error=RuntimeError("cleanup failed"),+ )+ responses.append(response)+ return response++ client = httpx.AsyncClient(+ base_url="https://chatgpt.com/backend-api/codex/",+ transport=httpx.MockTransport(handler),+ )+ provider = OpenAICodexProvider(+ _config(),+ auth=_FakeAuth(),+ admission=_admission(max_concurrency=1),+ client=client,+ )++ first = await asyncio.wait_for(provider.list_model_infos(), timeout=1)+ second = await asyncio.wait_for(provider.list_model_infos(), timeout=1)++ assert {info.model_id for info in first} == {"gpt-visible"}+ assert {info.model_id for info in second} == {"gpt-visible"}+ assert [response.close_calls for response in responses] == [1, 1]+ await client.aclose()+++async def test_generation_close_failure_preserves_success_and_permit() -> None:+ responses: list[_CloseTrackingResponse] = []++ def handler(request: httpx.Request) -> httpx.Response:+ response = _CloseTrackingResponse(+ 200,+ text=_complete_stream("hello"),+ headers={"content-type": "text/event-stream"},+ request=request,+ close_error=RuntimeError("cleanup failed"),+ )+ responses.append(response)+ return response++ client = httpx.AsyncClient(+ base_url="https://chatgpt.com/backend-api/codex/",+ transport=httpx.MockTransport(handler),+ )+ provider = OpenAICodexProvider(+ _config(),+ auth=_FakeAuth(),+ admission=_admission(max_concurrency=1),+ client=client,+ )++ first = await asyncio.wait_for(+ _collect(provider.stream_response(_request(), response_model="claude-opus-4")),+ timeout=1,+ )+ second = await asyncio.wait_for(+ _collect(provider.stream_response(_request(), response_model="claude-opus-4")),+ timeout=1,+ )++ assert text_content(parse_sse_text(first)) == "hello"+ assert text_content(parse_sse_text(second)) == "hello"+ assert [response.close_calls for response in responses] == [1, 1]+ await client.aclose()+++async def test_generation_close_failure_preserves_provider_failure() -> None:+ responses: list[_CloseTrackingResponse] = []++ def handler(request: httpx.Request) -> httpx.Response:+ response = _CloseTrackingResponse(+ 400,+ json={"error": {"message": "original provider failure"}},+ request=request,+ close_error=RuntimeError("cleanup failed"),+ )+ responses.append(response)+ return response++ client = httpx.AsyncClient(+ base_url="https://chatgpt.com/backend-api/codex/",+ transport=httpx.MockTransport(handler),+ )+ provider = OpenAICodexProvider(+ _config(), auth=_FakeAuth(), admission=_admission(), client=client+ )++ with pytest.raises(ExecutionFailure) as exc_info:+ await _collect(+ provider.stream_response(+ _request(),+ request_id="req_close_failure",+ response_model="claude-opus-4",+ )+ )++ assert exc_info.value.status_code == 400+ assert "original provider failure" in exc_info.value.message+ assert "cleanup failed" not in exc_info.value.message+ assert [response.close_calls for response in responses] == [1]+ await client.aclose()++@pytest.mark.asyncioasync def test_provider_accepts_claude_client_controls_before_upstream_io() -> None:requests: list[httpx.Request] = []@@ -592,15 +745,18 @@ async def test_truncated_attempt_after_commit_is_not_retried_or_duplicated() ->@pytest.mark.asyncioasync def test_unauthorized_response_forces_one_auth_refresh() -> None:authorizations: list[str] = []+ unauthorized_responses: list[_CloseTrackingResponse] = []def handler(request: httpx.Request) -> httpx.Response:authorizations.append(request.headers["authorization"])if len(authorizations) == 1:- return httpx.Response(+ response = _CloseTrackingResponse(401,json={"error": {"message": "expired"}},request=request,)+ unauthorized_responses.append(response)+ return responsereturn httpx.Response(200,text=_complete_stream("recovered"),@@ -612,7 +768,7 @@ async def test_unauthorized_response_forces_one_auth_refresh() -> None:base_url="https://chatgpt.com/backend-api/codex/",transport=httpx.MockTransport(handler),)- auth = _FakeAuth()+ auth = _CloseAwareAuth(unauthorized_responses)provider = OpenAICodexProvider(_config(), auth=auth, admission=_admission(), client=client)@@ -627,6 +783,7 @@ async def test_unauthorized_response_forces_one_auth_refresh() -> None:assert authorizations == ["Bearer access_1", "Bearer access_2"]assert auth.recovery_calls == 1+ assert unauthorized_responses[0].close_calls == 1assert text_content(parse_sse_text(body)) == "recovered"await client.aclose()@@ -634,11 +791,14 @@ async def test_unauthorized_response_forces_one_auth_refresh() -> None:@pytest.mark.asyncioasync def test_model_discovery_re_request_is_a_second_admitted_attempt() -> None:authorizations: list[str] = []+ unauthorized_responses: list[_CloseTrackingResponse] = []def handler(request: httpx.Request) -> httpx.Response:authorizations.append(request.headers["authorization"])if len(authorizations) == 1:- return httpx.Response(401, request=request)+ response = _CloseTrackingResponse(401, request=request)+ unauthorized_responses.append(response)+ return responsereturn httpx.Response(200,json={@@ -658,7 +818,7 @@ async def test_model_discovery_re_request_is_a_second_admitted_attempt() -> Nonebase_url="https://chatgpt.com/backend-api/codex/",transport=httpx.MockTransport(handler),)- auth = _FakeAuth()+ auth = _CloseAwareAuth(unauthorized_responses)provider = OpenAICodexProvider(_config(), auth=auth, admission=_admission(), client=client)@@ -669,6 +829,7 @@ async def test_model_discovery_re_request_is_a_second_admitted_attempt() -> Noneassert {info.model_id for info in infos} == {"gpt-visible"}assert authorizations == ["Bearer access_1", "Bearer access_2"]assert auth.recovery_calls == 1+ assert unauthorized_responses[0].close_calls == 1attempt_rows = [call.kwargsfor call in trace.call_args_listdiff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 4f6d9677..13a33cdb 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -1,5 +1,6 @@"""Tests for streaming error handling in providers/nvidia_nim/client.py."""+import asyncioimport jsonfrom types import SimpleNamespacefrom unittest.mock import AsyncMock, MagicMock, patch@@ -72,12 +73,39 @@ def _recovery_output(class ClosableAsyncStreamMock(AsyncStreamMock):"""Async stream mock that records cleanup."""- def __init__(self, chunks, error=None):+ def __init__(self, chunks, error=None, *, close_error=None):super().__init__(chunks, error=error)self.closed = False+ self.close_calls = 0+ self._close_error = close_errorasync def aclose(self):+ self.close_calls += 1self.closed = True+ if self._close_error is not None:+ raise self._close_error+++class BlockingClosableAsyncStreamMock:+ """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()++ async def _aiter(self):+ self.entered.set()+ await asyncio.Event().wait()+ yield++ async def aclose(self):+ self.close_calls += 1+ if self._close_error is not None:+ raise self._close_errordef _make_provider():@@ -1404,6 +1432,139 @@ class TestStreamingExceptionHandling:assert result.tool_calls == ()assert stream.closed is True+ @pytest.mark.asyncio+ async def test_recovery_close_failure_preserves_completed_output(self):+ """A failed stream close cannot replace completed recovery output."""+ stream = ClosableAsyncStreamMock(+ [+ _make_chunk(content="world"),+ _make_chunk(finish_reason="stop"),+ ],+ close_error=RuntimeError("cleanup failed"),+ )+ provider = _make_provider()+ runner = _make_stream_runner(provider, request_id="req_recovery_success")+ execution = provider._admission.start_execution(+ request_id="req_recovery_success"+ )++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream,+ ):+ result = await runner._collect_recovery_output(+ {"messages": []},+ include_reasoning=True,+ execution=execution,+ operation_kind=ProviderOperationKind.CONTINUATION,+ )++ replacement = await execution.open_attempt(ProviderOperationKind.CONTINUATION)+ await replacement.aclose()+ assert result.text == "world"+ assert stream.close_calls == 1++ @pytest.mark.asyncio+ async def test_recovery_close_failure_does_not_block_retry(self):+ """Cleanup failure cannot replace a retryable recovery failure."""+ failed = ClosableAsyncStreamMock(+ [],+ error=TimeoutError("original retryable failure"),+ close_error=RuntimeError("cleanup failed"),+ )+ recovered = ClosableAsyncStreamMock(+ [+ _make_chunk(content="world"),+ _make_chunk(finish_reason="stop"),+ ]+ )+ provider = _make_provider()+ runner = _make_stream_runner(provider)+ execution = provider._admission.start_execution()++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ side_effect=[failed, recovered],+ ) as create:+ result = await runner._collect_recovery_output(+ {"messages": []},+ include_reasoning=True,+ execution=execution,+ operation_kind=ProviderOperationKind.CONTINUATION,+ )++ assert result.text == "world"+ assert create.await_count == 2+ assert failed.close_calls == 1+ assert recovered.close_calls == 1++ @pytest.mark.asyncio+ async def test_recovery_close_failure_preserves_terminal_failure(self):+ """Cleanup failure cannot mask a non-retryable recovery failure."""+ stream = ClosableAsyncStreamMock(+ [],+ error=ValueError("original terminal failure"),+ close_error=RuntimeError("cleanup failed"),+ )+ provider = _make_provider()+ runner = _make_stream_runner(provider)+ execution = provider._admission.start_execution()++ with (+ patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream,+ ),+ pytest.raises(ValueError, match="original terminal failure"),+ ):+ await runner._collect_recovery_output(+ {"messages": []},+ include_reasoning=True,+ execution=execution,+ operation_kind=ProviderOperationKind.CONTINUATION,+ )++ assert stream.close_calls == 1++ @pytest.mark.asyncio+ async def test_recovery_close_failure_preserves_cancellation(self):+ """Cleanup failure cannot turn caller cancellation into a provider error."""+ stream = BlockingClosableAsyncStreamMock(+ close_error=RuntimeError("cleanup failed")+ )+ provider = _make_provider()+ runner = _make_stream_runner(provider)+ execution = provider._admission.start_execution()++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream,+ ):+ task = asyncio.create_task(+ runner._collect_recovery_output(+ {"messages": []},+ include_reasoning=True,+ execution=execution,+ operation_kind=ProviderOperationKind.CONTINUATION,+ )+ )+ await asyncio.wait_for(stream.entered.wait(), timeout=1)+ task.cancel()+ with pytest.raises(asyncio.CancelledError):+ await task++ replacement = await execution.open_attempt(ProviderOperationKind.CONTINUATION)+ await replacement.aclose()+ assert stream.close_calls == 1+@pytest.mark.asyncioasync def test_recovery_collect_text_honors_provider_retry_classification(self):"""Provider semantics apply before the first recovery chunk as well."""diff --git a/uv.lock b/uv.lockindex 7f0a74b9..bb974ceb 100644--- a/uv.lock+++ b/uv.lock@@ -607,7 +607,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.13.4"+version = "5.13.5"source = { editable = "." }dependencies = [{ name = "aiohttp" },