Skip to content

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

Python

patch: 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.py
index 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 AsyncIterator
from free_claude_code.core.anthropic.stream_contracts import SSEEvent
from free_claude_code.core.anthropic.streaming import format_sse_event
from free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoder
+from free_claude_code.core.stream_delivery import current_stream_delivery
from 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 = 0
def 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 projected
finally:
+ 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.py
index 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 StreamDeliveryState
from free_claude_code.core.trace import close_stream_input, trace_event
+from .stream_delivery import DeliveryObservedStream, PublicStreamEnvelope
from .tool_call_buffer import ToolCallBufferedStream
TERMINAL_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_chunk
self._initial_chunk = first_chunk
@@ -307,6 +315,8 @@ class _PrefetchedStream(AsyncIterator[str]):
self._terminal_failure_observer = terminal_failure_observer
self._done = False
self._closed = False
+ self._envelope = envelope
+ self._revision = envelope.state.attempt_revision
def __aiter__(self) -> _PrefetchedStream:
return self
@@ -320,6 +330,7 @@ class _PrefetchedStream(AsyncIterator[str]):
return first_chunk
try:
chunk = await anext(self._body)
+ self._synchronize()
self._latest_chunk = chunk
return chunk
except StopAsyncIteration:
@@ -340,13 +351,24 @@ class _PrefetchedStream(AsyncIterator[str]):
raise close_error
def _terminal_chunk(self, exc: BaseException) -> str:
+ self._synchronize()
terminal_frame = self._terminal_frame
if terminal_frame is None:
raise exc
self._done = True
if 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.py
new file mode 100644
index 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 False
diff --git a/src/free_claude_code/api/tool_call_buffer.py b/src/free_claude_code/api/tool_call_buffer.py
index 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 re
from collections.abc import AsyncIterator, Mapping
from typing import Literal, cast
-import simplejson
-
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.anthropic.streaming.decoder import AnthropicSSEDecoder
from free_claude_code.core.async_iterators import try_close_async_iterator
from free_claude_code.core.json_types import JsonValue
from 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 = body
self._wire_api = wire_api
@@ -65,6 +68,8 @@ class ToolCallBufferedStream(AsyncIterator[str]):
self._indices: dict[int, CallKey] = {}
self._done = False
self._closed = False
+ self._envelope = envelope
+ self._revision = envelope.state.attempt_revision if envelope else 0
def __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 = True
frames = self._decoder.finish_frames()
except BaseException:
+ self._synchronize()
self._discard_group()
+ if self._envelope is not None:
+ self._envelope.discard_pending_starts()
raise
else:
+ 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:
return
self._closed = True
self._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 frame
response = value.get("response")
if not isinstance(response, dict):
@@ -233,21 +259,7 @@ class ToolCallBufferedStream(AsyncIterator[str]):
if len(retained) == len(output):
return frame
response["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: object
diff --git a/src/free_claude_code/application/web_tools/service.py b/src/free_claude_code/application/web_tools/service.py
index 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, FailureKind
from free_claude_code.core.json_types import JsonObject
+from free_claude_code.core.stream_delivery import bind_stream_delivery
from free_claude_code.core.trace import close_stream_input, trace_event
from 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.py
index 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.py
new file mode 100644
index 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.py
index 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 TypeVar
from loguru import logger
+from free_claude_code.core.stream_delivery import (
+ StreamDeliveryState,
+ current_stream_delivery,
+)
from free_claude_code.core.trace import trace_event
from free_claude_code.providers.admission_policy import ProviderAdmissionLimits
from free_claude_code.providers.failure_policy import (
@@ -90,6 +94,11 @@ class ProviderExecution:
self._active_claim: _AttemptClaim | None = None
self._last_failure: Exception | None = None
self._state = ProviderExecutionState.ACTIVE
+ self._delivery = current_stream_delivery()
+
+ @property
+ def delivery(self) -> StreamDeliveryState | None:
+ return self._delivery
@property
def 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 attempt
async 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.py
index 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(
return
committed = False
while execution.can_attempt:
+ normal_stop_seen = False
scope = None
try:
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,
+ ):
+ continue
if error is not raw_error:
raise error from raw_error
raise
diff --git a/src/free_claude_code/providers/anthropic_messages/transport.py b/src/free_claude_code/providers/anthropic_messages/transport.py
index 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 = False
scope: ProviderAttemptScope | None = None
stream_opened = False
sent_body = body
@@ -328,6 +334,7 @@ class AnthropicMessagesTransport:
)
stream_opened = True
async for event_type, payload in messages_events(response):
+ normal_stop_seen |= is_messages_stop(event_type, payload)
check_messages_failure(event_type, payload)
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()
continue
if 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.py
index 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.py
index 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_reasoning
self._finish_reason: Any = None
+ self._raw_stop_seen = False
self._usage_info: Any = None
self._native_reasoning_seen = False
self._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_reason
if 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.execution
attempt_failure = None
if 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_name
if 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.py
index 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 = False
presenter = presenter_factory()
start_events = tuple(presenter.start())
presenter_started = False
@@ -372,6 +373,10 @@ class OpenAIResponsesTransport:
stream_opened = True
async for upstream_event in stream:
+ normal_stop_seen |= upstream_event.type in {
+ "response.completed",
+ "response.incomplete",
+ }
if not scope.attempt.accepted:
await scope.attempt.accept()
if not presenter_started:
@@ -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.py
index 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, Callable
from openai import AsyncStream
@@ -8,14 +8,23 @@ from openai import AsyncStream
class OpenAIStreamAdapter[EventT](AsyncIterator[EventT]):
"""Own an SDK response stream without closing its reusable client."""
- def __init__(self, stream: AsyncStream[EventT]) -> None:
+ def __init__(
+ self,
+ stream: AsyncStream[EventT],
+ *,
+ on_event: Callable[[EventT], None] | None = None,
+ ) -> None:
self._stream = stream
+ self._on_event = on_event
def __aiter__(self) -> AsyncIterator[EventT]:
return self
async 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 event
async 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.py
index 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 None
if await self.retry_authentication(error, auth_status, attempt):
return body
if 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.py
index 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 Callable
from dataclasses import dataclass
from enum import StrEnum
+from free_claude_code.core.stream_delivery import StreamDeliveryState
+
from .failure_policy import RetryableProviderProtocolError
EARLY_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
@property
def 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.committed
has_buffered = self._holdback.has_buffered
retry_available = attempts_remaining > 0
reserve_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 retryable
and retry_available
and stream_opened
and not committed
@@ -145,7 +162,8 @@ class RecoveryController:
)
if (
- retryable
+ not public_hidden
+ and retryable
and generated_output
and (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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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() -> None
assert response.status_code == 200
events = 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.py
index 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_text
from 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 == 200
events = 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.py
new file mode 100644
index 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 None
diff --git a/tests/api/test_tool_call_buffer.py b/tests/api/test_tool_call_buffer.py
index 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, f
task = 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 == 1
diff --git a/tests/providers/test_anthropic_provider.py b/tests/providers/test_anthropic_provider.py
index 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 AnthropicProvider
from 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.py
index 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.py
index 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=N
if 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 = key
extras = {"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=N
make_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.py
index f6f5053c..047c2404 100644
--- a/tests/providers/test_request_recovery_transitions.py
+++ b/tests/providers/test_request_recovery_transitions.py
@@ -11,11 +11,17 @@ import httpx
import httpx2
import pytest
from 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 ReasoningReplayMode
from free_claude_code.core.anthropic.models import MessagesRequest
from free_claude_code.core.anthropic.stream_contracts import parse_sse_text
from free_claude_code.core.failures import ExecutionFailure
+from free_claude_code.core.openai_responses import OpenAIResponsesRequest
from free_claude_code.core.reasoning import ReasoningPolicy
from 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, _serve
from tests.providers.support import make_provider_config
from tests.providers.test_anthropic_messages_transport import _events
from 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.py
index 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 patch
import httpx2
import pytest
from 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 NimSettings
from free_claude_code.core.async_iterators import AsyncCloseable
from free_claude_code.core.openai_responses import OpenAIResponsesRequest
@@ -21,10 +26,12 @@ from free_claude_code.providers.mistral.reasoning import normalize_mistral_strea
from free_claude_code.providers.nvidia_nim import NvidiaNimProvider
from free_claude_code.providers.nvidia_nim.native_tool_stream import (
NimNativeToolProtocolError,
+ normalize_nim_native_tool_stream,
)
from free_claude_code.providers.openai_responses import OpenAIResponsesTransport
from free_claude_code.providers.openai_stream import OpenAIStreamAdapter
from free_claude_code.providers.request_recovery import RequestRecovery
+from tests.api.test_response_streams import _json_error, _serve
from tests.providers.request_factory import make_messages_request
from tests.providers.support import make_provider_config, profiled_provider
from tests.providers.test_openai_responses_transport import (
@@ -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.py
index 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 StreamDeliveryState
from 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()