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

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.py
index 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.py
index 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_event
for 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.py
index 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:
+ break
if 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.py
index 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 asyncio
import time
-from collections.abc import Callable
+from collections.abc import AsyncIterator, Callable
+from contextlib import asynccontextmanager
from dataclasses import dataclass
-from enum import StrEnum
+from enum import Enum, StrEnum, auto
+from free_claude_code.core.async_tasks import wait_owned
from free_claude_code.core.stream_delivery import StreamDeliveryState
from .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.py
new file mode 100644
index 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.py
index 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 httpx2
if 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.py
index 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.asyncio
diff --git a/tests/providers/test_stream_recovery.py b/tests/providers/test_stream_recovery.py
index 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 StreamDeliveryState
from 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 None
assert holdback.push("event: content_block_start\n\n") == []
now[0] += 0.74
assert holdback.push("event: content_block_delta\n\n") == []
assert not holdback.committed
+ assert holdback.remaining_delay == pytest.approx(0.01)
now[0] += 0.01
assert 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 None
assert 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 None
assert 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()