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
patch: enforce the initial stream buffer deadline (#1997)
Ali Khokhar9194f157af6b
diff --git a/src/free_claude_code/providers/anthropic_messages/transport.py b/src/free_claude_code/providers/anthropic_messages/transport.pyindex 7ecb93f5..765fdb6c 100644--- a/src/free_claude_code/providers/anthropic_messages/transport.py+++ b/src/free_claude_code/providers/anthropic_messages/transport.py@@ -67,6 +67,7 @@ from free_claude_code.providers.request_recovery import (RequestRecovery,)from free_claude_code.providers.stream_recovery import (+ HoldbackSignal,RecoveryController,RecoveryFailureAction,)@@ -357,22 +358,35 @@ class AnthropicMessagesTransport:"Messages upstream did not return an SSE stream.")stream_opened = True- async for event_type, payload in messages_events(response):- normal_stop_seen |= is_messages_stop(event_type, payload)- check_messages_failure(event_type, payload)- source.observe(- "messages",- payload,- continuing=operation_kind is ProviderOperationKind.CONTINUATION,- )- output = presenter.feed(event_type, payload)- if event_type != "ping" and not attempt.accepted:- await attempt.accept()- for event in (output,) if isinstance(output, str) else output:- for held in recovery.push(event):- yield held- if presenter.completed:- break+ upstream = messages_events(response)+ try:+ async with recovery.read_stream(upstream) as events:+ async for item in events:+ if item is HoldbackSignal.EXPIRED:+ for held in recovery.flush():+ yield held+ continue+ event_type, payload = item+ normal_stop_seen |= is_messages_stop(event_type, payload)+ check_messages_failure(event_type, payload)+ source.observe(+ "messages",+ payload,+ continuing=operation_kind+ is ProviderOperationKind.CONTINUATION,+ )+ output = presenter.feed(event_type, payload)+ if event_type != "ping" and not attempt.accepted:+ await attempt.accept()+ for event in (+ (output,) if isinstance(output, str) else output+ ):+ for held in recovery.push(event):+ yield held+ if presenter.completed:+ break+ finally:+ await maybe_await_aclose(upstream)if not presenter.completed:raise RetryableProviderProtocolError("Messages stream ended without message_stop."diff --git a/src/free_claude_code/providers/openai_chat/transport.py b/src/free_claude_code/providers/openai_chat/transport.pyindex 0c18fedb..4a8c25d4 100644--- a/src/free_claude_code/providers/openai_chat/transport.py+++ b/src/free_claude_code/providers/openai_chat/transport.py@@ -98,6 +98,7 @@ from free_claude_code.providers.request_recovery import (RequestRecovery,)from free_claude_code.providers.stream_recovery import (+ HoldbackSignal,RecoveryController,RecoveryDecision,RecoveryFailureAction,@@ -1059,15 +1060,20 @@ class _OpenAIChatStreamRunner:else None,)assembler.bind_tool_argument_aliases(self._tool_argument_aliases)- async for chunk in stream:- if not scope.attempt.accepted:- await scope.attempt.accept()- for event in assembler.start_events():- for out_event in hold_event(event):- yield out_event- for event in assembler.feed(chunk):- for out_event in hold_event(event):- yield out_event+ async with recovery.read_stream(stream) as chunks:+ async for chunk in chunks:+ if chunk is HoldbackSignal.EXPIRED:+ for event in recovery.flush():+ yield event+ continue+ if not scope.attempt.accepted:+ await scope.attempt.accept()+ for event in assembler.start_events():+ for out_event in hold_event(event):+ yield out_event+ for event in assembler.feed(chunk):+ for out_event in hold_event(event):+ yield out_eventfor event in assembler.finish_upstream():for out_event in hold_event(event):diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex bbcd21fe..dff407e7 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -77,6 +77,7 @@ from free_claude_code.providers.request_recovery import (RequestRecovery,)from free_claude_code.providers.stream_recovery import (+ HoldbackSignal,RecoveryController,RecoveryFailureAction,)@@ -398,71 +399,77 @@ class OpenAIResponsesTransport:stream = scope.retain(OpenAIStreamAdapter(sdk_stream))stream_opened = True- async for upstream_event in stream:- normal_stop_seen |= upstream_event.type in {- "response.completed",- "response.incomplete",- }- if not scope.attempt.accepted:- await scope.attempt.accept()- if not presenter_started:- presenter_started = True- for event in start_events:- for held in recovery.push(event):+ async with recovery.read_stream(stream) as events:+ async for upstream_event in events:+ if upstream_event is HoldbackSignal.EXPIRED:+ for held in recovery.flush():yield held- payload = cast(- JsonObject,- upstream_event.to_dict(mode="json"),- )- failed = upstream_event.type in {- "response.failed",- "error",- "response.error",- }- context_exceeded = reports_context_window_incomplete(- upstream_event.type, payload- )- # Failed snapshots constrain recovery without replacing the- # provider's own error with an output-eligibility failure.- source.observe(- "responses",- payload,- continuing=operation_kind is ProviderOperationKind.CONTINUATION- and not (failed or context_exceeded),- )- if failed:- stream_failure = responses_stream_failure_from_event(- upstream_event.type,+ continue+ normal_stop_seen |= upstream_event.type in {+ "response.completed",+ "response.incomplete",+ }+ if not scope.attempt.accepted:+ await scope.attempt.accept()+ if not presenter_started:+ presenter_started = True+ for event in start_events:+ for held in recovery.push(event):+ yield held+ payload = cast(+ JsonObject,+ upstream_event.to_dict(mode="json"),+ )+ failed = upstream_event.type in {+ "response.failed",+ "error",+ "response.error",+ }+ context_exceeded = reports_context_window_incomplete(+ upstream_event.type, payload+ )+ # Failed snapshots constrain recovery without replacing the+ # provider's own error with an output-eligibility failure.+ source.observe(+ "responses",payload,+ continuing=operation_kind+ is ProviderOperationKind.CONTINUATION+ and not (failed or context_exceeded),)+ if failed:+ stream_failure = responses_stream_failure_from_event(+ upstream_event.type,+ payload,+ )+ if adapt_event is not None:+ try:+ stream_failure.payload = adapt_event(+ upstream_event.type, payload+ )+ except RetryableProviderProtocolError:+ # Preserve the upstream failure classification.+ # Synthesize the terminal event if partial output+ # cannot retain a consistent public identity.+ stream_failure.payload = None+ raise stream_failure+ if context_exceeded:+ raise context_window_exceeded_provider_failure()if adapt_event is not None:- try:- stream_failure.payload = adapt_event(- upstream_event.type, payload- )- except RetryableProviderProtocolError:- # Preserve the upstream failure classification.- # Synthesize the terminal event if partial output- # cannot retain a consistent public identity.- stream_failure.payload = None- raise stream_failure- if context_exceeded:- raise context_window_exceeded_provider_failure()- if adapt_event is not None:- payload = adapt_event(upstream_event.type, payload)- response = payload.get("response")- if (- isinstance(response, dict)- and isinstance(response.get("model"), str)- and response["model"]- ):- origin = replace(origin, model=response["model"])- payload = preserve_responses_reasoning(payload, origin)- for event in presenter.feed(upstream_event.type, payload):- for held in recovery.push(event):- yield held- if presenter.completed:- break+ payload = adapt_event(upstream_event.type, payload)+ response = payload.get("response")+ if (+ isinstance(response, dict)+ and isinstance(response.get("model"), str)+ and response["model"]+ ):+ origin = replace(origin, model=response["model"])+ payload = preserve_responses_reasoning(payload, origin)+ for event in presenter.feed(upstream_event.type, payload):+ for held in recovery.push(event):+ yield held+ if presenter.completed:+ breakif not presenter.completed:raise _TruncatedResponsesStream("Provider Responses stream ended without a terminal event."diff --git a/src/free_claude_code/providers/stream_recovery.py b/src/free_claude_code/providers/stream_recovery.pyindex 898c1778..1c3d043f 100644--- a/src/free_claude_code/providers/stream_recovery.py+++ b/src/free_claude_code/providers/stream_recovery.py@@ -1,10 +1,13 @@"""Provider-owned stream holdback and recovery decisions."""+import asyncioimport time-from collections.abc import Callable+from collections.abc import AsyncIterator, Callable+from contextlib import asynccontextmanagerfrom dataclasses import dataclass-from enum import StrEnum+from enum import Enum, StrEnum, auto+from free_claude_code.core.async_tasks import wait_ownedfrom free_claude_code.core.stream_delivery import StreamDeliveryStatefrom .failure_policy import RetryableProviderProtocolError@@ -25,6 +28,12 @@ class RecoveryFailureAction(StrEnum):FINAL_ERROR = "final_error"+class HoldbackSignal(Enum):+ """Wake a transport to release its buffer without cancelling its read."""++ EXPIRED = auto()++@dataclass(frozen=True, slots=True)class RecoveryDecision:"""Failure decision for one provider stream attempt."""@@ -86,6 +95,63 @@ class RecoveryHoldbackBuffer:def has_buffered(self) -> bool:return bool(self._events)+ @property+ def remaining_delay(self) -> float | None:+ if self.committed or self._started_at is None:+ return None+ return max(0.0, self._holdback_seconds - (self._now() - self._started_at))+++class _HoldbackReader[EventT](AsyncIterator[EventT | HoldbackSignal]):+ """Borrow a source and retain only the read interrupted by a buffer deadline."""++ def __init__(+ self, source: AsyncIterator[EventT], remaining_delay: Callable[[], float | None]+ ) -> None:+ self._source = source+ self._remaining_delay = remaining_delay+ self._pending: asyncio.Task[EventT] | None = None+ self._deadline_checked = False++ def __aiter__(self) -> _HoldbackReader[EventT]:+ return self++ async def __anext__(self) -> EventT | HoldbackSignal:+ pending = self._pending+ delay = self._remaining_delay()+ if pending is not None and pending.done():+ self._pending = None+ self._deadline_checked = delay == 0+ return pending.result()+ # Check one ready event at expiry, then release even if it was metadata.+ if delay == 0 and self._deadline_checked:+ return HoldbackSignal.EXPIRED+ if pending is None:+ if delay is None:+ return await anext(self._source)+ pending = self._pending = asyncio.create_task(self._read())+ await asyncio.wait({pending}, timeout=delay)+ if pending.done():+ self._pending = None+ self._deadline_checked = self._remaining_delay() == 0+ return pending.result()+ return HoldbackSignal.EXPIRED++ async def _read(self) -> EventT:+ return await anext(self._source)++ async def aclose(self) -> None:+ pending, self._pending = self._pending, None+ if pending is None:+ return+ if not pending.done():+ pending.cancel()++ async def drain() -> None:+ await asyncio.gather(pending, return_exceptions=True)++ await wait_owned(asyncio.create_task(drain()))+class RecoveryController:"""Own commit-boundary holdback for one provider stream lifecycle."""@@ -102,6 +168,20 @@ class RecoveryController:def has_buffered(self) -> bool:return self._holdback.has_buffered+ @property+ def remaining_delay(self) -> float | None:+ return self._holdback.remaining_delay++ @asynccontextmanager+ async def read_stream[EventT](+ self, source: AsyncIterator[EventT]+ ) -> AsyncIterator[_HoldbackReader[EventT]]:+ reader = _HoldbackReader(source, lambda: self.remaining_delay)+ try:+ yield reader+ finally:+ await reader.aclose()+def push(self, event: str) -> list[str]:return self._holdback.push(event)diff --git a/tests/api/test_initial_stream_holdback.py b/tests/api/test_initial_stream_holdback.pynew file mode 100644index 00000000..023ad3b6--- /dev/null+++ b/tests/api/test_initial_stream_holdback.py@@ -0,0 +1,428 @@+"""Initial output is released while the real upstream read remains blocked."""++import asyncio+import json++import httpx+import httpx2+import pytest++from free_claude_code.api.response_streams import (+ ManagedStreamingResponse,+ anthropic_sse_streaming_response,+ bind_response_lifetime,+)+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.providers.stream_recovery import RecoveryHoldbackBuffer+from tests.api.test_delivered_stream_recovery import (+ assert_completed,+ public_text,+ text_events,+)+from tests.api.test_hidden_stream_retries import (+ assert_winning_tool,+ executed,+ partial_tool,+)+from tests.api.test_response_streams import _json_error, _serve+from tests.api.test_tool_call_buffer import _response+from tests.api.test_tool_call_buffer_transports import _tools+from tests.providers.test_history_transports import _events_for, _harness+from tests.providers.test_native_tool_arguments import tool_events+++def short_holdback(monkeypatch):+ monkeypatch.setattr(+ "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",+ lambda: RecoveryHoldbackBuffer(holdback_seconds=0.02),+ )+++def encode(protocol, events):+ return "".join(+ (f"event: {event['type']}\n" if protocol == "messages" else "")+ + f"data: {json.dumps(event)}\n\n"+ for event in events+ ).encode()+++class GatedBody(httpx.AsyncByteStream, httpx2.AsyncByteStream):+ def __init__(self, prefix, suffix):+ self.prefix = prefix+ self.suffix = suffix+ self.waiting = asyncio.Event()+ self.release = asyncio.Event()+ self.cancelled = False+ self.close_count = 0++ async def __aiter__(self):+ yield self.prefix+ self.waiting.set()+ try:+ await self.release.wait()+ except asyncio.CancelledError:+ self.cancelled = True+ raise+ yield self.suffix++ async def aclose(self):+ self.close_count += 1++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_initial_text_reaches_http_without_another_upstream_event(+ protocol, wire, short_holdback+):+ events = text_events(protocol, "buffered text")+ prefix_size = len(text_events(protocol, "buffered text", complete=False))+ body = GatedBody(+ encode(protocol, events[:prefix_size]),+ encode(protocol, events[prefix_size:]),+ )+ visible = asyncio.Event()+ sent = []++ async def capture(message):+ data = message.get("body", b"")+ sent.append(data)+ if b"buffered text" in data:+ visible.set()++ async with _harness(protocol, lambda _: (200, body)) as (send, bodies, _):++ async def serve():+ source = send(wire, [{"role": "user", "content": "hello"}])+ response = await _response(wire, executed(source, wire))+ await _serve(response, send=capture)++ serving = asyncio.create_task(serve())+ wait_visible = asyncio.create_task(visible.wait())+ try:+ await asyncio.wait_for(body.waiting.wait(), 2)+ done, _ = await asyncio.wait({wait_visible, serving}, timeout=1)+ assert wait_visible in done, "Buffered text is still waiting for upstream"+ assert not body.cancelled+ assert not body.release.is_set()+ assert not serving.done()+ assert len(bodies) == 1+ finally:+ body.release.set()+ wait_visible.cancel()+ await asyncio.gather(wait_visible, return_exceptions=True)+ await asyncio.wait_for(serving, 2)++ output = parse_sse_text(b"".join(sent).decode())+ assert public_text(output, wire) == "buffered text"+ assert_completed(output, wire)+ assert body.close_count == 1++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])[email protected]("ending", ["eof", "error"])[email protected]("read_state", ["pending", "between_reads"])+async def test_ready_failure_at_deadline_retries_without_releasing_old_text(+ protocol, wire, ending, read_state, monkeypatch+):+ now = [0.0]++ class ClockedBuffer(RecoveryHoldbackBuffer):+ def __init__(self):+ super().__init__(now=lambda: now[0])++ def push(self, event):+ output = super().push(event)+ if read_state == "between_reads" and "abandoned" in event:+ # Time passes after buffering text, before asking for the next+ # event already available in this same HTTP body.+ now[0] = 1.0+ return output++ monkeypatch.setattr(+ "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",+ ClockedBuffer,+ )+ error = {"type": "api_error", "message": "internal server error"}+ if protocol == "responses":+ failure = {+ "type": "response.failed",+ "sequence_number": 4,+ "response": {+ **text_events(protocol, "abandoned")[-1]["response"],+ "status": "failed",+ "error": {"code": "server_error", "message": "interrupted"},+ },+ }+ else:+ failure = {"type": "error", "error": error}+ prefix = encode(protocol, text_events(protocol, "abandoned", complete=False))+ suffix = encode(protocol, [failure]) if ending == "error" else b""+ if read_state == "pending":+ first = GatedBody(prefix, suffix)+ else:+ first = GatedBody(prefix + suffix, b"")+ first.release.set()++ def reply(bodies):+ if len(bodies) == 1:+ return 200, first+ assert first.close_count == 1+ return 200, text_events(protocol, "winning")++ sent = []++ async def capture(message):+ sent.append(message.get("body", b""))++ async with _harness(protocol, reply) as (send, bodies, _):++ async def serve():+ source = send(wire, [{"role": "user", "content": "hello"}])+ response = await _response(wire, executed(source, wire))+ await _serve(response, send=capture)++ serving = asyncio.create_task(serve())+ try:+ if read_state == "pending":+ await asyncio.wait_for(first.waiting.wait(), 2)+ # The pending read completes after its logical deadline. Its+ # failure must be validated before the transport flushes.+ now[0] = 1.0+ first.release.set()+ await asyncio.wait_for(serving, 2)+ finally:+ first.release.set()+ if not serving.done():+ serving.cancel()+ await asyncio.gather(serving, return_exceptions=True)+ assert len(bodies) == 2+ assert bodies[0] == bodies[1]++ output = parse_sse_text(b"".join(sent).decode())+ assert public_text(output, wire) == "winning"+ assert_completed(output, wire)++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_failure_after_timed_release_continues_the_visible_answer(+ protocol, wire, short_holdback+):+ first = GatedBody(+ encode(protocol, text_events(protocol, "Hello ", complete=False)), b""+ )+ visible = asyncio.Event()+ sent = []++ async def capture(message):+ data = message.get("body", b"")+ sent.append(data)+ if b"Hello " in data:+ visible.set()++ async with _harness(+ protocol,+ lambda bodies: (+ 200,+ first if len(bodies) == 1 else text_events(protocol, "world."),+ ),+ ) as (send, bodies, _):++ async def serve():+ source = send(wire, [{"role": "user", "content": "hello"}])+ response = await _response(wire, executed(source, wire))+ await _serve(response, send=capture)++ serving = asyncio.create_task(serve())+ try:+ await asyncio.wait_for(visible.wait(), 2)+ assert not first.release.is_set()+ finally:+ first.release.set()+ await asyncio.wait_for(serving, 2)+ assert len(bodies) == 2+ assert "Hello " in json.dumps(bodies[1])++ output = parse_sse_text(b"".join(sent).decode())+ assert public_text(output, wire) == "Hello world."+ assert_completed(output, wire)+ assert first.close_count == 1++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])[email protected]("released", [False, True])+async def test_cancellation_drains_the_read_before_closing_its_http_body(+ protocol, wire, released, monkeypatch+):+ monkeypatch.setattr(+ "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",+ lambda: RecoveryHoldbackBuffer(holdback_seconds=0.01 if released else 60),+ )+ body = GatedBody(+ encode(protocol, text_events(protocol, "visible", complete=False)), b""+ )+ visible = asyncio.Event()++ async def capture(message):+ if b"visible" in message.get("body", b""):+ visible.set()++ async with _harness(protocol, lambda _: (200, body)) as (send, bodies, _):++ async def serve():+ source = send(wire, [{"role": "user", "content": "hello"}])+ response = await _response(wire, executed(source, wire))+ await _serve(response, send=capture)++ serving = asyncio.create_task(serve())+ try:+ await asyncio.wait_for(body.waiting.wait(), 2)+ if released:+ await asyncio.wait_for(visible.wait(), 2)+ else:+ assert not visible.is_set()+ serving.cancel()+ with pytest.raises(asyncio.CancelledError):+ await asyncio.wait_for(serving, 2)+ assert body.cancelled+ assert body.close_count == 1+ assert len(bodies) == 1+ finally:+ body.release.set()+ if not serving.done():+ serving.cancel()+ await asyncio.gather(serving, return_exceptions=True)++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_closing_prefetched_response_drains_timed_read(+ protocol, wire, short_holdback+):+ body = GatedBody(+ encode(protocol, text_events(protocol, "held", complete=False)), b""+ )+ released = []++ async def release():+ released.append("released")++ async with _harness(protocol, lambda _: (200, body)) as (send, bodies, _):+ source = send(wire, [{"role": "user", "content": "hello"}])+ response = await asyncio.wait_for(_response(wire, executed(source, wire)), 2)+ await bind_response_lifetime(response, release)+ try:+ assert body.waiting.is_set()+ assert not body.release.is_set()+ await response.aclose()+ await response.aclose()+ assert body.cancelled+ assert body.close_count == 1+ assert released == ["released"]+ assert len(bodies) == 1+ finally:+ body.release.set()+ await response.aclose()++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_timed_release_keeps_incomplete_tools_hidden_and_retryable(+ protocol, wire, short_holdback+):+ first = GatedBody(encode(protocol, partial_tool(protocol)), b"")+ started = asyncio.Event()+ sent = []++ async def capture(message):+ if message["type"] == "http.response.start":+ started.set()+ sent.append(message.get("body", b""))++ async with _harness(+ protocol,+ lambda bodies: (+ 200,+ first if len(bodies) == 1 else tool_events(protocol, '{"path":"winning"}'),+ ),+ ) as (send, bodies, _):++ async def serve():+ source = send(+ wire, [{"role": "user", "content": "read"}], tools=_tools(wire)+ )+ response = await _response(wire, executed(source, wire))+ await _serve(response, send=capture)++ serving = asyncio.create_task(serve())+ try:+ await asyncio.wait_for(started.wait(), 2)+ assert not first.release.is_set()+ assert b"call_abandoned" not in b"".join(sent)+ finally:+ first.release.set()+ await asyncio.wait_for(serving, 2)+ assert len(bodies) == 2+ assert bodies[0] == bodies[1]+ assert_winning_tool(b"".join(sent).decode(), wire)+ assert first.close_count == 1++[email protected]("protocol", ["chat", "messages", "responses"])+async def test_timed_release_keeps_projected_reasoning_hidden_and_retryable(+ protocol, short_holdback+):+ prefix_size = {"chat": 1, "messages": 3, "responses": 4}[protocol]+ first = GatedBody(encode(protocol, _events_for(protocol)[:prefix_size]), b"")+ started = asyncio.Event()+ sent = []++ async def capture(message):+ if message["type"] == "http.response.start":+ started.set()+ sent.append(message.get("body", b""))++ async with _harness(+ protocol,+ lambda bodies: (+ 200,+ first if len(bodies) == 1 else text_events(protocol, "winning"),+ ),+ ) as (send, bodies, _):++ async def serve():+ source = send("messages", [{"role": "user", "content": "hello"}])+ response = await anthropic_sse_streaming_response(+ executed(source, "messages"),+ pre_start_error_response=_json_error,+ request_id="hidden-reasoning",+ hide_reasoning=True,+ )+ assert isinstance(response, ManagedStreamingResponse)+ await _serve(response, send=capture)++ serving = asyncio.create_task(serve())+ try:+ await asyncio.wait_for(started.wait(), 2)+ assert not first.release.is_set()+ assert b"Find 17." not in b"".join(sent)+ finally:+ first.release.set()+ await asyncio.wait_for(serving, 2)+ assert len(bodies) == 2+ assert bodies[0] == bodies[1]+ raw = b"".join(sent).decode()+ assert "Find 17." not in raw+ output = parse_sse_text(raw)+ assert public_text(output, "messages") == "winning"+ assert_completed(output, "messages")diff --git a/tests/providers/test_history_transports.py b/tests/providers/test_history_transports.pyindex c5a18df4..0d2b2e41 100644--- a/tests/providers/test_history_transports.py+++ b/tests/providers/test_history_transports.py@@ -148,6 +148,10 @@ async def _harness(module = httpx if protocol == "messages" else httpx2if status != 200:return module.Response(status, json={"error": payload})+ if isinstance(payload, module.AsyncByteStream):+ return module.Response(+ 200, headers={"content-type": "text/event-stream"}, stream=payload+ )raw = "".join((f"event: {event['type']}\n" if protocol == "messages" else "")+ f"data: {json.dumps(event)}\n\n"diff --git a/tests/providers/test_openai_codex_auth.py b/tests/providers/test_openai_codex_auth.pyindex 2d31e208..a1153853 100644--- a/tests/providers/test_openai_codex_auth.py+++ b/tests/providers/test_openai_codex_auth.py@@ -438,27 +438,30 @@ async def test_device_login_persists_account_and_reports_only_safe_state(client=client,)- pending = await manager.start_login(ConnectedAccountLoginMode.DEVICE)- assert pending.state == "connecting"- assert pending.user_code == "ABCD-EFGH"- for _ in range(50):+ try:+ pending = await manager.start_login(ConnectedAccountLoginMode.DEVICE)+ assert pending.state == "connecting"+ assert pending.user_code == "ABCD-EFGH"+ login = manager._login_task+ assert login is not None+ await asyncio.wait_for(login, timeout=5)status = manager.status()- if status.state != "connecting":- break- await asyncio.sleep(0.01)-- assert status.state == "connected"- assert status.email == "[email protected]"- serialized = json.dumps(status.as_dict())- assert "device_private" not in serialized- assert "refresh_private" not in serialized- assert calls == [- "/api/accounts/deviceauth/usercode",- "/api/accounts/deviceauth/token",- "/oauth/token",- ]- await manager.close()- await client.aclose()++ assert status.state == "connected"+ assert status.email == "[email protected]"+ saved = json.loads((tmp_path / "openai.json").read_text(encoding="utf-8"))+ assert saved["credentials"]["account_id"] == "account_device"+ serialized = json.dumps(status.as_dict())+ assert "device_private" not in serialized+ assert "refresh_private" not in serialized+ assert calls == [+ "/api/accounts/deviceauth/usercode",+ "/api/accounts/deviceauth/token",+ "/oauth/token",+ ]+ finally:+ await manager.close()+ await client.aclose()@pytest.mark.asynciodiff --git a/tests/providers/test_stream_recovery.py b/tests/providers/test_stream_recovery.pyindex 34775a48..c86bbc2d 100644--- a/tests/providers/test_stream_recovery.py+++ b/tests/providers/test_stream_recovery.py@@ -1,7 +1,12 @@"""Provider stream commit-boundary and recovery policy."""+import asyncio++import pytest+from free_claude_code.core.stream_delivery import StreamDeliveryStatefrom free_claude_code.providers.stream_recovery import (+ HoldbackSignal,RecoveryController,RecoveryFailureAction,RecoveryHoldbackBuffer,@@ -158,10 +163,12 @@ def test_holdback_buffers_until_delay_then_commits() -> None:now = [10.0]holdback = RecoveryHoldbackBuffer(holdback_seconds=0.75, now=lambda: now[0])+ assert holdback.remaining_delay is Noneassert holdback.push("event: content_block_start\n\n") == []now[0] += 0.74assert holdback.push("event: content_block_delta\n\n") == []assert not holdback.committed+ assert holdback.remaining_delay == pytest.approx(0.01)now[0] += 0.01assert holdback.push("event: content_block_stop\n\n") == [@@ -170,6 +177,7 @@ def test_holdback_buffers_until_delay_then_commits() -> None:"event: content_block_stop\n\n",]assert holdback.committed+ assert holdback.remaining_delay is Noneassert holdback.push("event: message_stop\n\n") == ["event: message_stop\n\n"]@@ -187,4 +195,190 @@ def test_holdback_discard_drops_uncommitted_events() -> None:assert holdback.push("hidden") == []holdback.discard()+ assert holdback.remaining_delay is Noneassert holdback.flush() == []+++def test_new_attempt_deadline_starts_with_its_first_buffered_event(monkeypatch):+ now = [10.0]+ monkeypatch.setattr(+ "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",+ lambda: RecoveryHoldbackBuffer(now=lambda: now[0]),+ )+ recovery = RecoveryController()+ recovery.push("old")+ now[0] = 10.5+ decision = recovery.advance_failure(+ retryable=True,+ stream_opened=True,+ generated_output=True,+ complete_tool_salvageable=False,+ attempts_remaining=2,+ )+ assert decision.action is RecoveryFailureAction.EARLY_RETRY+ assert recovery.remaining_delay is None+ now[0] = 20.0+ recovery.push("new")+ now[0] = 20.7+ assert recovery.remaining_delay == pytest.approx(0.05)+ now[0] = 22.0+ assert recovery.remaining_delay == 0+ assert recovery.flush() == ["new"]+ recovery.discard()+ assert recovery.remaining_delay is None+ assert recovery.push("continuation") == ["continuation"]+++ "error", [None, TimeoutError("upstream"), StopAsyncIteration()]+)[email protected]("expired_before_read", [False, True])+async def test_deadline_preserves_the_pending_read_and_its_outcome(+ monkeypatch, error, expired_before_read+):+ now = [0.0]+ monkeypatch.setattr(+ "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",+ lambda: RecoveryHoldbackBuffer(+ holdback_seconds=0.01,+ now=(lambda: now[0]) if expired_before_read else None,+ ),+ )+ recovery = RecoveryController()+ recovery.push("buffered")+ if expired_before_read:+ now[0] = 1.0+ release = asyncio.Event()+ reads = []++ class Source:+ async def __anext__(self):+ reads.append("read")+ await release.wait()+ if error is not None:+ raise error+ return "next"++ def __aiter__(self):+ return self++ async with recovery.read_stream(Source()) as stream:+ assert await asyncio.wait_for(anext(stream), 1) is HoldbackSignal.EXPIRED+ assert reads == ["read"]+ assert recovery.flush() == ["buffered"]+ release.set()+ if error is None:+ assert await anext(stream) == "next"+ else:+ with pytest.raises(type(error)) as caught:+ await anext(stream)+ assert caught.value is error+ assert reads == ["read"]++[email protected]("expired_before_read", [False, True])+async def test_events_without_output_cannot_extend_a_buffer_deadline(+ monkeypatch, expired_before_read+):+ now = [0.0]+ monkeypatch.setattr(+ "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",+ lambda: RecoveryHoldbackBuffer(now=lambda: now[0]),+ )+ recovery = RecoveryController()+ recovery.push("held")+ if expired_before_read:+ now[0] = 1.0+ reads = []++ async def source():+ reads.append("first")+ now[0] = 1.0+ yield "ignored"+ reads.append("second")+ yield "next"++ upstream = source()+ try:+ async with recovery.read_stream(upstream) as stream:+ assert await anext(stream) == "ignored"+ assert await anext(stream) is HoldbackSignal.EXPIRED+ assert reads == ["first"]+ assert recovery.flush() == ["held"]+ assert await anext(stream) == "next"+ finally:+ await upstream.aclose()+++async def test_empty_buffer_does_not_wake_or_read_ahead():+ recovery = RecoveryController()+ entered = asyncio.Event()+ release = asyncio.Event()+ read_count = 0++ async def source():+ nonlocal read_count+ while True:+ read_count += 1+ entered.set()+ await release.wait()+ yield "next"++ upstream = source()+ read = None+ try:+ async with recovery.read_stream(upstream) as stream:+ read = asyncio.create_task(anext(stream))+ await asyncio.wait_for(entered.wait(), 1)+ assert not read.done()+ release.set()+ assert await read == "next"+ assert read_count == 1+ finally:+ release.set()+ if read is not None:+ read.cancel()+ await asyncio.gather(read, return_exceptions=True)+ await upstream.aclose()+++async def test_repeated_cancellation_drains_read_before_leaving_scope():+ recovery = RecoveryController()+ recovery.push("held")+ entered = asyncio.Event()+ closing = asyncio.Event()+ close_release = asyncio.Event()+ closed = asyncio.Event()++ async def source():+ try:+ entered.set()+ await asyncio.Event().wait()+ yield "unreachable"+ finally:+ closing.set()+ await close_release.wait()+ closed.set()++ async def consume():+ async with recovery.read_stream(source()) as stream:+ await anext(stream)++ consumer = asyncio.create_task(consume())+ try:+ await asyncio.wait_for(entered.wait(), 1)+ consumer.cancel()+ await asyncio.wait_for(closing.wait(), 1)+ consumer.cancel()+ await asyncio.sleep(0)+ assert not consumer.done()+ assert not closed.is_set()+ finally:+ close_release.set()+ with pytest.raises(asyncio.CancelledError):+ await asyncio.wait_for(consumer, 1)+ assert closed.is_set()