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: retry hidden streams on the same provider (#1974)
Ali Khokharba43d7f33300
diff --git a/src/free_claude_code/api/handlers/classifier_response.py b/src/free_claude_code/api/handlers/classifier_response.pyindex 10e39a19..dca30b89 100644--- a/src/free_claude_code/api/handlers/classifier_response.py+++ b/src/free_claude_code/api/handlers/classifier_response.py@@ -6,6 +6,7 @@ from collections.abc import AsyncIteratorfrom free_claude_code.core.anthropic.stream_contracts import SSEEventfrom free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoder+from free_claude_code.core.stream_delivery import current_stream_deliveryfrom free_claude_code.core.trace import close_stream_input@@ -14,6 +15,17 @@ async def classifier_response(source: AsyncIterator[str]) -> AsyncIterator[str]:decoder = AnthropicSSEDecoder()indices: dict[int, int | None] = {}next_index = 0+ delivery = current_stream_delivery()+ revision = delivery.attempt_revision if delivery else 0++ def synchronize() -> None:+ nonlocal decoder, next_index, revision+ if delivery is None or revision == delivery.attempt_revision:+ return+ revision = delivery.attempt_revision+ decoder = AnthropicSSEDecoder()+ indices.clear()+ next_index = 0def project(event: SSEEvent) -> str | None:nonlocal next_index@@ -49,15 +61,18 @@ async def classifier_response(source: AsyncIterator[str]) -> AsyncIterator[str]:try:async for chunk in source:+ synchronize()for event in decoder.feed(chunk):projected = project(event)if projected is not None:yield projected+ synchronize()for event in decoder.finish():projected = project(event)if projected is not None:yield projectedfinally:+ synchronize()await close_stream_input(source,owner="classifier_response",diff --git a/src/free_claude_code/api/response_streams.py b/src/free_claude_code/api/response_streams.pyindex 43aafcef..2bc01c39 100644--- a/src/free_claude_code/api/response_streams.py+++ b/src/free_claude_code/api/response_streams.py@@ -33,8 +33,10 @@ from free_claude_code.core.request_outcomes import (record_request_exception,record_request_failure,)+from free_claude_code.core.stream_delivery import StreamDeliveryStatefrom free_claude_code.core.trace import close_stream_input, trace_event+from .stream_delivery import DeliveryObservedStream, PublicStreamEnvelopefrom .tool_call_buffer import ToolCallBufferedStreamTERMINAL_EXECUTION_ERROR_HEADERS = {"x-should-retry": "false"}@@ -237,6 +239,9 @@ async def _first_chunk_streaming_response(terminal_frame: TerminalFrameEmitter | None,terminal_failure_observer: TerminalFailureObserver | None,) -> Response:+ state = StreamDeliveryState()+ envelope = PublicStreamEnvelope(state, wire_api=wire_api)+ body = DeliveryObservedStream(body, state)try:first_chunk = await anext(body)except StopAsyncIteration:@@ -263,8 +268,10 @@ async def _first_chunk_streaming_response(body,terminal_frame=terminal_frame,terminal_failure_observer=terminal_failure_observer,+ envelope=envelope,),wire_api=wire_api,+ envelope=envelope,),media_type="text/event-stream",headers=dict(headers),@@ -298,6 +305,7 @@ class _PrefetchedStream(AsyncIterator[str]):*,terminal_frame: TerminalFrameEmitter | None,terminal_failure_observer: TerminalFailureObserver | None,+ envelope: PublicStreamEnvelope,) -> None:self._first_chunk: str | None = first_chunkself._initial_chunk = first_chunk@@ -307,6 +315,8 @@ class _PrefetchedStream(AsyncIterator[str]):self._terminal_failure_observer = terminal_failure_observerself._done = Falseself._closed = False+ self._envelope = envelope+ self._revision = envelope.state.attempt_revisiondef __aiter__(self) -> _PrefetchedStream:return self@@ -320,6 +330,7 @@ class _PrefetchedStream(AsyncIterator[str]):return first_chunktry:chunk = await anext(self._body)+ self._synchronize()self._latest_chunk = chunkreturn chunkexcept StopAsyncIteration:@@ -340,13 +351,24 @@ class _PrefetchedStream(AsyncIterator[str]):raise close_errordef _terminal_chunk(self, exc: BaseException) -> str:+ self._synchronize()terminal_frame = self._terminal_frameif terminal_frame is None:raise excself._done = Trueif self._terminal_failure_observer is not None:self._terminal_failure_observer(exc)- return terminal_frame(self._initial_chunk, self._latest_chunk, exc)+ return terminal_frame(+ self._envelope.start_frame or self._initial_chunk, self._latest_chunk, exc+ )++ def _synchronize(self) -> None:+ if self._revision == self._envelope.state.attempt_revision:+ return+ self._revision = self._envelope.state.attempt_revision+ self._envelope.synchronize()+ self._initial_chunk = self._envelope.start_frame+ self._latest_chunk = ""async def anthropic_sse_streaming_response(diff --git a/src/free_claude_code/api/stream_delivery.py b/src/free_claude_code/api/stream_delivery.pynew file mode 100644index 00000000..645a8830--- /dev/null+++ b/src/free_claude_code/api/stream_delivery.py@@ -0,0 +1,206 @@+"""Observe public delivery and retain one response envelope across hidden retries."""++import re+from collections.abc import AsyncIterator, Mapping+from typing import Any, Literal++import simplejson++from free_claude_code.core.async_iterators import try_close_async_iterator+from free_claude_code.core.stream_delivery import (+ StreamDeliveryState,+ bind_stream_delivery,+)+++class DeliveryObservedStream(AsyncIterator[str]):+ """Bind observation for each read/close, including prefetch in another task."""++ def __init__(self, body: AsyncIterator[str], state: StreamDeliveryState) -> None:+ self._body = body+ self._state = state++ def __aiter__(self) -> DeliveryObservedStream:+ return self++ async def __anext__(self) -> str:+ with bind_stream_delivery(self._state):+ return await anext(self._body)++ async def aclose(self) -> None:+ with bind_stream_delivery(self._state):+ error = await try_close_async_iterator(self._body)+ if error is not None:+ raise error+++def frame_data(frame: str) -> dict[str, Any] | None:+ """Read only SSE data, retaining decimal precision for envelope edits."""+ text = "\n".join(+ line[5:].lstrip(" ")+ for line in re.split(r"\r\n|\r|\n", frame)+ if line.startswith("data:")+ )+ try:+ value: object = simplejson.loads(text, use_decimal=True)+ except ValueError:+ return None+ return value if isinstance(value, dict) else None+++def replace_frame_data(frame: str, payload: Mapping[str, object]) -> str:+ """Replace data lines while preserving other SSE fields and line endings."""+ lines = re.split(r"(\r\n|\r|\n)", frame)+ replacement = "data: " + simplejson.dumps(+ payload, use_decimal=True, ensure_ascii=False+ )+ parts: list[str] = []+ replaced = False+ for index in range(0, len(lines), 2):+ line = lines[index]+ ending = lines[index + 1] if index + 1 < len(lines) else ""+ if line.startswith("data:"):+ if replaced:+ continue+ line = replacement+ replaced = True+ parts.extend((line, ending))+ return "".join(parts)+++class PublicStreamEnvelope:+ """Own published metadata without reconstructing content or tool arguments."""++ def __init__(+ self, state: StreamDeliveryState, *, wire_api: Literal["messages", "responses"]+ ) -> None:+ self.state = state+ self._wire_api = wire_api+ self._revision = state.attempt_revision+ self._published_starts: set[str] = set()+ self._seen_starts: set[str] = set()+ self._replacement = False+ self._public_id: str | None = None+ self._created_at: object = None+ self._sequence: int = -1+ self._offset: int | None = None+ self._pending_starts: list[str] = []+ self.start_frame = ""++ def synchronize(self) -> None:+ if self._revision == self.state.attempt_revision:+ return+ self._revision = self.state.attempt_revision+ self._replacement = bool(self._published_starts)+ self._seen_starts.clear()+ self._offset = None+ self.discard_pending_starts()++ def discard_pending_starts(self) -> None:+ """Discard metadata that no client has observed."""+ self._pending_starts.clear()++ def _release_content(self, frame: str) -> str:+ self.state.release_content()+ if not self._pending_starts:+ return frame+ self.start_frame = self._pending_starts[0]+ self._published_starts.add("message_start")+ prefix = "".join(self._pending_starts)+ self.discard_pending_starts()+ return prefix + frame++ def publish(self, frame: str) -> str | None:+ """Normalize only a replacement envelope and mark actually released frames."""+ self.synchronize()+ payload = frame_data(frame)+ if payload is None:+ if any(+ line.strip() and not line.startswith(":")+ for line in re.split(r"\r\n|\r|\n", frame)+ ):+ return self._release_content(frame)+ return frame++ raw_kind = payload.get("type")+ kind = raw_kind if isinstance(raw_kind, str) else ""+ metadata = self._metadata(kind, payload)+ if self._wire_api == "messages":+ if kind == "message_start" and metadata and not self.state.content_released:+ self._pending_starts.append(frame)+ return None+ if kind == "error":+ self.discard_pending_starts()+ start = kind in {"message_start", "response.created", "response.in_progress"}+ if start and metadata:+ if kind not in self._seen_starts:+ self._seen_starts.add(kind)+ if self._replacement and kind in self._published_starts:+ return None+ self._published_starts.add(kind)+ if not self.start_frame:+ self.start_frame = frame+ value = payload.get(+ "message" if self._wire_api == "messages" else "response"+ )+ if isinstance(value, dict):+ self._public_id = value.get("id")+ self._created_at = value.get("created_at")++ changed = False+ if self._replacement and self._wire_api == "responses":+ response = payload.get("response")+ if isinstance(response, dict):+ if (+ self._public_id is not None+ and response.get("id") != self._public_id+ ):+ response["id"] = self._public_id+ changed = True+ if (+ self._created_at is not None+ and response.get("created_at") != self._created_at+ ):+ response["created_at"] = self._created_at+ changed = True+ if (+ "response_id" in payload+ and self._public_id is not None+ and payload["response_id"] != self._public_id+ ):+ payload["response_id"] = self._public_id+ changed = True+ number = payload.get("sequence_number")+ if isinstance(number, int) and not isinstance(number, bool):+ if self._replacement:+ if self._offset is None:+ self._offset = max(0, self._sequence + 1 - number)+ if self._offset:+ payload["sequence_number"] = number + self._offset+ changed = True+ number += self._offset+ self._sequence = max(self._sequence, number)+ frame = replace_frame_data(frame, payload) if changed else frame+ return frame if metadata else self._release_content(frame)++ def _metadata(self, kind: str, payload: dict[str, Any]) -> bool:+ if kind == "ping":+ return True+ if self._wire_api == "messages" and kind == "message_start":+ message = payload.get("message")+ return (+ isinstance(message, dict)+ and message.get("content", []) == []+ and message.get("stop_reason") is None+ )+ if self._wire_api == "responses" and kind in {+ "response.created",+ "response.in_progress",+ }:+ response = payload.get("response")+ return (+ isinstance(response, dict)+ and response.get("output", []) == []+ and response.get("status") in (None, "queued", "in_progress")+ )+ return Falsediff --git a/src/free_claude_code/api/tool_call_buffer.py b/src/free_claude_code/api/tool_call_buffer.pyindex 5bd77c34..e1931576 100644--- a/src/free_claude_code/api/tool_call_buffer.py+++ b/src/free_claude_code/api/tool_call_buffer.py@@ -1,17 +1,16 @@"""Withhold incomplete client tool calls at the public SSE delivery boundary."""-import refrom collections.abc import AsyncIterator, Mappingfrom typing import Literal, cast-import simplejson-from free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoderfrom free_claude_code.core.async_iterators import try_close_async_iteratorfrom free_claude_code.core.json_types import JsonValuefrom free_claude_code.core.openai_responses import is_client_search+from .stream_delivery import PublicStreamEnvelope, frame_data, replace_frame_data+type CallKey = int | str_UNFINISHED = frozenset({"in_progress", "incomplete", "failed"})@@ -51,7 +50,11 @@ class ToolCallBufferedStream(AsyncIterator[str]):"""Keep overlapping calls and intervening frames in their original order."""def __init__(- self, body: AsyncIterator[str], *, wire_api: Literal["messages", "responses"]+ self,+ body: AsyncIterator[str],+ *,+ wire_api: Literal["messages", "responses"],+ envelope: PublicStreamEnvelope | None = None,) -> None:self._body = bodyself._wire_api = wire_api@@ -65,6 +68,8 @@ class ToolCallBufferedStream(AsyncIterator[str]):self._indices: dict[int, CallKey] = {}self._done = Falseself._closed = False+ self._envelope = envelope+ self._revision = envelope.state.attempt_revision if envelope else 0def __aiter__(self) -> ToolCallBufferedStream:return self@@ -74,25 +79,52 @@ class ToolCallBufferedStream(AsyncIterator[str]):try:chunk = await anext(self._body)except StopAsyncIteration:+ self._synchronize()self._done = Trueframes = self._decoder.finish_frames()except BaseException:+ self._synchronize()self._discard_group()+ if self._envelope is not None:+ self._envelope.discard_pending_starts()raiseelse:+ self._synchronize()frames = self._decoder.feed_frames(chunk)ready = [value for frame in frames for value in self._accept(frame)]+ if self._envelope is not None:+ ready = [+ value+ for frame in ready+ if (value := self._envelope.publish(frame)) is not None+ ]if self._done:self._discard_group()+ if self._envelope is not None:+ self._envelope.discard_pending_starts()if ready:return "".join(ready)raise StopAsyncIteration+ def _synchronize(self) -> None:+ envelope = self._envelope+ if envelope is None or self._revision == envelope.state.attempt_revision:+ return+ self._revision = envelope.state.attempt_revision+ self._discard_group()+ self._decoder = AnthropicSSEDecoder()+ self._ids.clear()+ self._indices.clear()+ self._delivered.clear()+ self._discarded.clear()+async def aclose(self) -> None:if self._closed:returnself._closed = Trueself._discard_group()+ if self._envelope is not None:+ self._envelope.discard_pending_starts()self._decoder.finish_frames()self._ids.clear()self._indices.clear()@@ -206,14 +238,8 @@ class ToolCallBufferedStream(AsyncIterator[str]):def _filter_snapshot(self, frame: str) -> str:# Parse only frames we may edit using decimal-aware JSON; all other# payloads, including argument strings and SSE framing, stay verbatim.- lines = re.split(r"(\r\n|\r|\n)", frame)- text = "\n".join(- line[5:].lstrip(" ") for line in lines[::2] if line.startswith("data:")- )- if not text:- return frame- value: object = simplejson.loads(text, use_decimal=True)- if not isinstance(value, dict):+ value = frame_data(frame)+ if value is None:return frameresponse = value.get("response")if not isinstance(response, dict):@@ -233,21 +259,7 @@ class ToolCallBufferedStream(AsyncIterator[str]):if len(retained) == len(output):return frameresponse["output"] = retained- replacement = "data: " + simplejson.dumps(- value, use_decimal=True, ensure_ascii=False- )- parts: list[str] = []- replaced = False- for index in range(0, len(lines), 2):- line = lines[index]- ending = lines[index + 1] if index + 1 < len(lines) else ""- if line.startswith("data:"):- if replaced:- continue- line = replacement- replaced = True- parts.extend((line, ending))- return "".join(parts)+ return replace_frame_data(frame, value)def _withheld_item(self, item: Mapping[str, object], response_status: objectdiff --git a/src/free_claude_code/application/web_tools/service.py b/src/free_claude_code/application/web_tools/service.pyindex 7b7924f9..dbfb69f4 100644--- a/src/free_claude_code/application/web_tools/service.py+++ b/src/free_claude_code/application/web_tools/service.py@@ -32,6 +32,7 @@ from free_claude_code.core.anthropic.server_tool_sse import ()from free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.json_types import JsonObject+from free_claude_code.core.stream_delivery import bind_stream_deliveryfrom free_claude_code.core.trace import close_stream_input, trace_eventfrom free_claude_code.core.web_tools import WebSearchResult@@ -142,15 +143,16 @@ class WebToolService:request_id=request_id,)chunks: list[str] = []- try:- chunks.extend([chunk async for chunk in provider_stream])- finally:- await close_stream_input(- provider_stream,- owner="automatic_web_search",- source="api",- preserved_error=sys.exception(),- )+ with bind_stream_delivery(None):+ try:+ chunks.extend([chunk async for chunk in provider_stream])+ finally:+ await close_stream_input(+ provider_stream,+ owner="automatic_web_search",+ source="api",+ preserved_error=sys.exception(),+ )message, stream_error, _complete = await aggregate_anthropic_sse_to_message(_iterate_chunks(chunks)diff --git a/src/free_claude_code/core/anthropic/conversion.py b/src/free_claude_code/core/anthropic/conversion.pyindex 528486ad..80e24922 100644--- a/src/free_claude_code/core/anthropic/conversion.py+++ b/src/free_claude_code/core/anthropic/conversion.py@@ -517,11 +517,8 @@ class AnthropicToOpenAIConverter:content,context="an inline Anthropic system message",)- if system_text is None:- raise OpenAIConversionError(- "OpenAI chat conversion requires an inline Anthropic system "- "message to contain text."- )+ if not system_text:+ return []# Reserve the downstream system role for request.system at index zero.return [_PlainSegment([{"role": "user", "content": system_text}])]if role == "assistant" and isinstance(content, list):diff --git a/src/free_claude_code/core/stream_delivery.py b/src/free_claude_code/core/stream_delivery.pynew file mode 100644index 00000000..38bd0ab5--- /dev/null+++ b/src/free_claude_code/core/stream_delivery.py@@ -0,0 +1,47 @@+"""Request-local evidence of public stream delivery, independent of wire format."""++from collections.abc import Iterator+from contextlib import contextmanager+from contextvars import ContextVar+++class StreamDeliveryState:+ """Retain public commitment while identifying invisible generation attempts."""++ def __init__(self) -> None:+ self._content_released = False+ self._attempt_revision = 0++ @property+ def content_released(self) -> bool:+ return self._content_released++ @property+ def attempt_revision(self) -> int:+ return self._attempt_revision++ def release_content(self) -> None:+ self._content_released = True++ def begin_attempt(self) -> None:+ if not self._content_released:+ self._attempt_revision += 1+++_delivery: ContextVar[StreamDeliveryState | None] = ContextVar(+ "stream_delivery", default=None+)+++def current_stream_delivery() -> StreamDeliveryState | None:+ return _delivery.get()+++@contextmanager+def bind_stream_delivery(state: StreamDeliveryState | None) -> Iterator[None]:+ """Bind only for an iterator operation, or mask a private stream consumer."""+ token = _delivery.set(state)+ try:+ yield+ finally:+ _delivery.reset(token)diff --git a/src/free_claude_code/providers/admission.py b/src/free_claude_code/providers/admission.pyindex 51f3373f..55123f50 100644--- a/src/free_claude_code/providers/admission.py+++ b/src/free_claude_code/providers/admission.py@@ -15,6 +15,10 @@ from typing import TypeVarfrom loguru import logger+from free_claude_code.core.stream_delivery import (+ StreamDeliveryState,+ current_stream_delivery,+)from free_claude_code.core.trace import trace_eventfrom free_claude_code.providers.admission_policy import ProviderAdmissionLimitsfrom free_claude_code.providers.failure_policy import (@@ -90,6 +94,11 @@ class ProviderExecution:self._active_claim: _AttemptClaim | None = Noneself._last_failure: Exception | None = Noneself._state = ProviderExecutionState.ACTIVE+ self._delivery = current_stream_delivery()++ @property+ def delivery(self) -> StreamDeliveryState | None:+ return self._delivery@propertydef execution_id(self) -> str:@@ -133,7 +142,10 @@ class ProviderExecution:operation_kind: ProviderOperationKind,) -> ProviderAttempt:"""Open the sole active physical call for this execution."""- return await self._controller._open_attempt(self, operation_kind)+ attempt = await self._controller._open_attempt(self, operation_kind)+ if operation_kind is ProviderOperationKind.GENERATION and self._delivery:+ self._delivery.begin_attempt()+ return attemptasync def run_call(self,diff --git a/src/free_claude_code/providers/anthropic_messages/passthrough.py b/src/free_claude_code/providers/anthropic_messages/passthrough.pyindex 0cd0fa04..1038c071 100644--- a/src/free_claude_code/providers/anthropic_messages/passthrough.py+++ b/src/free_claude_code/providers/anthropic_messages/passthrough.py@@ -26,10 +26,17 @@ from free_claude_code.providers.admission import (from free_claude_code.providers.failure_policy import (RetryableProviderProtocolError,classify_provider_failure,+ is_retryable_stream_error,)from free_claude_code.providers.http import ProviderAttemptScope+from free_claude_code.providers.stream_recovery import can_retry_undelivered_stream-from .wire import check_messages_failure, messages_events, messages_status_error+from .wire import (+ check_messages_failure,+ is_messages_stop,+ messages_events,+ messages_status_error,+)async def stream_native_messages(@@ -75,6 +82,7 @@ async def stream_native_messages(returncommitted = Falsewhile execution.can_attempt:+ normal_stop_seen = Falsescope = Nonetry:attempt = await execution.open_attempt(ProviderOperationKind.GENERATION)@@ -103,6 +111,7 @@ async def stream_native_messages()relay = NativeMessagesPassthrough(public_model)async for kind, payload in messages_events(response):+ normal_stop_seen |= is_messages_stop(kind, payload)check_messages_failure(kind, payload, native=True)output = relay.feed(kind, payload)if output is None:@@ -128,9 +137,24 @@ async def stream_native_messages(else raw_error)if scope is not None:- decision = await scope.attempt.fail(error)- if not committed and decision.retry_allowed:- continue+ hidden_stop = (+ normal_stop_seen+ and execution.delivery is not None+ and not execution.delivery.content_released+ )+ if hidden_stop:+ await scope.attempt.accept()+ else:+ decision = await scope.attempt.fail(error)+ if (+ not committed and decision.retry_allowed+ ) or can_retry_undelivered_stream(+ execution.delivery,+ retryable=is_retryable_stream_error(error),+ attempts_remaining=execution.attempts_remaining,+ normal_stop_seen=normal_stop_seen,+ ):+ continueif error is not raw_error:raise error from raw_errorraisediff --git a/src/free_claude_code/providers/anthropic_messages/transport.py b/src/free_claude_code/providers/anthropic_messages/transport.pyindex 58e6182d..0ffd6a72 100644--- a/src/free_claude_code/providers/anthropic_messages/transport.py+++ b/src/free_claude_code/providers/anthropic_messages/transport.py@@ -69,7 +69,12 @@ from .request_policy import (MessagesModelCapabilities,resolve_messages_options,)-from .wire import check_messages_failure, messages_events, messages_status_error+from .wire import (+ check_messages_failure,+ is_messages_stop,+ messages_events,+ messages_status_error,+)type _Presenter = NativeMessagesRelay | AnthropicToResponsesStream@@ -264,13 +269,14 @@ class AnthropicMessagesTransport:presenter_factory: Callable[[ReplayOrigin], _Presenter],reasoning_correction: ReasoningCorrection | None = None,) -> AsyncIterator[str]:- recovery = RecoveryController()+ recovery = RecoveryController(execution.delivery)request_endpoint = RequestEndpoint(endpoint_context)request_recovery = RequestRecovery(execution, endpoint=request_endpoint, stream=recovery)corrections = RequestCorrections("messages", reasoning_correction)while execution.can_attempt:+ normal_stop_seen = Falsescope: ProviderAttemptScope | None = Nonestream_opened = Falsesent_body = body@@ -328,6 +334,7 @@ class AnthropicMessagesTransport:)stream_opened = Trueasync for event_type, payload in messages_events(response):+ normal_stop_seen |= is_messages_stop(event_type, payload)check_messages_failure(event_type, payload)output = presenter.feed(event_type, payload)if event_type != "ping" and not attempt.accepted:@@ -367,6 +374,7 @@ class AnthropicMessagesTransport:scope.attempt,body,operation_kind=ProviderOperationKind.GENERATION,+ normal_stop_seen=normal_stop_seen,propose_correction=partial(corrections.next_body,raw_error,@@ -380,7 +388,14 @@ class AnthropicMessagesTransport:recovery.discard()continueif scope is not None and not scope.attempt.accepted:- attempt_failure = await scope.attempt.fail(error)+ if (+ normal_stop_seen+ and execution.delivery is not None+ and not execution.delivery.content_released+ ):+ await scope.attempt.accept()+ else:+ attempt_failure = await scope.attempt.fail(error)if attempt_failure is not None and attempt_failure.retry_allowed:recovery.discard()continue@@ -392,6 +407,7 @@ class AnthropicMessagesTransport:generated_output=recovery.committed,complete_tool_salvageable=False,attempts_remaining=execution.attempts_remaining,+ normal_stop_seen=normal_stop_seen,)if decision.action is RecoveryFailureAction.EARLY_RETRY:recovery.discard()diff --git a/src/free_claude_code/providers/anthropic_messages/wire.py b/src/free_claude_code/providers/anthropic_messages/wire.pyindex fd75a110..4d5f11d5 100644--- a/src/free_claude_code/providers/anthropic_messages/wire.py+++ b/src/free_claude_code/providers/anthropic_messages/wire.py@@ -46,6 +46,16 @@ async def messages_events(yield kind, payload+def is_messages_stop(event_type: str, payload: JsonObject) -> bool:+ """Capture a model stop before presentation or validation can reject it."""+ delta = payload.get("delta")+ return event_type == "message_stop" or (+ event_type == "message_delta"+ and isinstance(delta, Mapping)+ and delta.get("stop_reason") is not None+ )++def check_messages_failure(event_type: str, payload: JsonObject, *, native: bool = False) -> None:diff --git a/src/free_claude_code/providers/openai_chat/transport.py b/src/free_claude_code/providers/openai_chat/transport.pyindex e2154d85..ebfe9f3f 100644--- a/src/free_claude_code/providers/openai_chat/transport.py+++ b/src/free_claude_code/providers/openai_chat/transport.py@@ -208,6 +208,7 @@ class _OpenAIChatStreamAssembler:if self._structured_reasoning is not None:self._output.reasoning_replay = self._structured_reasoningself._finish_reason: Any = None+ self._raw_stop_seen = Falseself._usage_info: Any = Noneself._native_reasoning_seen = Falseself._tool_argument_aliases: dict[str, dict[str, str]] = {}@@ -249,6 +250,14 @@ class _OpenAIChatStreamAssembler:def tool_argument_alias_buffers(self) -> Mapping[int, str]:return self._tool_argument_alias_buffers+ @property+ def normal_stop_seen(self) -> bool:+ return self._raw_stop_seen or self._finish_reason is not None++ def observe_upstream_chunk(self, chunk: Any) -> None:+ if chunk.choices and chunk.choices[0].finish_reason is not None:+ self._raw_stop_seen = True+def recovered_tool_call_events(self, tool_call: CompletedOpenAIToolCall) -> Iterator[str]:@@ -288,7 +297,7 @@ class _OpenAIChatStreamAssembler:)choice = chunk.choices[0]delta = choice.delta- if choice.finish_reason:+ if choice.finish_reason is not None:self._finish_reason = choice.finish_reasonif delta is None:return@@ -577,6 +586,7 @@ class OpenAIChatTransport:endpoint: RequestEndpoint | None = None,request_client: OpenAIRequestClient | None = None,extra_headers: Mapping[str, str] | None = None,+ on_event: Callable[[Any], None] | None = None,) -> tuple[Any, dict, ProviderAttempt, dict]:"""Create a streaming chat completion with bounded request fallbacks."""execution = request_recovery.execution@@ -629,7 +639,8 @@ class OpenAIChatTransport:await client.chat.completions.create(**create_body,stream=True,- )+ ),+ on_event=on_event,)stream = self._behavior.normalize_stream(stream, body)retain_attempt = True@@ -889,7 +900,7 @@ class _OpenAIChatStreamRunner:execution = self._transport._admission.start_execution(request_id=self._request_id)- recovery = RecoveryController()+ recovery = RecoveryController(execution.delivery)request_recovery = RequestRecovery(execution, endpoint=self._endpoint, stream=recovery)@@ -959,6 +970,7 @@ class _OpenAIChatStreamRunner:endpoint=self._endpoint,request_client=self._request_client,extra_headers=self._extra_headers,+ on_event=assembler.observe_upstream_chunk,)scope = ProviderAttemptScope(attempt,@@ -1001,6 +1013,7 @@ class _OpenAIChatStreamRunner:scope.attempt,body,operation_kind=ProviderOperationKind.GENERATION,+ normal_stop_seen=assembler.normal_stop_seen,propose_correction=partial(corrections.next_body,error,@@ -1108,10 +1121,19 @@ class _OpenAIChatStreamRunner:execution = request_recovery.executionattempt_failure = Noneif scope is not None and not scope.attempt.accepted:- attempt_failure = await scope.attempt.fail(- error,- provider_failure_override=self._transport._behavior.failure_override,- )+ if (+ assembler.normal_stop_seen+ and execution.delivery is not None+ and not execution.delivery.content_released+ ):+ # The raw stop proves acceptance even if normalization rejected it.+ # Do not reserve a retry probe for this terminal execution.+ await scope.attempt.accept()+ else:+ attempt_failure = await scope.attempt.fail(+ error,+ provider_failure_override=self._transport._behavior.failure_override,+ )retryable = (attempt_failure.retryable@@ -1126,6 +1148,7 @@ class _OpenAIChatStreamRunner:generated_output=generated_output,complete_tool_salvageable=complete_tool_salvageable,attempts_remaining=execution.attempts_remaining,+ normal_stop_seen=assembler.normal_stop_seen,)tag = self._transport._provider_nameif decision.action == RecoveryFailureAction.EARLY_RETRY:diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex 4503b39a..d55d4b67 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -313,7 +313,7 @@ class OpenAIResponsesTransport:extra_headers: Mapping[str, str] | None = None,reasoning_correction: ReasoningCorrection | None = None,) -> AsyncIterator[str]:- recovery = RecoveryController()+ recovery = RecoveryController(execution.delivery)request_recovery = RequestRecovery(execution, endpoint=endpoint, stream=recovery)@@ -331,6 +331,7 @@ class OpenAIResponsesTransport:)while execution.can_attempt:+ normal_stop_seen = Falsepresenter = presenter_factory()start_events = tuple(presenter.start())presenter_started = False@@ -372,6 +373,10 @@ class OpenAIResponsesTransport:stream_opened = Trueasync 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:@@ -449,6 +454,7 @@ class OpenAIResponsesTransport:scope.attempt,body,operation_kind=ProviderOperationKind.GENERATION,+ normal_stop_seen=normal_stop_seen,propose_correction=partial(corrections.next_body,raw_error,@@ -487,6 +493,7 @@ class OpenAIResponsesTransport:generated_output=recovery.committed,complete_tool_salvageable=False,attempts_remaining=execution.attempts_remaining,+ normal_stop_seen=normal_stop_seen,)if decision.action is RecoveryFailureAction.EARLY_RETRY:recovery.discard()diff --git a/src/free_claude_code/providers/openai_stream.py b/src/free_claude_code/providers/openai_stream.pyindex 28aa42c6..b83f878c 100644--- a/src/free_claude_code/providers/openai_stream.py+++ b/src/free_claude_code/providers/openai_stream.py@@ -1,6 +1,6 @@"""Adapt the OpenAI SDK stream to FCC's asynchronous cleanup contract."""-from collections.abc import AsyncIterator+from collections.abc import AsyncIterator, Callablefrom openai import AsyncStream@@ -8,14 +8,23 @@ from openai import AsyncStreamclass OpenAIStreamAdapter[EventT](AsyncIterator[EventT]):"""Own an SDK response stream without closing its reusable client."""- def __init__(self, stream: AsyncStream[EventT]) -> None:+ def __init__(+ self,+ stream: AsyncStream[EventT],+ *,+ on_event: Callable[[EventT], None] | None = None,+ ) -> None:self._stream = stream+ self._on_event = on_eventdef __aiter__(self) -> AsyncIterator[EventT]:return selfasync def __anext__(self) -> EventT:- return await anext(self._stream)+ event = await anext(self._stream)+ if self._on_event is not None:+ self._on_event(event)+ return eventasync def aclose(self) -> None:await self._stream.close()diff --git a/src/free_claude_code/providers/request_recovery.py b/src/free_claude_code/providers/request_recovery.pyindex 56a0b1d3..8ce43170 100644--- a/src/free_claude_code/providers/request_recovery.py+++ b/src/free_claude_code/providers/request_recovery.py@@ -72,7 +72,16 @@ class RequestRecovery:*,operation_kind: ProviderOperationKind,propose_correction: Callable[[], JsonObject | None],+ normal_stop_seen: bool = False,) -> JsonObject | None:+ delivery = self.execution.delivery+ if (+ operation_kind is ProviderOperationKind.GENERATION+ and normal_stop_seen+ and delivery is not None+ and not delivery.content_released+ ):+ return Noneif await self.retry_authentication(error, auth_status, attempt):return bodyif operation_kind is ProviderOperationKind.GENERATION and self._committed:diff --git a/src/free_claude_code/providers/stream_recovery.py b/src/free_claude_code/providers/stream_recovery.pyindex 149bef2c..898c1778 100644--- a/src/free_claude_code/providers/stream_recovery.py+++ b/src/free_claude_code/providers/stream_recovery.py@@ -5,6 +5,8 @@ from collections.abc import Callablefrom dataclasses import dataclassfrom enum import StrEnum+from free_claude_code.core.stream_delivery import StreamDeliveryState+from .failure_policy import RetryableProviderProtocolErrorEARLY_HOLDBACK_SECONDS = 0.75@@ -88,8 +90,9 @@ class RecoveryHoldbackBuffer:class RecoveryController:"""Own commit-boundary holdback for one provider stream lifecycle."""- def __init__(self) -> None:+ def __init__(self, delivery: StreamDeliveryState | None = None) -> None:self._holdback = RecoveryHoldbackBuffer()+ self._delivery = delivery@propertydef committed(self) -> bool:@@ -121,14 +124,28 @@ class RecoveryController:generated_output: bool,complete_tool_salvageable: bool,attempts_remaining: int,+ normal_stop_seen: bool = False,) -> RecoveryDecision:committed = self._holdback.committedhas_buffered = self._holdback.has_bufferedretry_available = attempts_remaining > 0reserve_last_attempt_for_recovery = generated_output and attempts_remaining == 1+ public_hidden = (+ self._delivery is not None and not self._delivery.content_released+ )+if (- retryable+ stream_opened+ and can_retry_undelivered_stream(+ self._delivery,+ retryable=retryable,+ attempts_remaining=attempts_remaining,+ normal_stop_seen=normal_stop_seen,+ )+ ) or (+ not public_hidden+ and retryableand retry_availableand stream_openedand not committed@@ -145,7 +162,8 @@ class RecoveryController:)if (- retryable+ not public_hidden+ and retryableand generated_outputand (retry_available or complete_tool_salvageable)):@@ -162,3 +180,20 @@ class RecoveryController:committed=committed,has_buffered=has_buffered,)+++def can_retry_undelivered_stream(+ delivery: StreamDeliveryState | None,+ *,+ retryable: bool,+ attempts_remaining: int,+ normal_stop_seen: bool,+) -> bool:+ """A clean restart is safe only before content and a normal model stop."""+ return (+ delivery is not None+ and not delivery.content_released+ and retryable+ and attempts_remaining > 0+ and not normal_stop_seen+ )diff --git a/tests/api/test_hidden_retry_admission.py b/tests/api/test_hidden_retry_admission.pynew file mode 100644index 00000000..54e75898--- /dev/null+++ b/tests/api/test_hidden_retry_admission.py@@ -0,0 +1,203 @@+"""Stopped public generations release recovery ownership for later requests."""++import asyncio+import json+from contextlib import asynccontextmanager++import httpx+import pytest+from starlette.responses import StreamingResponse++from free_claude_code.api.response_streams import (+ anthropic_sse_streaming_response,+ openai_responses_sse_streaming_response,+)+from free_claude_code.providers.anthropic_messages.passthrough import (+ stream_native_messages,+)+from free_claude_code.providers.failure_policy import RetryableProviderProtocolError+from tests.api.test_response_streams import _json_error, _serve+from tests.providers.test_anthropic_messages_transport import (+ Endpoint,+ _events,+ _sse,+ _stream,+ _transport,+)+from tests.providers.test_history_transports import _events_for, _harness+from tests.providers.test_provider_admission import _controller, _open, _status_error+from tests.providers.test_request_recovery_transitions import Wire+++async def _response(source, wire):+ options = {"pre_start_error_response": _json_error, "request_id": "stopped"}+ return await (+ anthropic_sse_streaming_response(source, **options)+ if wire == "messages"+ else openai_responses_sse_streaming_response(source, headers={}, **options)+ )+++@asynccontextmanager+async def _messages_path(route, respond, *, max_attempts=3):+ bodies = []+ wires = []+ admission = _controller(max_attempts=max_attempts, max_concurrency=2)++ def reply(request):+ bodies.append(json.loads(request.content))+ status, payload = respond(len(bodies))+ wire = (+ payload+ if isinstance(payload, Wire)+ else Wire(_sse(*payload) if status == 200 else json.dumps(payload).encode())+ )+ wires.append(wire)+ return httpx.Response(+ status,+ headers={"content-type": "text/event-stream"},+ stream=wire,+ )++ async with httpx.AsyncClient(transport=httpx.MockTransport(reply)) as client:+ transport = _transport(client, admission)++ def source():+ if route == "native":+ return stream_native_messages(+ client,+ admission,+ base_url="https://native.invalid/v1",+ headers={},+ body={+ "model": "native",+ "stream": True,+ "messages": [{"role": "user", "content": "hi"}],+ },+ public_model="public",+ provider_name="TEST",+ read_timeout_s=3,+ request_id="stopped",+ )+ return _stream(transport, Endpoint(), responses=route == "responses")++ yield source, bodies, wires, admission++[email protected]("route", ["native", "messages", "responses"])[email protected]("terminal", ["message_delta", "message_stop"])+ "max_attempts,probe", [(3, False), (1, False), (3, True), (2, True)]+)+async def test_stopped_first_messages_event_releases_admission(+ route, terminal, max_attempts, probe+):+ stopped = {"type": terminal}+ if terminal == "message_delta":+ stopped["delta"] = {"stop_reason": "end_turn"}++ def respond(ordinal):+ if probe and ordinal == 1:+ return 503, {"error": {"type": "overloaded_error", "message": "busy"}}+ return 200, [stopped] if ordinal == 1 + probe else _events()++ wire = "responses" if route == "responses" else "messages"+ async with _messages_path(route, respond, max_attempts=max_attempts) as (+ source,+ bodies,+ wires,+ admission,+ ):+ failed = await _response(source(), wire)+ assert failed.status_code == 502+ assert len(bodies) == 1 + probe+ assert all(item.close_calls == 1 for item in wires)+ assert admission._episode is None+ recovered = await asyncio.wait_for(_response(source(), wire), timeout=1)+ assert isinstance(recovered, StreamingResponse)+ await _serve(recovered)+ assert len(bodies) == 2 + probe+ assert all(item.close_calls == 1 for item in wires)++[email protected]("route", ["native", "messages", "responses"])+async def test_unstopped_first_messages_event_still_retries(route):+ def respond(ordinal):+ return 200, (+ [{"type": "message_delta", "delta": {"stop_reason": None}}]+ if ordinal == 1+ else _events()+ )++ async with _messages_path(route, respond) as (source, bodies, wires, admission):+ result = await _response(+ source(), "responses" if route == "responses" else "messages"+ )+ assert isinstance(result, StreamingResponse)+ await _serve(result)+ assert len(bodies) == 2 and bodies[0] == bodies[1]+ assert all(item.close_calls == 1 for item in wires)+ assert admission._episode is None++[email protected]("wire", ["messages", "responses"])[email protected]("terminal", ["response.completed", "response.incomplete"])+async def test_stopped_first_responses_event_releases_admission(wire, terminal):+ event = {+ "type": terminal,+ "response": {"status": terminal.split(".")[1], "output": []},+ }+ async with _harness(+ "responses",+ lambda bodies: (200, [event] if len(bodies) == 1 else _events_for("responses")),+ ) as (send, bodies, transport):++ def adapter(kind, payload):+ if len(bodies) == 1:+ raise RetryableProviderProtocolError(+ "terminal adapter rejected snapshot"+ )+ return payload++ transport._event_adapter_factory = lambda: adapter+ history = [{"role": "user", "content": "hi"}]+ failed = await _response(send(wire, history), wire)+ assert failed.status_code == 502 and len(bodies) == 1+ recovered = await asyncio.wait_for(+ _response(send(wire, history), wire), timeout=1+ )+ assert isinstance(recovered, StreamingResponse)+ await _serve(recovered)+ assert len(bodies) == 2++[email protected]("route", ["native", "messages", "responses"])+async def test_stopped_messages_cannot_close_another_executions_recovery(route):+ leader = None++ class ConcurrentWire(Wire):+ async def __aiter__(self):+ assert leader is not None+ await leader.fail(_status_error(503))+ await leader.aclose()+ async for chunk in super().__aiter__():+ yield chunk++ async with _messages_path(+ route, lambda _: (200, ConcurrentWire(_sse({"type": "message_stop"})))+ ) as (source, _bodies, _wires, admission):+ other = admission.start_execution()+ leader = await _open(other)+ result = await _response(+ source(), "responses" if route == "responses" else "messages"+ )+ assert result.status_code == 502+ assert admission._episode is not None and admission._episode.leader is other+ probe = await asyncio.wait_for(_open(other), timeout=1)+ await probe.accept()+ await probe.aclose()+ other.succeed()diff --git a/tests/api/test_hidden_stream_retries.py b/tests/api/test_hidden_stream_retries.pynew file mode 100644index 00000000..332563a3--- /dev/null+++ b/tests/api/test_hidden_stream_retries.py@@ -0,0 +1,833 @@+"""Physical provider retries use evidence from the public delivery boundary."""++import asyncio+import json+from copy import deepcopy+from itertools import pairwise+from unittest.mock import AsyncMock++import httpx+import pytest++from free_claude_code.api.response_streams import bind_response_lifetime+from free_claude_code.application.execution import ProviderExecutor+from free_claude_code.config.nim import NimSettings+from free_claude_code.core.anthropic import aggregate_anthropic_sse_to_message+from free_claude_code.core.anthropic.passthrough import NativeMessagesRequest+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.reasoning import ReasoningPolicy+from free_claude_code.providers.failure_policy import RetryableProviderProtocolError+from free_claude_code.providers.nvidia_nim import NvidiaNimProvider, native_tool_stream+from free_claude_code.providers.openai_chat.transport import _OpenAIChatStreamAssembler+from free_claude_code.providers.stream_recovery import RecoveryHoldbackBuffer+from tests.api.test_response_streams import _serve+from tests.api.test_tool_call_buffer import _response+from tests.api.test_tool_call_buffer_transports import _tools+from tests.application.test_execution import _routed_request+from tests.providers.support import immediate_admission, make_provider_config+from tests.providers.test_anthropic_messages_transport import Wire, _sse+from tests.providers.test_anthropic_provider import native_body, provider+from tests.providers.test_history_transports import _events_for, _harness, _native+from tests.providers.test_native_tool_arguments import tool_events+++def committed_holdback(monkeypatch):+ # Commit on metadata, regardless of whether a presenter emits partial args.+ monkeypatch.setattr(+ "free_claude_code.providers.stream_recovery.RecoveryHoldbackBuffer",+ lambda: RecoveryHoldbackBuffer(max_bytes=1),+ )+++def partial_tool(protocol):+ events = tool_events(protocol, '{"path":"old"}')+ events = events[:2] if protocol == "chat" else events[:3]+ if protocol == "chat":+ events[1]["choices"][0]["delta"]["tool_calls"][0]["function"]["arguments"] = (+ '{"path":"abandoned'+ )+ elif protocol == "messages":+ events[2]["delta"]["partial_json"] = '{"path":"abandoned'+ else:+ events[2]["delta"] = '{"path":"abandoned'+ return json.loads(+ json.dumps(events)+ .replace("call_probe", "call_abandoned")+ .replace("resp_probe", "resp_abandoned")+ )+++def executed(body, wire):+ async def open_candidate(_index, _target):+ return body++ return ProviderExecutor(+ AsyncMock(), progress_timeout_seconds=10+ )._stream_candidates(+ resolved=_routed_request().resolved,+ reasoning=ReasoningPolicy.provider_default(),+ wire_api=wire,+ raw_log_label="HIDDEN_RETRY",+ raw_log_payload=dict,+ request_snapshot=dict,+ ingress_count_name="message_count",+ ingress_count=1,+ request_id="hidden-retry",+ open_candidate=open_candidate,+ )+++async def delivered(body, wire):+ response = await _response(wire, executed(body, wire))+ messages = await _serve(response)+ return b"".join(message.get("body", b"") for message in messages).decode()+++def assert_winning_tool(result, wire):+ events = parse_sse_text(result)+ assert "call_abandoned" not in result+ if wire == "messages":+ assert sum(event.event == "message_start" for event in events) == 1+ assert events[-1].event == "message_stop"+ assert (+ "".join(+ event.data["delta"]["partial_json"]+ for event in events+ if event.data.get("delta", {}).get("type") == "input_json_delta"+ )+ == '{"path":"winning"}'+ )+ else:+ assert sum(event.event == "response.created" for event in events) == 1+ assert events[-1].event == "response.completed"+ call = events[-1].data["response"]["output"][0]+ assert call["call_id"] == "call_probe"+ assert call["arguments"] == '{"path":"winning"}'+ numbers = [event.data["sequence_number"] for event in events]+ assert all(right > left for left, right in pairwise(numbers))+ ids = {+ event.data["response"]["id"] for event in events if "response" in event.data+ }+ assert len(ids) == 1++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_hidden_tool_cutoff_retries_identical_generation(+ protocol, wire, committed_holdback+):+ def reply(bodies):+ return 200, (+ partial_tool(protocol)+ if len(bodies) == 1+ else tool_events(protocol, '{"path":"winning"}')+ )++ async with _harness(protocol, reply) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)),+ wire,+ )+ assert len(bodies) == 2+ assert bodies[0] == bodies[1]+ assert_winning_tool(result, wire)+++async def test_raw_native_messages_hidden_cutoff_retries_and_closes_first():+ bodies = []+ first = Wire([_sse(*partial_tool("messages"))])+ second = Wire([_sse(*tool_events("messages", '{"path":"winning"}'))])++ def reply(request):+ bodies.append(json.loads(request.content))+ if len(bodies) == 2:+ assert first.closed+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=first if len(bodies) == 1 else second,+ )++ p = provider(reply)+ try:+ result = await delivered(+ p.stream_native_messages(NativeMessagesRequest(native_body(True))),+ "messages",+ )+ assert len(bodies) == 2+ assert bodies[0] == bodies[1]+ assert first.closed and second.closed+ assert_winning_tool(result, "messages")+ finally:+ await p.cleanup()++[email protected]("separator", ["-", "\u2028", "\u2029", "\x85"])+async def test_raw_native_unicode_metadata_keeps_hidden_retry_eligible(separator):+ abandoned = partial_tool("messages")+ abandoned[0]["message"]["extension"] = "a" + separator + "b"+ first = Wire([_sse(*abandoned)])+ winner = tool_events("messages", '{"path":"winning"}')+ winner[0]["message"]["extension"] = "winner" + separator + "b"+ second = Wire([_sse(*winner)])+ bodies = []++ def reply(request):+ bodies.append(json.loads(request.content))+ if len(bodies) == 2:+ assert first.closed+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=first if len(bodies) == 1 else second,+ )++ p = provider(reply)+ try:+ result = await delivered(+ p.stream_native_messages(NativeMessagesRequest(native_body(True))),+ "messages",+ )+ assert len(bodies) == 2 and bodies[0] == bodies[1]+ assert first.closed and second.closed+ assert_winning_tool(result, "messages")+ assert parse_sse_text(result)[0].data["message"]["extension"] == (+ "winner" + separator + "b"+ )+ finally:+ await p.cleanup()+++def _nim_factory():+ return NvidiaNimProvider(+ make_provider_config("test", "https://provider.invalid/v1"),+ nim_settings=NimSettings(),+ admission=immediate_admission(max_attempts=3),+ )+++def _nim_partial_terminal(reason):+ first = deepcopy(_events_for("chat")[0])+ first["choices"][0]["delta"] = {"role": "assistant"}+ first["choices"][0]["finish_reason"] = None+ stopped = deepcopy(first)+ stopped["choices"][0]["delta"] = {"content": "]<]minimax[>[<tool_call>"}+ stopped["choices"][0]["finish_reason"] = reason+ return [first, stopped]++[email protected]("wire", ["messages", "responses"])[email protected]("reason", ["stop", "length", "tool_calls", "content_filter"])+async def test_normal_chat_stop_survives_nim_normalization_failure(+ wire, reason, committed_holdback+):+ async with _harness(+ "chat",+ lambda bodies: (+ 200,+ _nim_partial_terminal(reason)+ if len(bodies) == 1+ else tool_events("chat", '{"path":"winning"}'),+ ),+ chat_provider_factory=_nim_factory,+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)),+ wire,+ )+ assert len(bodies) == 1+ assert "]<]minimax" not in result and "winning" not in result+ assert parse_sse_text(result)[-1].event == (+ "error" if wire == "messages" else "response.failed"+ )++[email protected]("wire", ["messages", "responses"])+async def test_nim_unstopped_normalization_failure_can_retry(wire, committed_holdback):+ async with _harness(+ "chat",+ lambda bodies: (+ 200,+ _nim_partial_terminal(None)+ if len(bodies) == 1+ else tool_events("chat", '{"path":"winning"}'),+ ),+ chat_provider_factory=_nim_factory,+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)),+ wire,+ )+ assert len(bodies) == 2 and bodies[0] == bodies[1]+ assert_winning_tool(result, wire)++[email protected]("wire", ["messages", "responses"])+async def test_replacement_nim_stop_prevents_third_generation(wire, committed_holdback):+ async with _harness(+ "chat",+ lambda bodies: (+ 200,+ _nim_partial_terminal(None if len(bodies) == 1 else "length")+ if len(bodies) <= 2+ else tool_events("chat", '{"path":"winning"}'),+ ),+ chat_provider_factory=_nim_factory,+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)),+ wire,+ )+ assert len(bodies) == 2 and bodies[0] == bodies[1]+ assert "winning" not in result+ assert parse_sse_text(result)[-1].event == (+ "error" if wire == "messages" else "response.failed"+ )+++async def test_concurrent_nim_requests_keep_stop_evidence_independent(+ committed_holdback,+):+ attempts = {"stopped": 0, "retry": 0}++ def reply(bodies):+ label = bodies[-1]["messages"][-1]["content"]+ attempts[label] += 1+ if label == "retry" and attempts[label] > 1:+ return 200, tool_events("chat", '{"path":"winning"}')+ return 200, _nim_partial_terminal("stop" if label == "stopped" else None)++ async with _harness("chat", reply, chat_provider_factory=_nim_factory) as (+ send,+ _,+ _,+ ):+ stopped, winning = await asyncio.gather(+ *[+ delivered(+ send(+ "messages",+ [{"role": "user", "content": label}],+ tools=_tools("messages"),+ ),+ "messages",+ )+ for label in ("stopped", "retry")+ ]+ )+ assert attempts == {"stopped": 1, "retry": 2}+ assert parse_sse_text(stopped)[-1].event == "error"+ assert_winning_tool(winning, "messages")++[email protected]("wire", ["messages", "responses"])+async def test_raw_nim_stop_survives_later_null_and_empty_choices(+ wire, committed_holdback, monkeypatch+):+ normalize = native_tool_stream._normalized_chunks++ def suppress_terminal(chunk, choice, *args, **kwargs):+ if choice.finish_reason is not None:+ return []+ return normalize(chunk, choice, *args, **kwargs)++ monkeypatch.setattr(native_tool_stream, "_normalized_chunks", suppress_terminal)+ first, terminal = _nim_partial_terminal("stop")+ terminal["choices"][0]["delta"] = {"content": ""}+ usage = {**deepcopy(first), "choices": []}+ async with _harness(+ "chat",+ lambda _: (200, [first, terminal, deepcopy(first), usage]),+ chat_provider_factory=_nim_factory,+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)),+ wire,+ )+ assert len(bodies) == 1+ assert parse_sse_text(result)[-1].event == (+ "error" if wire == "messages" else "response.failed"+ )+++def overlapping_tools(protocol):+ complete = json.loads(+ json.dumps(tool_events(protocol, '{"path":"oldA"}'))+ .replace("call_probe", "call_oldA")+ .replace("fc_probe", "fc_oldA")+ )+ partial = json.loads(+ json.dumps(partial_tool(protocol))+ .replace("call_abandoned", "call_oldB")+ .replace("fc_probe", "fc_oldB")+ )+ if protocol == "chat":+ for event in partial:+ event["choices"][0]["delta"]["tool_calls"][0]["index"] = 1+ return [complete[0], partial[0], *complete[1:-1], *partial[1:]]+ index_field = "index" if protocol == "messages" else "output_index"+ for event in partial[1:]:+ event[index_field] = 1+ return [+ complete[0],+ complete[1],+ partial[1],+ *partial[2:],+ *complete[2 : (-2 if protocol == "messages" else -1)],+ ]++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_complete_call_held_by_partial_call_restarts_on_last_attempt(+ protocol, wire, committed_holdback+):+ async with _harness(+ protocol,+ lambda bodies: (+ 200,+ overlapping_tools(protocol)+ if len(bodies) == 1+ else tool_events(protocol, '{"path":"winning"}'),+ ),+ max_attempts=2,+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == 2 and bodies[0] == bodies[1]+ assert "call_oldA" not in result and "call_oldB" not in result+ assert_winning_tool(result, wire)++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_hidden_failures_exhaust_one_budget_without_salvage(+ protocol, wire, committed_holdback+):+ async with _harness(+ protocol,+ lambda _: (200, overlapping_tools(protocol)),+ max_attempts=2,+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == 2 and bodies[0] == bodies[1]+ assert "call_oldA" not in result and "call_oldB" not in result+ assert parse_sse_text(result)[-1].event == (+ "error" if wire == "messages" else "response.failed"+ )++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])+async def test_replacement_rejection_before_frames_uses_public_empty_envelope(+ protocol, wire, committed_holdback+):+ def reply(bodies):+ return (+ (200, overlapping_tools(protocol))+ if len(bodies) == 1+ else (+ 400,+ {"code": "invalid_request_error", "message": "replacement rejected"},+ )+ )++ async with _harness(protocol, reply) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == 2 and bodies[0] == bodies[1]+ assert "call_oldA" not in result and "call_oldB" not in result+ events = parse_sse_text(result)+ assert events[-1].event == ("error" if wire == "messages" else "response.failed")+ if wire == "responses":+ assert events[-1].data["response"]["id"] == events[0].data["response"]["id"]+ assert events[-1].data["response"]["output"] == []++[email protected]("protocol", ["chat", "messages", "responses"])[email protected]("wire", ["messages", "responses"])[email protected]("retryable", [True, False])+async def test_typed_upstream_failure_qualifies_before_wire_error(+ protocol, wire, retryable, committed_holdback+):+ failure = (+ {+ "type": "error",+ "error": {+ "type": "overloaded_error" if retryable else "authentication_error",+ "message": "temporary overload" if retryable else "unauthorized",+ },+ }+ if protocol == "messages"+ else {+ "type": "error",+ "error": {+ "code": "rate_limit_exceeded" if retryable else "invalid_request_error",+ "message": "rate limit exceeded" if retryable else "invalid request",+ },+ "code": "rate_limit_exceeded" if retryable else "invalid_request_error",+ "message": "rate limit exceeded" if retryable else "invalid request",+ "sequence_number": 99,+ }+ )+ async with _harness(+ protocol,+ lambda bodies: (+ 200,+ [*partial_tool(protocol), failure]+ if len(bodies) == 1+ else tool_events(protocol, '{"path":"winning"}'),+ ),+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == (2 if retryable else 1)+ if retryable:+ assert bodies[0] == bodies[1]+ assert_winning_tool(result, wire)+ else:+ assert "call_abandoned" not in result+ assert parse_sse_text(result)[-1].event == (+ "error" if wire == "messages" else "response.failed"+ )++[email protected]("wire", ["messages", "responses"])[email protected]("terminal", ["response.completed", "response.incomplete"])+async def test_normal_responses_stop_prevents_retry_when_adapter_raises(+ wire, terminal, committed_holdback+):+ events = [+ *partial_tool("responses"),+ {+ "type": terminal,+ "response": {"status": terminal.split(".")[1], "output": []},+ "sequence_number": 4,+ },+ ]++ def adapter(kind, payload):+ if kind == terminal:+ raise RetryableProviderProtocolError("terminal adapter rejected snapshot")+ return payload++ async with _harness("responses", lambda _: (200, events)) as (+ send,+ bodies,+ transport,+ ):+ transport._event_adapter_factory = lambda: adapter+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == 1+ assert "call_abandoned" not in result+ assert parse_sse_text(result)[-1].event == (+ "error" if wire == "messages" else "response.failed"+ )++[email protected]("wire", ["messages", "responses"])[email protected]("stop", ["end_turn", "max_tokens", "refusal", "pause_turn"])+async def test_messages_normal_stop_with_open_hidden_block_cannot_retry(+ wire, stop, committed_holdback+):+ events = [+ *partial_tool("messages"),+ {+ "type": "message_delta",+ "delta": {"stop_reason": stop},+ "usage": {"output_tokens": 10},+ },+ ]+ async with _harness("messages", lambda _: (200, events)) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == 1 and "call_abandoned" not in result++[email protected]("wire", ["messages", "responses"])+async def test_thinking_hidden_inside_tool_group_can_be_discarded(+ wire, committed_holdback+):+ events = overlapping_tools("messages")+ events += [+ {+ "type": "content_block_start",+ "index": 2,+ "content_block": {"type": "thinking", "thinking": ""},+ },+ {+ "type": "content_block_delta",+ "index": 2,+ "delta": {"type": "thinking_delta", "thinking": "hidden old reasoning"},+ },+ ]+ async with _harness(+ "messages",+ lambda bodies: (+ 200,+ events+ if len(bodies) == 1+ else tool_events("messages", '{"path":"winning"}'),+ ),+ ) as (send, bodies, _):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == 2 and "hidden old reasoning" not in result+ assert_winning_tool(result, wire)++[email protected]("wire", ["messages", "responses"])[email protected]("reason", ["stop", "length", "tool_calls", "content_filter"])+async def test_normal_chat_finish_survives_later_parser_failure(+ wire, reason, committed_holdback, monkeypatch+):+ feed = _OpenAIChatStreamAssembler.feed++ def rejected_terminal(self, chunk):+ yield from feed(self, chunk)+ if chunk.choices and chunk.choices[0].finish_reason is not None:+ raise RetryableProviderProtocolError("terminal parsing failed")++ monkeypatch.setattr(_OpenAIChatStreamAssembler, "feed", rejected_terminal)+ terminal = tool_events("chat", "")[-1]+ terminal["choices"][0]["finish_reason"] = reason+ async with _harness("chat", lambda _: (200, [*partial_tool("chat"), terminal])) as (+ send,+ bodies,+ _,+ ):+ result = await delivered(+ send(wire, [{"role": "user", "content": "read"}], tools=_tools(wire)), wire+ )+ assert len(bodies) == 1 and "call_abandoned" not in result+ assert parse_sse_text(result)[-1].event == (+ "error" if wire == "messages" else "response.failed"+ )+++ "kind", ["text", "thinking", "server_tool_use", "future_block"]+)+async def test_raw_native_published_activity_prevents_clean_retry(kind):+ events = partial_tool("messages")+ events.insert(+ 1,+ {+ "type": "content_block_start",+ "index": 7,+ "content_block": {+ "type": kind,+ "text": "",+ "thinking": "",+ "id": "hosted",+ "name": "search",+ "input": {},+ },+ },+ )+ bodies = []++ def reply(request):+ bodies.append(json.loads(request.content))+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=Wire([_sse(*events)]),+ )++ p = provider(reply)+ try:+ result = await delivered(+ p.stream_native_messages(NativeMessagesRequest(native_body(True))),+ "messages",+ )+ assert len(bodies) == 1 and f'"type": "{kind}"' in result+ assert "call_abandoned" not in result+ finally:+ await p.cleanup()++[email protected]("cache_details", ["missing", "null", "zero", "partial"])+async def test_raw_native_retry_uses_winning_initial_usage_and_final_overrides(+ cache_details,+):+ first = partial_tool("messages")+ first[0]["message"]["usage"] = {+ "input_tokens": 1,+ "cache_read_input_tokens": 0,+ "cache_creation_input_tokens": 70,+ "cache_creation": {+ "ephemeral_5m_input_tokens": 70,+ "ephemeral_1h_input_tokens": 0,+ },+ "abandoned_extension": {"old": 7},+ "output_tokens": 0,+ }+ winner = tool_events("messages", '{"path":"winning"}')+ winner[0]["message"]["id"] = "msg_winning"+ winner[0]["message"]["usage"] = {+ "input_tokens": 0,+ "cache_read_input_tokens": 70,+ "cache_creation_input_tokens": 0,+ "output_tokens": 1,+ "winning_extension": {"note": "a\u2028b", "counts": [0, None]},+ }+ if cache_details != "missing":+ winner[0]["message"]["usage"]["cache_creation"] = (+ None+ if cache_details == "null"+ else {"ephemeral_5m_input_tokens": 0, "ephemeral_1h_input_tokens": 0}+ if cache_details == "zero"+ else {"ephemeral_1h_input_tokens": 0}+ )+ winner[-2]["usage"] = {"input_tokens": 25, "output_tokens": 10}+ bodies = []++ def reply(request):+ bodies.append(json.loads(request.content))+ return httpx.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ stream=Wire([_sse(*(first if len(bodies) < 3 else winner))]),+ )++ p = provider(reply, max_attempts=3)+ try:+ result = await delivered(+ p.stream_native_messages(NativeMessagesRequest(native_body(True))),+ "messages",+ )+ assert len(bodies) == 3 and bodies[0] == bodies[1] == bodies[2]+ events = parse_sse_text(result)+ assert events[0].data["message"]["id"] == "msg_winning"+ assert events[0].data["message"]["usage"] == winner[0]["message"]["usage"]+ assert events[-2].data["usage"] == winner[-2]["usage"]++ async def emitted():+ yield result++ message, error, complete = await aggregate_anthropic_sse_to_message(emitted())+ assert complete and error is None+ assert message["usage"] == {+ **winner[0]["message"]["usage"],+ **winner[-2]["usage"],+ }+ assert "abandoned_extension" not in result+ finally:+ await p.cleanup()++[email protected]("before_first_read", [False, True])+async def test_raw_native_cancellation_closes_once_without_replacement(+ before_first_read,+):+ reading = asyncio.Event()+ calls = []+ releases = []++ class BlockingWire(httpx.AsyncByteStream):+ closes = 0++ async def __aiter__(self):+ events = partial_tool("messages")+ yield _sse(events[0])+ yield _sse(*events[1:])+ reading.set()+ await asyncio.Event().wait()++ async def aclose(self):+ self.closes += 1++ wire = BlockingWire()++ def reply(request):+ calls.append(request)+ return httpx.Response(+ 200, headers={"content-type": "text/event-stream"}, stream=wire+ )++ async def release():+ releases.append(True)++ p = provider(reply)+ try:+ response = await _response(+ "messages",+ p.stream_native_messages(NativeMessagesRequest(native_body(True))),+ )+ await bind_response_lifetime(response, release)+ if not before_first_read:+ iterator = aiter(response.body_iterator)++ async def read():+ return [chunk async for chunk in iterator]++ task = asyncio.create_task(read())+ await asyncio.wait_for(reading.wait(), 1)+ task.cancel()+ with pytest.raises(asyncio.CancelledError):+ await task+ await response.aclose()+ await response.aclose()+ assert len(calls) == 1 and wire.closes == 1 and releases == [True]+ finally:+ await p.cleanup()+++async def test_hidden_retry_keeps_correction_and_uses_its_remaining_budget(+ committed_holdback,+):+ def reply(bodies):+ if len(bodies) == 1:+ return 400, {+ "code": "invalid_value",+ "param": "input[0].id",+ "message": "Invalid 'input[0].id': 'rs_a:rs_b'. Expected an ID that contains letters, numbers, underscores, or dashes.",+ }+ return 200, partial_tool("responses") if len(bodies) == 2 else tool_events(+ "responses", '{"path":"winning"}'+ )++ async with _harness("responses", reply, max_attempts=3) as (send, bodies, _):+ result = await delivered(+ send(+ "responses",+ [_native("responses"), {"role": "user", "content": "read"}],+ tools=_tools("responses"),+ ),+ "responses",+ )+ assert len(bodies) == 3+ assert bodies[0] != bodies[1] and bodies[1] == bodies[2]+ assert ":" not in bodies[1]["input"][0]["id"]+ assert_winning_tool(result, "responses")diff --git a/tests/api/test_model_fallback.py b/tests/api/test_model_fallback.pyindex 082e4eb4..dacaf601 100644--- a/tests/api/test_model_fallback.py+++ b/tests/api/test_model_fallback.py@@ -182,7 +182,7 @@ def test_postframe_failure_never_opens_fallback_for_streaming_messages() -> Noneassert response.status_code == 200events = parse_sse_text(response.text)- assert [event.event for event in events] == ["message_start", "error"]+ assert [event.event for event in events] == ["error"]assert fallback.stream_models == []diff --git a/tests/api/test_native_anthropic.py b/tests/api/test_native_anthropic.pyindex 8326c0b0..bf0b9310 100644--- a/tests/api/test_native_anthropic.py+++ b/tests/api/test_native_anthropic.py@@ -144,7 +144,7 @@ def test_leading_pings_allow_exhausted_primary_to_reach_native_fallback():assert all(wire.closed for wire in wires)-def test_stream_failure_after_start_emits_one_error_without_fallback():+def test_stream_failure_after_metadata_retries_same_provider_without_fallback():from free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom tests.providers.test_anthropic_messages_transport import _events, _sse@@ -175,9 +175,13 @@ def test_stream_failure_after_start_emits_one_error_without_fallback():response = client.post("/v1/messages", json=native_body(True))assert response.status_code == 200events = parse_sse_text(response.text)- assert [event.event for event in events] == ["message_start", "error"]+ assert [event.event for event in events] == ["error"]assert "anthropic-req-evidence" in response.text- assert len(requests) == 1+ assert len(requests) == 2+ assert json.loads(requests[0].content) == json.loads(requests[1].content)+ assert all(+ json.loads(request.content)["model"] == "primary" for request in requests+ )@pytest.mark.parametrize("view", ["claude", "claude-desktop", "messages"])diff --git a/tests/api/test_stream_delivery.py b/tests/api/test_stream_delivery.pynew file mode 100644index 00000000..98e5c14e--- /dev/null+++ b/tests/api/test_stream_delivery.py@@ -0,0 +1,352 @@+"""Public envelope observation preserves ordinary frames and invisible retries."""++import asyncio+import json+from decimal import Decimal++import pytest+import simplejson+from starlette.responses import StreamingResponse++from free_claude_code.api.handlers.classifier_response import classifier_response+from free_claude_code.core.anthropic.stream_contracts import parse_sse_text+from free_claude_code.core.stream_delivery import current_stream_delivery+from tests.api.test_response_streams import _serve+from tests.api.test_tool_call_buffer import _call, _end, _frames, _response, _start+from tests.api.test_web_server_tools import (+ ScriptedSelectionProvider,+ _automatic_search_request,+ _automatic_search_service,+ _provider_text_events,+)+++async def drained(body, wire):+ response = await _response(wire, body)+ try:+ return "".join([str(chunk) async for chunk in response.body_iterator])+ finally:+ await response.aclose()+++ "ending", ["activity", "empty", "stop", "error", "raise", "eof"]+)+async def test_messages_start_is_published_only_with_committed_activity(ending):+ start = _frames("messages", [_start("messages")])[0]+ harmless = ': keepalive\r\n\r\nevent: ping\r\ndata: {"type":"ping"}\r\n\r\n'+ activity = (+ 'event: future\ndata: {"type":"future","extension":0.1234567890123456789}\n\n'+ )++ async def source():+ yield start+ yield harmless+ if ending == "activity":+ yield activity+ if ending in {"activity", "empty"}:+ yield "".join(_frames("messages", _end("messages")))+ elif ending == "stop":+ yield 'event: message_stop\ndata: {"type":"message_stop"}\n\n'+ elif ending == "error":+ yield "".join(_frames("messages", _end("messages", failed=True)))+ elif ending == "raise":+ raise RuntimeError("stream interrupted")++ response = await _response("messages", source())+ try:+ iterator = aiter(response.body_iterator)+ assert await anext(iterator) == harmless+ remaining = "".join([str(chunk) async for chunk in iterator])+ if ending in {"activity", "empty", "stop"}:+ assert remaining.startswith(start)+ assert parse_sse_text(remaining)[-1].event == "message_stop"+ if ending == "activity":+ assert activity in remaining+ else:+ assert "message_start" not in remaining+ if ending != "eof":+ assert parse_sse_text(remaining)[-1].event == "error"+ finally:+ await response.aclose()+++async def test_messages_deferral_preserves_duplicate_starts_within_one_attempt():+ raw = "".join(+ _frames("messages", [_start("messages"), _start("messages"), *_end("messages")])+ )++ async def source():+ yield raw++ assert await drained(source(), "messages") == raw++[email protected]("wire", ["messages", "responses"])[email protected]("separator", ["\u2028", "\u2029", "\x85"])[email protected]("ending", ["\r", "\n", "\r\n"])+async def test_unicode_metadata_preserves_bytes_and_retry_eligibility(+ wire, separator, ending+):+ start = _start(wire)+ start[1]["message" if wire == "messages" else "response"]["extension"] = (+ "before" + separator + "after"+ )+ raw = _frames(wire, [start])[0].replace("\n", ending)+ released = []++ async def source():+ state = current_stream_delivery()+ assert state is not None+ yield raw+ released.append(state.content_released)+ yield "".join(_frames(wire, _end(wire)))++ result = await drained(source(), wire)+ assert released == [False]+ assert result.startswith(raw)+ payload = parse_sse_text(result)[0].data+ assert payload["message" if wire == "messages" else "response"]["extension"] == (+ "before" + separator + "after"+ )++[email protected]("separator", ["\u2028", "\u2029", "\x85"])+async def test_unicode_comment_does_not_release_content(separator):+ raw = ": before" + separator + "after\r\n\r\n"+ released = []++ async def source():+ state = current_stream_delivery()+ assert state is not None+ yield raw+ released.append(state.content_released)+ yield "".join(_frames("messages", [_start("messages"), *_end("messages")]))++ assert (await drained(source(), "messages")).startswith(raw)+ assert released == [False]++[email protected]("separator", ["\u2028", "\u2029", "\x85"])+async def test_unicode_meaningful_frame_still_releases_content(separator):+ raw = _frames("messages", [_start("messages")])[0]+ raw += 'event: future\ndata: {"type":"future","text":"a' + separator + 'b"}\n\n'+ released = []++ async def source():+ state = current_stream_delivery()+ assert state is not None+ yield raw+ released.append(state.content_released)+ yield "".join(_frames("messages", _end("messages")))++ assert (await drained(source(), "messages")).startswith(raw)+ assert released == [True]+++ "payload",+ [+ {"type": {"future": 7}},+ {"type": ["future"]},+ {+ "type": "response.created",+ "response": {"status": {"future": 7}, "output": []},+ },+ ],+)+async def test_opaque_frame_closes_eligibility_without_changing_bytes(payload):+ raw = _frames("responses", [_start("responses")])[0]+ raw += "event: future\ndata: " + json.dumps(payload) + "\n\n"+ seen = []++ async def source():+ seen.append(current_stream_delivery())+ yield raw++ assert await drained(source(), "responses") == raw+ assert seen[0].content_released++[email protected]("wire", ["messages", "responses"])+async def test_retry_drops_hidden_group_tail_and_reused_call_aliases(wire):+ async def source():+ delivery = current_stream_delivery()+ assert delivery is not None+ delivery.begin_attempt()+ yield "".join(_frames(wire, [_start(wire)]))+ first, second = _call(wire, 0), _call(wire, 1)+ yield "".join(_frames(wire, [first[0], second[0], *first[1:], second[1]]))+ yield 'event: content_block_delta\ndata: {"index":1,'+ assert not delivery.content_released+ delivery.begin_attempt()+ winner = _call(wire, 0, '{"path":"winning"}')+ yield "".join(_frames(wire, [_start(wire), *winner, *_end(wire)]))++ output = await drained(source(), wire)+ assert "call_1" not in output+ assert "winning" in output+ assert ("message_stop" if wire == "messages" else "response.completed") in output+ assert (+ output.count(+ '"type": "message_start"'+ if wire == "messages"+ else '"type": "response.created"'+ )+ == 1+ )++[email protected]("separator", ["", "\u2028", "\u2029", "\x85"])+async def test_retry_sequence_offset_preserves_decimal_extensions_and_call_ids(+ separator,+):+ async def source():+ state = current_stream_delivery()+ assert state is not None+ state.begin_attempt()+ yield 'event: response.created\r\ndata: {"type":"response.created","sequence_number":40,"response":{"id":"resp_old","created_at":7,"status":"in_progress","output":[]}}\r\n\r\n'+ state.begin_attempt()+ yield 'event: response.created\r\ndata: {"type":"response.created","sequence_number":0,"response":{"id":"resp_new","created_at":9,"status":"in_progress","output":[]}}\r\n\r\n'+ yield (+ 'id: native-event\r\nevent: response.completed\r\ndata: {"type":"response.completed","sequence_number":3,"response_id":"resp_new","response":{"id":"resp_new","created_at":9,"status":"completed","output":[]},"native":1.234567890123456789,"call_id":"resp_new","extension":"a'+ + separator+ + 'b"}\r\n\r\n'+ )++ output = await drained(source(), "responses")+ payload = simplejson.loads(output.split("data: ")[-1], use_decimal=True)+ assert payload["sequence_number"] == 41+ assert payload["response_id"] == payload["response"]["id"] == "resp_old"+ assert payload["response"]["created_at"] == 7+ assert payload["call_id"] == "resp_new"+ assert payload["native"] == Decimal("1.234567890123456789")+ assert payload["extension"] == "a" + separator + "b"+ assert "id: native-event\r\n" in output+ assert output.endswith("\r\n\r\n")+++async def test_classifier_resets_projection_when_hidden_attempt_is_replaced():+ async def source():+ state = current_stream_delivery()+ assert state is not None+ state.begin_attempt()+ yield "".join(_frames("messages", [_start("messages")]))+ yield 'event: content_block_start\ndata: {"type":"content_block_start","index":0,"content_block":{"type":"thinking","thinking":"hidden"}}\n\n'+ yield "event: content_block_delta\ndata: {"+ state.begin_attempt()+ yield "".join(+ _frames(+ "messages",+ [_start("messages"), *_call("messages", 0), *_end("messages")],+ )+ )++ output = await drained(classifier_response(source()), "messages")+ assert "hidden" not in output+ assert "call_0" in output and "message_stop" in output+ assert '"index": 0' in output+++async def test_prefetch_read_and_close_can_migrate_tasks_without_context_leak():+ seen = []+ closed = []++ async def source():+ state = current_stream_delivery()+ seen.append(state)+ try:+ yield "".join(_frames("messages", [_start("messages")]))+ assert current_stream_delivery() is state+ yield "".join(_frames("messages", _end("messages")))+ finally:+ closed.append(current_stream_delivery())++ response = await asyncio.create_task(_response("messages", source()))+ assert current_stream_delivery() is None+ iterator = aiter(response.body_iterator)++ async def read():+ return await anext(iterator)++ async def finish():+ return [chunk async for chunk in iterator]++ await asyncio.create_task(read())+ await asyncio.create_task(finish())+ await asyncio.create_task(response.aclose())+ assert closed == seen and current_stream_delivery() is None+++async def test_private_web_search_masks_public_observer_during_read_and_close():+ seen = []+ closed = []++ class ObservedSelection(ScriptedSelectionProvider):+ async def stream_messages(self, *args, **kwargs):+ seen.append(current_stream_delivery())+ try:+ async for frame in super().stream_messages(*args, **kwargs):+ yield frame+ finally:+ closed.append(current_stream_delivery())++ provider = ObservedSelection(_provider_text_events("private decision"))+ response = await _automatic_search_service(provider).create(+ _automatic_search_request()+ )+ assert isinstance(response, StreamingResponse)+ messages = await _serve(response)+ output = b"".join(message.get("body", b"") for message in messages).decode()+ assert "private decision" in output+ assert seen == closed == [None]+ assert len(provider.requests) == 1 and provider.close_count == 1+ assert current_stream_delivery() is None+++async def test_concurrent_responses_do_not_share_delivery_or_call_aliases():+ states = {}+ both = asyncio.Event()+ other_done = asyncio.Event()++ async def source(label):+ state = current_stream_delivery()+ assert state is not None+ states[label] = state+ state.begin_attempt()+ yield "".join(_frames("messages", [_start("messages")]))+ call = _call("messages", 0, '{"path":"' + label + '"}')+ yield "".join(_frames("messages", call[:2]))+ if len(states) == 2:+ both.set()+ await both.wait()+ if label == "alpha":+ await other_done.wait()+ assert not state.content_released+ state.begin_attempt()+ yield "".join(+ _frames("messages", [_start("messages"), *call, *_end("messages")])+ )+ else:+ yield "".join(_frames("messages", [call[2], *_end("messages")]))+ other_done.set()++ alpha, beta = await asyncio.gather(+ drained(source("alpha"), "messages"), drained(source("beta"), "messages")+ )+ assert states["alpha"] is not states["beta"]+ assert "alpha" in alpha and "beta" not in alpha+ assert "beta" in beta and "alpha" not in beta+ assert current_stream_delivery() is Nonediff --git a/tests/api/test_tool_call_buffer.py b/tests/api/test_tool_call_buffer.pyindex a0e198a8..85914edd 100644--- a/tests/api/test_tool_call_buffer.py+++ b/tests/api/test_tool_call_buffer.py@@ -192,7 +192,7 @@ async def test_call_is_hidden_until_completion_then_sent_before_response_end(task = asyncio.create_task(_serve(response, send=send))try:await asyncio.wait_for(waiting_for_completion.wait(), 1)- assert frames[0] in "".join(sent)+ assert "".join(sent) == (frames[0] if wire == "responses" else "")assert "call_0" not in "".join(sent)complete.set()await asyncio.wait_for(waiting_for_tail.wait(), 1)@@ -284,7 +284,7 @@ async def test_overlapping_group_keeps_order_and_is_discarded_on_failure(wire, ftask = asyncio.create_task(_serve(await _response(wire, body()), send=send))try:await asyncio.wait_for(waiting.wait(), 1)- assert "".join(sent) == frames[0]+ assert "".join(sent) == (frames[0] if wire == "responses" else "")finally:finish.set()await asyncio.wait_for(task, 1)@@ -334,7 +334,7 @@ async def test_unfinished_call_is_discarded_at_eof(wire):response = await _response(wire, body())result = "".join([str(chunk) async for chunk in response.body_iterator])await response.aclose()- assert result == frames[0]+ assert result == (frames[0] if wire == "responses" else "")@pytest.mark.asyncio@@ -530,7 +530,7 @@ async def test_cancellation_discards_pending_group_and_closes_body_once(wire):task.cancel()with pytest.raises(asyncio.CancelledError):await asyncio.wait_for(task, 1)- assert sent == [frames[0]]+ assert sent == ([frames[0]] if wire == "responses" else [])assert closed == released == 1diff --git a/tests/providers/test_anthropic_provider.py b/tests/providers/test_anthropic_provider.pyindex 980ea961..c3d17d57 100644--- a/tests/providers/test_anthropic_provider.py+++ b/tests/providers/test_anthropic_provider.py@@ -10,11 +10,11 @@ from free_claude_code.providers.anthropic import AnthropicProviderfrom tests.providers.support import immediate_admission, make_provider_config-def provider(handler, **kwargs):+def provider(handler, *, max_attempts=2, **kwargs):return AnthropicProvider(make_provider_config("upstream-secret", "https://api.anthropic.com/v1"),workspace_id="wrkspc_test",- admission=immediate_admission(max_attempts=2),+ admission=immediate_admission(max_attempts=max_attempts),transport=httpx.MockTransport(handler),**kwargs,)diff --git a/tests/providers/test_converter.py b/tests/providers/test_converter.pyindex 4d8c2e7f..a41c7f0c 100644--- a/tests/providers/test_converter.py+++ b/tests/providers/test_converter.py@@ -285,16 +285,36 @@ def test_openai_build_rejects_non_text_inline_system_blocks() -> None:build_base_request_body(request)-def test_openai_build_rejects_empty_inline_system_content() -> None:+ "content",+ [[], "", [{"type": "text", "text": ""}]],+ ids=["empty_list", "empty_string", "empty_text_block"],+)[email protected]("position", [0, 1, 2, 3])+def test_openai_build_omits_empty_inline_system_content(content, position) -> None:+ history = [+ {"role": "user", "content": "First question"},+ {"role": "assistant", "content": "First answer"},+ {"role": "user", "content": "Second question"},+ ]request = MessagesRequest.model_validate({"model": "model",- "messages": [{"role": "system", "content": []}],+ "system": "Conversation-wide instructions",+ "messages": [+ *history[:position],+ {"role": "system", "content": content},+ *history[position:],+ ],})- with pytest.raises(OpenAIConversionError, match="contain text"):- build_base_request_body(request)+ body = build_base_request_body(request)++ assert body["messages"] == [+ {"role": "system", "content": "Conversation-wide instructions"},+ *history,+ ]# --- Tool Conversion Tests ---diff --git a/tests/providers/test_history_transports.py b/tests/providers/test_history_transports.pyindex 10e32b31..22b4b919 100644--- a/tests/providers/test_history_transports.py+++ b/tests/providers/test_history_transports.py@@ -135,7 +135,9 @@ def _events_for(protocol):@asynccontextmanager-async def _harness(protocol, responder=None, *, key="a", chat_provider_factory=None):+async def _harness(+ protocol, responder=None, *, key="a", chat_provider_factory=None, max_attempts=5+):bodies: list[dict[str, Any]] = []def reply(request):@@ -157,14 +159,16 @@ async def _harness(protocol, responder=None, *, key="a", chat_provider_factory=Nif protocol == "messages":client = httpx.AsyncClient(transport=httpx.MockTransport(reply))- provider = messages_transport(client, immediate_admission(max_attempts=5))+ provider = messages_transport(+ client, immediate_admission(max_attempts=max_attempts)+ )endpoint = Endpoint()endpoint.token = keyextras = {"endpoint_context": endpoint}else:client = _client(reply, api_key=key)if protocol == "responses":- provider = responses_transport(client)+ provider = responses_transport(client, max_attempts=max_attempts)else:with patch("free_claude_code.providers.openai_chat.client.AsyncOpenAI",@@ -177,7 +181,7 @@ async def _harness(protocol, responder=None, *, key="a", chat_provider_factory=Nmake_provider_config(api_key=key, base_url="https://provider.invalid/v1"),- admission=immediate_admission(max_attempts=5),+ admission=immediate_admission(max_attempts=max_attempts),))extras = {}diff --git a/tests/providers/test_request_recovery_transitions.py b/tests/providers/test_request_recovery_transitions.pyindex f6f5053c..047c2404 100644--- a/tests/providers/test_request_recovery_transitions.py+++ b/tests/providers/test_request_recovery_transitions.py@@ -11,11 +11,17 @@ import httpximport httpx2import pytestfrom openai import AsyncOpenAI+from starlette.responses import StreamingResponse+from free_claude_code.api.response_streams import (+ anthropic_sse_streaming_response,+ openai_responses_sse_streaming_response,+)from free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.admission import (ProviderAdmissionController,@@ -29,6 +35,7 @@ from free_claude_code.providers.openai_chat import (OpenAIChatRequestPolicy,)from free_claude_code.providers.openai_responses import OpenAIResponsesTransport+from tests.api.test_response_streams import _json_error, _servefrom tests.providers.support import make_provider_configfrom tests.providers.test_anthropic_messages_transport import _eventsfrom tests.providers.test_anthropic_messages_transport import (@@ -221,6 +228,103 @@ def _partial(protocol, text=""):return [chunk][email protected]("protocol", ["chat", "messages"])+ "wire,failure_kind",+ [+ ("messages", "authentication"),+ ("responses", "authentication"),+ ("messages", "history"),+ ("messages", "reasoning"),+ ],+)[email protected]("stopped,public", [(True, True), (False, True), (True, False)])+async def test_hidden_normal_stop_prevents_request_corrections(+ protocol, wire, failure_kind, stopped, public+):+ error = (+ {+ "type": "authentication_error",+ "code": "invalid_api_key",+ "message": "expired",+ }+ if failure_kind == "authentication"+ else _history_error(protocol)+ if failure_kind == "history"+ else _reasoning_error()+ )+ events = _partial(protocol)+ if stopped:+ if protocol == "messages":+ events.append(+ {+ "type": "message_delta",+ "delta": {"stop_reason": "end_turn"},+ "usage": {"output_tokens": 0},+ }+ )+ else:+ terminal = deepcopy(events[0])+ terminal["choices"][0].update(delta={}, finish_reason="stop")+ events.append(terminal)+ events.append({"type": "error", "error": error})++ async with _transport(+ protocol,+ lambda ordinal: (200, events if ordinal == 1 else _events_for(protocol)),+ ) as (provider, endpoint, bodies, wires, admission):+ if wire == "messages":+ source = _stream(provider, endpoint, _request(protocol))+ else:+ source = provider.stream_responses(+ OpenAIResponsesRequest(model="upstream", input="continue"),+ endpoint_context=endpoint,+ reasoning=ReasoningPolicy.prefer_off(),+ response_model="public",+ )+ if public:+ options = {"pre_start_error_response": _json_error, "request_id": "stopped"}+ response = await (+ anthropic_sse_streaming_response(source, **options)+ if wire == "messages"+ else openai_responses_sse_streaming_response(+ source, headers={}, **options+ )+ )+ if isinstance(response, StreamingResponse):+ await _serve(response)+ if stopped:+ assert response.status_code >= 400+ assert error["message"] in bytes(response.body).decode()+ else:+ assert isinstance(response, StreamingResponse)+ else:+ output = "".join([event async for event in source])+ assert parse_sse_text(output)[-1].event == (+ "message_stop" if wire == "messages" else "response.completed"+ )+ calls = 1 if public and stopped else 2+ assert len(bodies) == calls+ assert all(item.close_calls == 1 for item in wires)+ assert admission._episode is None+ assert endpoint.calls == (+ [False, True]+ if calls == 2 and failure_kind == "authentication"+ else [False] * calls+ )+ if calls == 2:+ first, second = bodies+ if failure_kind == "authentication":+ assert first == second+ elif failure_kind == "history":+ assert "opaque-original" in json.dumps(first)+ assert "opaque-original" not in json.dumps(second)+ else:+ field = "thinking" if protocol == "messages" else "reasoning_effort"+ assert field in first and field not in second++@pytest.mark.asyncio@pytest.mark.parametrize("protocol", ["chat", "responses", "messages"])@pytest.mark.parametrize("exhausted", [False, True])diff --git a/tests/providers/test_sdk_stream_lifecycle.py b/tests/providers/test_sdk_stream_lifecycle.pyindex 89d871fb..21953f5f 100644--- a/tests/providers/test_sdk_stream_lifecycle.py+++ b/tests/providers/test_sdk_stream_lifecycle.py@@ -7,7 +7,12 @@ from unittest.mock import patchimport httpx2import pytestfrom openai import AsyncOpenAI+from starlette.responses import StreamingResponse+from free_claude_code.api.response_streams import (+ anthropic_sse_streaming_response,+ openai_responses_sse_streaming_response,+)from free_claude_code.config.nim import NimSettingsfrom free_claude_code.core.async_iterators import AsyncCloseablefrom free_claude_code.core.openai_responses import OpenAIResponsesRequest@@ -21,10 +26,12 @@ from free_claude_code.providers.mistral.reasoning import normalize_mistral_streafrom free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.nvidia_nim.native_tool_stream import (NimNativeToolProtocolError,+ normalize_nim_native_tool_stream,)from free_claude_code.providers.openai_responses import OpenAIResponsesTransportfrom free_claude_code.providers.openai_stream import OpenAIStreamAdapterfrom free_claude_code.providers.request_recovery import RequestRecovery+from tests.api.test_response_streams import _json_error, _servefrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import make_provider_config, profiled_providerfrom tests.providers.test_openai_responses_transport import (@@ -346,6 +353,80 @@ async def test_nim_parser_failure_closes_response_before_retry(wire):await _assert_admission_available(admission)[email protected]("wire", ["messages", "responses"])+async def test_stopped_first_nim_chunk_returns_public_error_and_releases_admission(+ wire,+):+ body = ResponseBody(_chat_chunk("]<]minimax[>[<tool_call>", finish_reason="length"))+ requests = 0++ def handler(request):+ nonlocal requests+ requests += 1+ if requests == 1:+ return _response(body)+ assert body.close_count == 1+ return httpx2.Response(+ 200,+ headers={"content-type": "text/event-stream"},+ content=_chat_chunk("unexpected retry", finish_reason="stop")+ + b"data: [DONE]\n\n",+ )++ async with _harness("nim", handler) as (provider, client, admission):+ options = {"pre_start_error_response": _json_error, "request_id": "raw-stop"}+ source = _public_stream(provider, wire)+ async with asyncio.timeout(2):+ response = await (+ anthropic_sse_streaming_response(source, **options)+ if wire == "messages"+ else openai_responses_sse_streaming_response(+ source, headers={}, **options+ )+ )+ if isinstance(response, StreamingResponse):+ await _serve(response)+ assert response.status_code >= 400+ assert requests == 1+ assert body.close_count == 1 and not client.is_closed()+ await _assert_admission_available(admission)++[email protected]("reject_normalization", [False, True])+async def test_sdk_observer_runs_before_normalization_without_owning_cleanup(+ reject_normalization,+):+ text = "]<]minimax[>[<tool_call>" if reject_normalization else "hello"+ body = ResponseBody(_chat_chunk(text, finish_reason="stop"))+ seen = []+ async with _harness("nim", lambda _: _response(body)) as (_, client, admission):+ sdk_stream = await client.chat.completions.create(+ model="model", messages=[], stream=True+ )+ source = OpenAIStreamAdapter(sdk_stream, on_event=seen.append)+ normalized = (+ normalize_nim_native_tool_stream(source, {})+ if reject_normalization+ else source+ )+ try:+ if reject_normalization:+ with pytest.raises(NimNativeToolProtocolError):+ await anext(normalized)+ else:+ event = await anext(normalized)+ assert seen[0] is event+ assert len(seen) == 1+ assert seen[0].choices[0].finish_reason == "stop"+ finally:+ assert isinstance(normalized, AsyncCloseable)+ await normalized.aclose()+ assert body.close_count == 1 and not client.is_closed()+ await _assert_admission_available(admission)++@pytest.mark.asyncio@pytest.mark.parametrize("operation",diff --git a/tests/providers/test_stream_recovery.py b/tests/providers/test_stream_recovery.pyindex 959d6ab2..34775a48 100644--- a/tests/providers/test_stream_recovery.py+++ b/tests/providers/test_stream_recovery.py@@ -1,5 +1,6 @@"""Provider stream commit-boundary and recovery policy."""+from free_claude_code.core.stream_delivery import StreamDeliveryStatefrom free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -7,6 +8,20 @@ from free_claude_code.providers.stream_recovery import ()+def test_exhausted_hidden_group_cannot_fall_through_to_salvage():+ controller = RecoveryController(StreamDeliveryState())+ controller.push("hidden")+ controller.flush()+ decision = controller.advance_failure(+ retryable=True,+ stream_opened=True,+ generated_output=True,+ complete_tool_salvageable=True,+ attempts_remaining=0,+ )+ assert decision.action == RecoveryFailureAction.FINAL_ERROR++def test_early_retry_discards_uncommitted_holdback() -> None:controller = RecoveryController()