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
Canonicalize provider output events (#1541)
Ali Khokhar7fedb4234215
diff --git a/e2e/conftest.py b/e2e/conftest.pyindex 58cf5836..a32e8a66 100644--- a/e2e/conftest.py+++ b/e2e/conftest.py@@ -17,6 +17,7 @@ from free_claude_code.config import env_migrations, pathsfrom free_claude_code.config.env_migrations import recognized_env_keysfrom free_claude_code.config.loader import clear_settings_cache, get_settingsfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedgerfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.base import BaseProvider, ProviderConfigfrom free_claude_code.providers.runtime import ProviderRuntime@@ -73,9 +74,9 @@ class _ModelListingProvider(BaseProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:if False:- yield ""+ yield InferenceStreamLedger("unused", "unused").start_response()def _close_manager(manager: ProviderRuntimeManager) -> None:diff --git a/pyproject.toml b/pyproject.tomlindex 1c072f2a..ca921ecd 100644--- a/pyproject.toml+++ b/pyproject.toml@@ -4,7 +4,7 @@ build-backend = "hatchling.build"[project]name = "free-claude-code"-version = "5.14.1"+version = "5.14.2"description = "Local proxy connecting coding agents to OpenAI-compatible AI providers"readme = "README.md"requires-python = ">=3.14.0"diff --git a/src/free_claude_code/api/handlers/messages.py b/src/free_claude_code/api/handlers/messages.pyindex fcafd337..4547b52f 100644--- a/src/free_claude_code/api/handlers/messages.py+++ b/src/free_claude_code/api/handlers/messages.py@@ -44,20 +44,28 @@ from free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import (MessagesRequest,aggregate_anthropic_sse_to_message,+ aggregate_inference_events_to_message,anthropic_error_payload,anthropic_error_type_for_failure,anthropic_failure_payload,anthropic_status_for_error_type,get_token_count,+ iter_anthropic_sse,)from free_claude_code.core.diagnostics import safe_exception_messagefrom free_claude_code.core.failures import ExecutionFailure, find_execution_failure+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.reasoning import ReasoningControl, ReasoningPolicyfrom free_claude_code.core.trace import trace_event@dataclass(frozen=True)-class _MessagesStreamResult:+class _MessagesEventResult:+ body: AsyncIterator[InferenceEvent]+++@dataclass(frozen=True)+class _MessagesWireStreamResult:body: AsyncIterator[str]@@ -66,7 +74,9 @@ class _MessagesCompleteResult:response: object-_MessagesResult = _MessagesStreamResult | _MessagesCompleteResult+_MessagesResult = (+ _MessagesEventResult | _MessagesWireStreamResult | _MessagesCompleteResult+)MessageIntercept = Callable[[RoutedMessagesRequest], _MessagesResult | None]@@ -120,7 +130,7 @@ class MessagesHandler:routed.request.system,routed.request.tools,)- result = _MessagesStreamResult(+ result = _MessagesWireStreamResult(stream_automatic_web_search_response(self._provider_executor,routed,@@ -128,11 +138,12 @@ class MessagesHandler:request_id=request_id,fallback_input_tokens=input_tokens,verbose_client_errors=self._settings.log_api_error_tracebacks,+ log_raw_events=self._settings.log_raw_sse_events,))if result is None:logger.debug("No optimization matched, routing to provider")- result = _MessagesStreamResult(+ result = _MessagesEventResult(self._provider_executor.stream(routed,wire_api="messages",@@ -172,7 +183,13 @@ class MessagesHandler:# complete JSON Message; the internal pipeline is always SSE, so# serving that raw here breaks the client SDK's response parse.try:- message, error = await aggregate_anthropic_sse_to_message(result.body)+ if isinstance(result, _MessagesEventResult):+ message = await aggregate_inference_events_to_message(result.body)+ error = None+ else:+ message, error = await aggregate_anthropic_sse_to_message(+ result.body+ )except GeneratorExit:raiseexcept asyncio.CancelledError:@@ -216,8 +233,16 @@ class MessagesHandler:),)return JSONResponse(content=message)+ body = (+ iter_anthropic_sse(+ result.body,+ log_raw_events=self._settings.log_raw_sse_events,+ )+ if isinstance(result, _MessagesEventResult)+ else result.body+ )return await anthropic_sse_streaming_response(- result.body,+ body,pre_start_error_response=lambda exc: self._pre_start_error_response(exc, request_id=request_id),@@ -379,7 +404,7 @@ class MessagesHandler:self._settings.web_fetch_allowed_schemes),)- return _MessagesStreamResult(+ return _MessagesWireStreamResult(stream_web_server_tool_response(routed.request,input_tokens=input_tokens,diff --git a/src/free_claude_code/api/handlers/responses.py b/src/free_claude_code/api/handlers/responses.pyindex 84f0a988..ac0eda59 100644--- a/src/free_claude_code/api/handlers/responses.py+++ b/src/free_claude_code/api/handlers/responses.py@@ -25,6 +25,7 @@ from free_claude_code.core.failures import ExecutionFailure, find_execution_failfrom free_claude_code.core.openai_responses import (OpenAIResponsesAdapter,OpenAIResponsesRequest,+ iter_responses_sse_from_events,openai_error_type_for_failure,openai_failure_payload,)@@ -80,7 +81,7 @@ class ResponsesHandler:request_id=request_id,)return await openai_responses_sse_streaming_response(- self._responses_adapter.iter_sse_from_anthropic(+ iter_responses_sse_from_events(streamed,request_data,on_post_start_terminal_failure=lambda exc: (diff --git a/src/free_claude_code/api/web_tools/automatic_search.py b/src/free_claude_code/api/web_tools/automatic_search.pyindex 4478afdd..6652ce16 100644--- a/src/free_claude_code/api/web_tools/automatic_search.py+++ b/src/free_claude_code/api/web_tools/automatic_search.py@@ -8,10 +8,11 @@ from urllib.parse import urlsplitfrom free_claude_code.application.execution import ProviderExecutorfrom free_claude_code.application.routing import RoutedMessagesRequestfrom free_claude_code.core.anthropic import (- aggregate_anthropic_sse_to_message,- anthropic_status_for_error_type,+ aggregate_inference_events_to_message,+ iter_anthropic_sse,)from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.trace import close_stream_input, trace_eventfrom .request import (@@ -30,6 +31,7 @@ async def stream_automatic_web_search_response(request_id: str,fallback_input_tokens: int,verbose_client_errors: bool,+ log_raw_events: bool,) -> AsyncIterator[str]:"""Buffer one model decision, then replay it or execute one local search."""translated = replace(routed, request=plan.request)@@ -47,9 +49,9 @@ async def stream_automatic_web_search_response(raw_log_payload=plan.request.model_dump(),request_id=request_id,)- chunks: list[str] = []+ events: list[InferenceEvent] = []try:- chunks.extend([chunk async for chunk in provider_stream])+ events.extend([event async for event in provider_stream])finally:await close_stream_input(provider_stream,@@ -58,11 +60,7 @@ async def stream_automatic_web_search_response(preserved_error=sys.exception(),)- message, stream_error = await aggregate_anthropic_sse_to_message(- _iterate_chunks(chunks)- )- if stream_error is not None:- raise _execution_failure_from_stream_error(stream_error)+ message = await aggregate_inference_events_to_message(_iterate_events(events))tool_calls = _tool_calls(message)if not tool_calls:@@ -73,7 +71,10 @@ async def stream_automatic_web_search_response(request_id=request_id,model=routed.resolved.original_model,)- for chunk in chunks:+ async for chunk in iter_anthropic_sse(+ _iterate_events(events),+ log_raw_events=log_raw_events,+ ):yield chunkreturnif len(tool_calls) != 1:@@ -131,9 +132,11 @@ async def stream_automatic_web_search_response()-async def _iterate_chunks(chunks: list[str]) -> AsyncIterator[str]:- for chunk in chunks:- yield chunk+async def _iterate_events(+ events: list[InferenceEvent],+) -> AsyncIterator[InferenceEvent]:+ for event in events:+ yield eventdef _tool_calls(message: Mapping[str, object]) -> list[dict[str, object]]:@@ -194,37 +197,6 @@ def _is_hostname_or_subdomain(hostname: str, domain: str) -> bool:return hostname == domain or hostname.endswith(f".{domain}")-def _execution_failure_from_stream_error(- error: Mapping[str, object],-) -> ExecutionFailure:- raw_type = error.get("type")- error_type = raw_type if isinstance(raw_type, str) else "api_error"- raw_message = error.get("message")- message = (- raw_message- if isinstance(raw_message, str) and raw_message.strip()- else "Provider request failed unexpectedly."- )- status = anthropic_status_for_error_type(error_type)- kind = {- 400: FailureKind.INVALID_REQUEST,- 401: FailureKind.AUTHENTICATION,- 402: FailureKind.PERMISSION,- 403: FailureKind.PERMISSION,- 404: FailureKind.INVALID_REQUEST,- 413: FailureKind.INVALID_REQUEST,- 429: FailureKind.RATE_LIMIT,- 504: FailureKind.TIMEOUT,- 529: FailureKind.OVERLOADED,- }.get(status, FailureKind.UPSTREAM)- return ExecutionFailure(- kind=kind,- status_code=status,- message=message,- retryable=False,- )--def _protocol_failure(message: str, *, request_id: str) -> ExecutionFailure:return ExecutionFailure(kind=FailureKind.UPSTREAM,diff --git a/src/free_claude_code/application/execution.py b/src/free_claude_code/application/execution.pyindex ca4b1fca..42bf552b 100644--- a/src/free_claude_code/application/execution.py+++ b/src/free_claude_code/application/execution.py@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic import (get_token_count,)from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import InferenceEvent, inference_event_sizefrom free_claude_code.core.trace import (close_stream_input,trace_event,@@ -148,7 +149,7 @@ class ProviderExecutor:raw_log_label: str,raw_log_payload: object,request_id: str,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:"""Preflight synchronously, then return the traced provider stream."""primary = routed.resolved.primaryprimary_provider = self._provider_resolver(primary.provider_id)@@ -208,7 +209,7 @@ class ProviderExecutor:routed.request.tools,)- async def provider_body() -> AsyncIterator[str]:+ async def provider_body() -> AsyncIterator[InferenceEvent]:loop = asyncio.get_running_loop()progress_deadline = loop.time() + self._progress_timeout_secondsfor index, target in enumerate(candidates):@@ -231,7 +232,7 @@ class ProviderExecutor:reasoning=routed.reasoning,)- provider_stream: AsyncIterator[str] | None = None+ provider_stream: AsyncIterator[InferenceEvent] | None = Nonecandidate_committed = Falseadvance_failure: ExecutionFailure | None = Nonetry:@@ -261,9 +262,6 @@ class ProviderExecutor:request_id=request_id,provider_id=target.provider_id,) from exc- if not chunk:- await asyncio.sleep(0)- continueif not candidate_committed:candidate_committed = Trueif index > 0:@@ -330,4 +328,5 @@ class ProviderExecutor:),chunk_event=None,extra=stream_trace,+ item_size=inference_event_size,)diff --git a/src/free_claude_code/application/ports.py b/src/free_claude_code/application/ports.pyindex 5d810b32..3e8b8196 100644--- a/src/free_claude_code/application/ports.py+++ b/src/free_claude_code/application/ports.py@@ -6,6 +6,7 @@ from typing import Protocolfrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequest+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.reasoning import ReasoningPolicyfrom .model_metadata import ProviderModelInfo@@ -29,7 +30,7 @@ class ProviderPort(Protocol):request_id: str,response_model: str,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]: ...+ ) -> AsyncIterator[InferenceEvent]: ...ProviderResolver = Callable[[str], ProviderPort]diff --git a/src/free_claude_code/core/anthropic/__init__.py b/src/free_claude_code/core/anthropic/__init__.pyindex e812230c..b0a88fe1 100644--- a/src/free_claude_code/core/anthropic/__init__.py+++ b/src/free_claude_code/core/anthropic/__init__.py@@ -36,13 +36,15 @@ from .models import (Usage,)from .openai_tool_names import OpenAIToolNameCodec+from .presenter import (+ AnthropicEventPresenter,+ aggregate_inference_events_to_message,+ iter_anthropic_sse,+)from .request_serialization import dump_messages_request, serialize_tool_result_contentfrom .request_snapshot import anthropic_request_snapshotfrom .sse_aggregation import aggregate_anthropic_sse_to_messagefrom .streaming import (- AnthropicStreamLedger,- StreamBlockLedger,- ToolBlockState,format_sse_event,map_stop_reason,)@@ -52,7 +54,7 @@ from .tools import FunctionTagToolParser, HeuristicToolParserfrom .utils import set_if_not_none__all__ = [- "AnthropicStreamLedger",+ "AnthropicEventPresenter","AnthropicToOpenAIConverter","ContentBlockDocument","ContentBlockImage",@@ -74,16 +76,15 @@ __all__ = ["OpenAIConversionError","OpenAIToolNameCodec","ReasoningReplayMode",- "StreamBlockLedger","SystemContent","ThinkTagParser","ThinkingConfig","TokenCountRequest","TokenCountResponse","Tool",- "ToolBlockState","Usage","aggregate_anthropic_sse_to_message",+ "aggregate_inference_events_to_message","anthropic_error_payload","anthropic_error_type_for_failure","anthropic_failure_payload",@@ -97,6 +98,7 @@ __all__ = ["get_block_type","get_token_count","is_synthetic_openai_tool_turn_boundary",+ "iter_anthropic_sse","map_stop_reason","serialize_tool_result_content","set_if_not_none",diff --git a/src/free_claude_code/core/anthropic/presenter.py b/src/free_claude_code/core/anthropic/presenter.pynew file mode 100644index 00000000..f66ea5c3--- /dev/null+++ b/src/free_claude_code/core/anthropic/presenter.py@@ -0,0 +1,529 @@+"""Present canonical inference events through the Anthropic Messages protocol."""++import asyncio+import json+import sys+import uuid+from collections.abc import AsyncIterator, Mapping+from dataclasses import dataclass++from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceUsage,+ ReasoningBlockCompleted,+ ReasoningBlockStarted,+ ReasoningDelta,+ ReplayArtifact,+ ReplayArtifactKind,+ ResponseCompleted,+ ResponseStarted,+ TextBlockCompleted,+ TextBlockStarted,+ TextDelta,+ TokenMeasurement,+ ToolCallArgumentsDelta,+ ToolCallCompleted,+ ToolCallStarted,+ UsageUpdated,+ replay_payload_text,+)+from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.core.trace import close_stream_input++from .streaming.emitter import AnthropicSseEmitter+++@dataclass(slots=True)+class _WireBlock:+ index: int | None+ block_type: str+ open: bool+ emitted_artifacts: int = 0+++class AnthropicEventPresenter:+ """Serialize one canonical stream while owning all Anthropic wire state."""++ def __init__(self, *, log_raw_events: bool = False) -> None:+ self._emitter = AnthropicSseEmitter(log_raw_events=log_raw_events)+ self._message_id = f"msg_{uuid.uuid4()}"+ self._next_index = 0+ self._blocks: dict[str, _WireBlock] = {}+ self._started = False+ self._completed = False+ self._usage = InferenceUsage()++ def present(self, event: InferenceEvent) -> list[str]:+ if self._completed:+ raise RuntimeError("canonical event arrived after response completion")+ if isinstance(event, ResponseStarted):+ return self._response_started(event)+ if not self._started:+ raise RuntimeError("canonical response must start before output")+ if isinstance(event, TextBlockStarted):+ return self._text_started(event)+ if isinstance(event, TextDelta):+ return [self._text_delta(event)]+ if isinstance(event, TextBlockCompleted):+ return [self._block_completed(event.block_id)]+ if isinstance(event, ReasoningBlockStarted):+ return self._reasoning_started(event)+ if isinstance(event, ReasoningDelta):+ return self._reasoning_delta(event)+ if isinstance(event, ReasoningBlockCompleted):+ return self._reasoning_completed(event)+ if isinstance(event, ToolCallStarted):+ return self._tool_started(event)+ if isinstance(event, ToolCallArgumentsDelta):+ return [self._tool_delta(event)]+ if isinstance(event, ToolCallCompleted):+ return [self._block_completed(event.block_id)]+ if isinstance(event, UsageUpdated):+ self._usage = event.usage+ return []+ return self._response_completed(event)++ def _response_started(self, event: ResponseStarted) -> list[str]:+ if self._started:+ raise RuntimeError("canonical response started more than once")+ self._started = True+ self._usage = event.initial_usage+ usage: JsonObject = {+ "input_tokens": _usage_value(event.initial_usage.input_tokens),+ "output_tokens": 1,+ }+ return [+ self._emitter.event(+ "message_start",+ {+ "type": "message_start",+ "message": {+ "id": self._message_id,+ "type": "message",+ "role": "assistant",+ "content": [],+ "model": event.model,+ "stop_reason": None,+ "stop_sequence": None,+ "usage": usage,+ },+ },+ )+ ]++ def _text_started(self, event: TextBlockStarted) -> list[str]:+ index = self._allocate_index()+ self._blocks[event.block_id] = _WireBlock(index, "text", True)+ return [+ self._emitter.event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": index,+ "content_block": {"type": "text", "text": ""},+ },+ )+ ]++ def _text_delta(self, event: TextDelta) -> str:+ block = self._require_open_block(event.block_id, "text")+ return self._emitter.event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": _required_index(block),+ "delta": {"type": "text_delta", "text": event.delta},+ },+ )++ def _reasoning_started(self, event: ReasoningBlockStarted) -> list[str]:+ block = _WireBlock(None, "reasoning", False)+ self._blocks[event.block_id] = block+ chunks: list[str] = []+ if not event.artifacts or any(+ artifact.kind is ReplayArtifactKind.THINKING_SIGNATURE+ for artifact in event.artifacts+ ):+ chunks.append(self._start_reasoning_wire_block(block))+ chunks.extend(self._emit_reasoning_artifacts(block, event.artifacts))+ return chunks++ def _reasoning_delta(self, event: ReasoningDelta) -> list[str]:+ block = self._require_block(event.block_id, "reasoning")+ chunks: list[str] = []+ if not block.open:+ chunks.append(self._start_reasoning_wire_block(block))+ if event.delta:+ chunks.append(+ self._emitter.event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": _required_index(block),+ "delta": {+ "type": "thinking_delta",+ "thinking": event.delta,+ },+ },+ )+ )+ return chunks++ def _reasoning_completed(self, event: ReasoningBlockCompleted) -> list[str]:+ block = self._require_block(event.block_id, "reasoning")+ chunks: list[str] = []+ if block.open:+ chunks.append(self._stop_wire_block(block))+ remaining = event.artifacts[block.emitted_artifacts :]+ chunks.extend(self._emit_reasoning_artifacts(block, remaining))+ block.open = False+ return chunks++ def _tool_started(self, event: ToolCallStarted) -> list[str]:+ index = self._allocate_index()+ self._blocks[event.block_id] = _WireBlock(index, "tool_call", True)+ content_block: JsonObject = {+ "type": "tool_use",+ "id": event.call_id,+ "name": event.name,+ "input": {},+ }+ extra_content = _tool_extra_content(event.artifacts)+ if extra_content:+ content_block["extra_content"] = extra_content+ return [+ self._emitter.event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": index,+ "content_block": content_block,+ },+ )+ ]++ def _tool_delta(self, event: ToolCallArgumentsDelta) -> str:+ block = self._require_open_block(event.block_id, "tool_call")+ return self._emitter.event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": _required_index(block),+ "delta": {+ "type": "input_json_delta",+ "partial_json": event.delta,+ },+ },+ )++ def _block_completed(self, block_id: str) -> str:+ block = self._require_open_block(block_id, None)+ return self._stop_wire_block(block)++ def _response_completed(self, event: ResponseCompleted) -> list[str]:+ if any(block.open for block in self._blocks.values()):+ raise RuntimeError("canonical response completed with open output blocks")+ self._usage = event.final_usage+ self._completed = True+ return [+ self._emitter.event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {+ "stop_reason": _anthropic_stop_reason(event.finish_reason),+ "stop_sequence": event.stop_sequence,+ },+ "usage": _anthropic_usage(event.final_usage),+ },+ ),+ self._emitter.event("message_stop", {"type": "message_stop"}),+ ]++ def _emit_reasoning_artifacts(+ self,+ block: _WireBlock,+ artifacts: tuple[ReplayArtifact, ...],+ ) -> list[str]:+ chunks: list[str] = []+ for artifact in artifacts:+ if artifact.kind is ReplayArtifactKind.THINKING_SIGNATURE:+ if not block.open:+ chunks.append(self._start_reasoning_wire_block(block))+ chunks.append(+ self._emitter.event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": _required_index(block),+ "delta": {+ "type": "signature_delta",+ "signature": replay_payload_text(artifact),+ },+ },+ )+ )+ elif artifact.kind in {+ ReplayArtifactKind.REDACTED_THINKING,+ ReplayArtifactKind.ENCRYPTED_REASONING,+ ReplayArtifactKind.REASONING_DETAILS,+ }:+ if block.open:+ chunks.append(self._stop_wire_block(block))+ index = self._allocate_index()+ chunks.extend(+ [+ self._emitter.event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": index,+ "content_block": {+ "type": "redacted_thinking",+ "data": replay_payload_text(artifact),+ },+ },+ ),+ self._emitter.event(+ "content_block_stop",+ {"type": "content_block_stop", "index": index},+ ),+ ]+ )+ block.emitted_artifacts += 1+ return chunks++ def _start_reasoning_wire_block(self, block: _WireBlock) -> str:+ block.index = self._allocate_index()+ block.open = True+ return self._emitter.event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": block.index,+ "content_block": {"type": "thinking", "thinking": ""},+ },+ )++ def _stop_wire_block(self, block: _WireBlock) -> str:+ index = _required_index(block)+ block.open = False+ return self._emitter.event(+ "content_block_stop",+ {"type": "content_block_stop", "index": index},+ )++ def _allocate_index(self) -> int:+ index = self._next_index+ self._next_index += 1+ return index++ def _require_block(self, block_id: str, expected_type: str) -> _WireBlock:+ block = self._blocks.get(block_id)+ if block is None or block.block_type != expected_type:+ raise RuntimeError(f"unknown canonical {expected_type} block")+ return block++ def _require_open_block(+ self, block_id: str, expected_type: str | None+ ) -> _WireBlock:+ block = self._blocks.get(block_id)+ if (+ block is None+ or not block.open+ or (expected_type is not None and block.block_type != expected_type)+ ):+ raise RuntimeError("canonical delta/completion targeted a closed block")+ return block+++async def iter_anthropic_sse(+ events: AsyncIterator[InferenceEvent],+ *,+ log_raw_events: bool = False,+) -> AsyncIterator[str]:+ """Serialize canonical events and retain ownership of the event stream."""++ presenter = AnthropicEventPresenter(log_raw_events=log_raw_events)+ try:+ async for event in events:+ for chunk in presenter.present(event):+ yield chunk+ finally:+ await close_stream_input(+ events,+ owner="anthropic_event_presenter",+ source="core",+ preserved_error=sys.exception(),+ )+++async def aggregate_inference_events_to_message(+ events: AsyncIterator[InferenceEvent],+) -> JsonObject:+ """Fold canonical events directly into one non-stream Messages response."""++ message_id = f"msg_{uuid.uuid4()}"+ model = "unknown"+ content: list[JsonValue] = []+ final_usage = InferenceUsage()+ finish_reason = FinishReason.END_TURN+ stop_sequence: str | None = None+ started = False+ completed = False+ try:+ async for event in events:+ if isinstance(event, ResponseStarted):+ if started:+ raise RuntimeError("canonical response started more than once")+ started = True+ model = event.model+ final_usage = event.initial_usage+ elif isinstance(event, TextBlockCompleted):+ content.append({"type": "text", "text": event.text})+ elif isinstance(event, ReasoningBlockCompleted):+ if event.reasoning:+ block: JsonObject = {+ "type": "thinking",+ "thinking": event.reasoning,+ "signature": _reasoning_signature(event.artifacts),+ }+ content.append(block)+ content.extend(_redacted_reasoning_blocks(event.artifacts))+ elif isinstance(event, ToolCallCompleted):+ tool_input: JsonValue = {}+ if event.arguments.strip():+ try:+ parsed: JsonValue = json.loads(event.arguments)+ except json.JSONDecodeError:+ parsed = {}+ if isinstance(parsed, Mapping):+ tool_input = {+ str(key): _json_value(value)+ for key, value in parsed.items()+ }+ tool_block: JsonObject = {+ "type": "tool_use",+ "id": event.call_id,+ "name": event.name,+ "input": tool_input,+ }+ extra_content = _tool_extra_content(event.artifacts)+ if extra_content:+ tool_block["extra_content"] = extra_content+ content.append(tool_block)+ elif isinstance(event, UsageUpdated):+ final_usage = event.usage+ elif isinstance(event, ResponseCompleted):+ final_usage = event.final_usage+ finish_reason = event.finish_reason+ stop_sequence = event.stop_sequence+ completed = True+ except GeneratorExit:+ raise+ except asyncio.CancelledError:+ raise+ finally:+ await close_stream_input(+ events,+ owner="anthropic_event_aggregator",+ source="core",+ preserved_error=sys.exception(),+ )+ if not started or not completed:+ raise RuntimeError("canonical response ended without its lifecycle markers")+ return {+ "id": message_id,+ "type": "message",+ "role": "assistant",+ "content": content,+ "model": model,+ "stop_reason": _anthropic_stop_reason(finish_reason),+ "stop_sequence": stop_sequence,+ "usage": _anthropic_usage(final_usage),+ }+++def _anthropic_stop_reason(reason: FinishReason) -> str:+ return {+ FinishReason.TOOL_CALLS: "tool_use",+ FinishReason.OUTPUT_LIMIT: "max_tokens",+ FinishReason.STOP_SEQUENCE: "stop_sequence",+ }.get(reason, "end_turn")+++def _anthropic_usage(usage: InferenceUsage) -> JsonObject:+ result: JsonObject = {+ "input_tokens": _usage_value(usage.input_tokens),+ "output_tokens": _usage_value(usage.output_tokens),+ }+ if usage.cache_read_input_tokens is not None:+ result["cache_read_input_tokens"] = usage.cache_read_input_tokens.value+ if usage.cache_creation_input_tokens is not None:+ result["cache_creation_input_tokens"] = usage.cache_creation_input_tokens.value+ return result+++def _usage_value(measurement: TokenMeasurement | None) -> int:+ return measurement.value if measurement is not None else 0+++def _tool_extra_content(+ artifacts: tuple[ReplayArtifact, ...],+) -> JsonObject | None:+ result: JsonObject = {}+ for artifact in artifacts:+ if artifact.kind is ReplayArtifactKind.THOUGHT_SIGNATURE:+ result["google"] = {"thought_signature": replay_payload_text(artifact)}+ elif artifact.kind is ReplayArtifactKind.TOOL_EXTRA_CONTENT and isinstance(+ artifact.payload, Mapping+ ):+ result.update(+ {+ str(key): _json_value(value)+ for key, value in artifact.payload.items()+ }+ )+ return result or None+++def _reasoning_signature(artifacts: tuple[ReplayArtifact, ...]) -> str:+ for artifact in artifacts:+ if artifact.kind is ReplayArtifactKind.THINKING_SIGNATURE:+ return replay_payload_text(artifact)+ return ""+++def _redacted_reasoning_blocks(+ artifacts: tuple[ReplayArtifact, ...],+) -> list[JsonValue]:+ return [+ {+ "type": "redacted_thinking",+ "data": replay_payload_text(artifact),+ }+ for artifact in artifacts+ if artifact.kind+ in {+ ReplayArtifactKind.REDACTED_THINKING,+ ReplayArtifactKind.ENCRYPTED_REASONING,+ ReplayArtifactKind.REASONING_DETAILS,+ }+ ]+++def _required_index(block: _WireBlock) -> int:+ if block.index is None:+ raise RuntimeError("Anthropic wire block has no index")+ return block.index+++def _json_value(value: object) -> JsonValue:+ if isinstance(value, Mapping):+ return {str(key): _json_value(item) for key, item in value.items()}+ if isinstance(value, list | tuple):+ return [_json_value(item) for item in value]+ if isinstance(value, bool | int | float | str) or value is None:+ return value+ return str(value)diff --git a/src/free_claude_code/core/anthropic/streaming/__init__.py b/src/free_claude_code/core/anthropic/streaming/__init__.pyindex afe31200..10be1b1b 100644--- a/src/free_claude_code/core/anthropic/streaming/__init__.py+++ b/src/free_claude_code/core/anthropic/streaming/__init__.py@@ -8,7 +8,6 @@ from .emitter import (format_sse_event,map_stop_reason,)-from .ledger import AnthropicStreamLedger, StreamBlockLedger, ToolBlockStatefrom .recovery import (ToolSchema,accept_tool_json_repair,@@ -23,9 +22,6 @@ from .recovery import (__all__ = ["ANTHROPIC_SSE_RESPONSE_HEADERS","AnthropicSseEmitter",- "AnthropicStreamLedger",- "StreamBlockLedger",- "ToolBlockState","ToolSchema","accept_tool_json_repair","anthropic_terminal_error_frame",diff --git a/src/free_claude_code/core/anthropic/streaming/emitter.py b/src/free_claude_code/core/anthropic/streaming/emitter.pyindex 3fab009c..e08328a3 100644--- a/src/free_claude_code/core/anthropic/streaming/emitter.py+++ b/src/free_claude_code/core/anthropic/streaming/emitter.py@@ -1,7 +1,7 @@"""Anthropic SSE serialization helpers."""import json-from typing import Any+from collections.abc import Mappingfrom loguru import logger@@ -30,7 +30,7 @@ def map_stop_reason(openai_reason: str | None) -> str:)-def format_sse_event(event_type: str, data: dict[str, Any]) -> str:+def format_sse_event(event_type: str, data: Mapping[str, object]) -> str:"""Format one Anthropic-style SSE event."""return f"event: {event_type}\ndata: {json.dumps(data)}\n\n"@@ -55,7 +55,7 @@ class AnthropicSseEmitter:def __init__(self, *, log_raw_events: bool = False) -> None:self._log_raw_events = log_raw_events- def event(self, event_type: str, data: dict[str, Any]) -> str:+ def event(self, event_type: str, data: Mapping[str, object]) -> str:event = format_sse_event(event_type, data)if self._log_raw_events:logger.debug("SSE_EVENT: {} - {}", event_type, event.strip())diff --git a/src/free_claude_code/core/anthropic/streaming/ledger.py b/src/free_claude_code/core/anthropic/streaming/ledger.pydeleted file mode 100644index 90c39e85..00000000--- a/src/free_claude_code/core/anthropic/streaming/ledger.py+++ /dev/null@@ -1,543 +0,0 @@-"""Anthropic stream state ledger."""--import hashlib-import json-import uuid-from collections.abc import Iterator, Mapping-from contextlib import suppress-from dataclasses import dataclass, field-from typing import Any--from loguru import logger--from free_claude_code.core.token_estimation import estimate_text_tokens--from .emitter import AnthropicSseEmitter-from .recovery import (- ToolSchema,- parse_complete_tool_input,-)---def _safe_usage_int(value: object) -> int:- return value if isinstance(value, int) else 0---@dataclass-class ToolBlockState:- """State for one streamed tool call."""-- block_index: int- tool_id: str- name: str- extra_content: dict[str, Any] | None = None- started: bool = False- task_arg_buffer: str = ""- task_args_emitted: bool = False- pre_start_args: str = ""---@dataclass-class StreamBlockState:- """Tracked downstream Anthropic content block."""-- index: int- block_type: str- open: bool = True- tool_id: str = ""- name: str = ""- parts: list[str] = field(default_factory=list)- extra_content: dict[str, Any] | None = None-- @property- def content(self) -> str:- return "".join(self.parts)---@dataclass-class StreamBlockLedger:- """Allocate and track Anthropic content block indexes."""-- next_index: int = 0- thinking_index: int = -1- text_index: int = -1- thinking_started: bool = False- text_started: bool = False- tool_states: dict[int, ToolBlockState] = field(default_factory=dict)-- def allocate_index(self) -> int:- idx = self.next_index- self.next_index += 1- return idx-- def reserve_index(self, index: int) -> None:- self.next_index = max(self.next_index, index + 1)-- def ensure_tool_state(self, index: int) -> ToolBlockState:- if index not in self.tool_states:- self.tool_states[index] = ToolBlockState(- block_index=-1, tool_id="", name=""- )- return self.tool_states[index]-- def set_stream_tool_id(self, index: int, tool_id: str | None) -> None:- if not tool_id:- return- self.ensure_tool_state(index).tool_id = str(tool_id)-- def set_tool_extra_content(- self, index: int, extra_content: dict[str, Any] | None- ) -> None:- if extra_content:- self.ensure_tool_state(index).extra_content = extra_content-- def register_tool_name(self, index: int, name: str) -> None:- if index not in self.tool_states:- self.tool_states[index] = ToolBlockState(- block_index=-1, tool_id="", name=name- )- return- state = self.tool_states[index]- prev = state.name- if not prev or name.startswith(prev):- state.name = name- elif not prev.startswith(name):- state.name = prev + name-- def buffer_task_args(self, index: int, args: str) -> dict[str, Any] | None:- state = self.tool_states.get(index)- if state is None or state.task_args_emitted:- return None-- state.task_arg_buffer += args- try:- args_json = json.loads(state.task_arg_buffer)- except Exception:- return None- if not isinstance(args_json, dict):- return None-- _normalize_task_run_in_background(args_json)- state.task_args_emitted = True- state.task_arg_buffer = ""- return args_json-- def flush_task_arg_buffers(self) -> list[tuple[int, str]]:- results: list[tuple[int, str]] = []- for tool_index, state in list(self.tool_states.items()):- if not state.task_arg_buffer or state.task_args_emitted:- continue-- out = "{}"- try:- args_json = json.loads(state.task_arg_buffer)- if isinstance(args_json, dict):- _normalize_task_run_in_background(args_json)- out = json.dumps(args_json)- except (json.JSONDecodeError, TypeError, ValueError) as exc:- digest = hashlib.sha256(- state.task_arg_buffer.encode("utf-8", errors="replace")- ).hexdigest()[:16]- logger.warning(- "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",- state.tool_id or "unknown",- len(state.task_arg_buffer),- digest,- exc,- )-- state.task_args_emitted = True- state.task_arg_buffer = ""- results.append((tool_index, out))- return results---class AnthropicStreamLedger:- """Own mutable Anthropic stream state and produce serialized SSE events."""-- def __init__(- self,- message_id: str | None,- model: str,- input_tokens: int = 0,- *,- log_raw_events: bool = False,- ) -> None:- self.message_id = message_id or f"msg_{uuid.uuid4()}"- self.model = model- self.input_tokens = input_tokens- self.blocks = StreamBlockLedger()- self._emitter = AnthropicSseEmitter(log_raw_events=log_raw_events)- self._text_parts: list[str] = []- self._thinking_parts: list[str] = []- self._open_stack: list[int] = []- self._content_blocks: dict[int, StreamBlockState] = {}- self.message_started = False- self.message_stopped = False- self.stop_reason: str | None = None-- def message_start(self) -> str:- self.message_started = True- safe_input = _safe_usage_int(self.input_tokens)- return self._emitter.event(- "message_start",- {- "type": "message_start",- "message": {- "id": self.message_id,- "type": "message",- "role": "assistant",- "content": [],- "model": self.model,- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": safe_input, "output_tokens": 1},- },- },- )-- def message_delta(- self,- stop_reason: str,- output_tokens: int | None,- *,- input_tokens: int | None = None,- usage_fields: Mapping[str, int] | None = None,- ) -> str:- self.stop_reason = stop_reason- safe_in = _safe_usage_int(- self.input_tokens if input_tokens is None else input_tokens- )- safe_out = output_tokens if isinstance(output_tokens, int) else 0- usage = {"input_tokens": safe_in, "output_tokens": safe_out}- if usage_fields:- usage.update(- {- key: value- for key, value in usage_fields.items()- if isinstance(value, int)- }- )- return self._emitter.event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": stop_reason, "stop_sequence": None},- "usage": usage,- },- )-- def message_stop(self) -> str:- self.message_stopped = True- return self._emitter.event("message_stop", {"type": "message_stop"})-- def content_block_start(self, index: int, block_type: str, **kwargs: Any) -> str:- content_block: dict[str, Any] = {"type": block_type}- if block_type == "thinking":- content_block["thinking"] = kwargs.get("thinking", "")- elif block_type == "text":- content_block["text"] = kwargs.get("text", "")- elif block_type == "tool_use":- content_block["id"] = kwargs.get("id", "")- content_block["name"] = kwargs.get("name", "")- content_block["input"] = kwargs.get("input", {})- extra_content = kwargs.get("extra_content")- if isinstance(extra_content, dict) and extra_content:- content_block["extra_content"] = extra_content- elif block_type == "redacted_thinking":- data = kwargs.get("data")- if isinstance(data, str):- content_block["data"] = data-- self._record_block_start(index, content_block)- return self._emitter.event(- "content_block_start",- {- "type": "content_block_start",- "index": index,- "content_block": content_block,- },- )-- def content_block_delta(self, index: int, delta_type: str, content: str) -> str:- delta: dict[str, Any] = {"type": delta_type}- if delta_type == "thinking_delta":- delta["thinking"] = content- elif delta_type == "signature_delta":- delta["signature"] = content- elif delta_type == "text_delta":- delta["text"] = content- elif delta_type == "input_json_delta":- delta["partial_json"] = content-- self._record_block_delta(index, delta)- return self._emitter.event(- "content_block_delta",- {- "type": "content_block_delta",- "index": index,- "delta": delta,- },- )-- def content_block_stop(self, index: int) -> str:- self._record_block_stop(index)- return self._emitter.event(- "content_block_stop",- {"type": "content_block_stop", "index": index},- )-- def start_thinking_block(self) -> str:- self.blocks.thinking_index = self.blocks.allocate_index()- self.blocks.thinking_started = True- return self.content_block_start(self.blocks.thinking_index, "thinking")-- def emit_thinking_delta(self, content: str) -> str:- return self.content_block_delta(- self.blocks.thinking_index, "thinking_delta", content- )-- def stop_thinking_block(self) -> str:- self.blocks.thinking_started = False- return self.content_block_stop(self.blocks.thinking_index)-- def start_text_block(self) -> str:- self.blocks.text_index = self.blocks.allocate_index()- self.blocks.text_started = True- return self.content_block_start(self.blocks.text_index, "text")-- def emit_text_delta(self, content: str) -> str:- return self.content_block_delta(self.blocks.text_index, "text_delta", content)-- def stop_text_block(self) -> str:- self.blocks.text_started = False- return self.content_block_stop(self.blocks.text_index)-- def start_tool_block(- self,- tool_index: int,- tool_id: str,- name: str,- *,- extra_content: dict[str, Any] | None = None,- ) -> str:- block_idx = self.blocks.allocate_index()- if tool_index in self.blocks.tool_states:- state = self.blocks.tool_states[tool_index]- state.block_index = block_idx- state.tool_id = tool_id- state.name = name- if extra_content:- state.extra_content = extra_content- state.started = True- else:- self.blocks.tool_states[tool_index] = ToolBlockState(- block_index=block_idx,- tool_id=tool_id,- name=name,- extra_content=extra_content,- started=True,- )- return self.content_block_start(- block_idx,- "tool_use",- id=tool_id,- name=name,- extra_content=extra_content,- )-- def emit_tool_delta(self, tool_index: int, partial_json: str) -> str:- state = self.blocks.tool_states[tool_index]- return self.content_block_delta(- state.block_index, "input_json_delta", partial_json- )-- def stop_tool_block(self, tool_index: int) -> str:- return self.content_block_stop(self.blocks.tool_states[tool_index].block_index)-- def ensure_thinking_block(self) -> Iterator[str]:- if self.blocks.text_started:- yield self.stop_text_block()- if not self.blocks.thinking_started:- yield self.start_thinking_block()-- def ensure_text_block(self) -> Iterator[str]:- if self.blocks.thinking_started:- yield self.stop_thinking_block()- if not self.blocks.text_started:- yield self.start_text_block()-- def close_content_blocks(self) -> Iterator[str]:- if self.blocks.thinking_started:- yield self.stop_thinking_block()- if self.blocks.text_started:- yield self.stop_text_block()-- def close_all_blocks(self) -> Iterator[str]:- yield from self.close_content_blocks()- for tool_index, state in list(self.blocks.tool_states.items()):- if state.started:- yield self.stop_tool_block(tool_index)-- def close_unclosed_blocks(self) -> Iterator[str]:- while self._open_stack:- idx = self._open_stack.pop()- state = self._content_blocks.get(idx)- if state is not None:- state.open = False- self._clear_active_content_block(state)- yield self._emitter.event(- "content_block_stop",- {"type": "content_block_stop", "index": idx},- )-- def can_salvage_tool_use(self, schemas: dict[str, ToolSchema]) -> bool:- tool_blocks = self.tool_blocks()- if not tool_blocks:- return False- for block in tool_blocks:- if not block.tool_id or not block.name:- return False- if parse_complete_tool_input(block.content, block.name, schemas) is None:- return False- return True-- def tool_blocks(self) -> list[StreamBlockState]:- return [- block- for block in self._content_blocks.values()- if block.block_type == "tool_use"- ]-- def tool_block_for_tool_index(self, tool_index: int) -> StreamBlockState | None:- state = self.blocks.tool_states.get(tool_index)- if state is None or state.block_index < 0:- return None- block = self._content_blocks.get(state.block_index)- if block is None or block.block_type != "tool_use":- return None- return block-- def has_emitted_tool_block(self) -> bool:- return bool(self.tool_blocks())-- def has_content_block(self) -> bool:- return bool(self._content_blocks)-- def final_stop_reason(self, fallback: str) -> str:- if self.has_emitted_tool_block():- return "tool_use"- return fallback-- def has_terminal_message(self) -> bool:- return self.message_stopped-- @property- def accumulated_text(self) -> str:- return "".join(self._text_parts)-- @property- def accumulated_reasoning(self) -> str:- return "".join(self._thinking_parts)-- def estimate_output_tokens(self) -> int:- text_tokens = estimate_text_tokens(self.accumulated_text)- reasoning_tokens = estimate_text_tokens(self.accumulated_reasoning)- tool_tokens = 0- tool_count = 0- for name, content in self._iter_tool_token_payloads():- tool_tokens += estimate_text_tokens(name)- tool_tokens += estimate_text_tokens(content)- tool_tokens += 15- tool_count += 1-- block_count = (- (1 if self.accumulated_reasoning else 0)- + (1 if self.accumulated_text else 0)- + tool_count- )- return text_tokens + reasoning_tokens + tool_tokens + (block_count * 4)-- def _iter_tool_token_payloads(self) -> Iterator[tuple[str, str]]:- for block in self.tool_blocks():- yield block.name, block.content-- def _record_block_start(self, index: int, block: dict[str, Any]) -> None:- self.blocks.reserve_index(index)- block_type = str(block.get("type", ""))- state = StreamBlockState(index=index, block_type=block_type)- if block_type == "tool_use":- tool_id = block.get("id")- name = block.get("name")- state.tool_id = tool_id if isinstance(tool_id, str) else ""- state.name = name if isinstance(name, str) else ""- extra_content = block.get("extra_content")- state.extra_content = (- extra_content if isinstance(extra_content, dict) else None- )- elif block_type == "text":- self.blocks.text_index = index- self.blocks.text_started = True- text = block.get("text")- if isinstance(text, str) and text:- state.parts.append(text)- self._text_parts.append(text)- elif block_type == "thinking":- self.blocks.thinking_index = index- self.blocks.thinking_started = True- thinking = block.get("thinking")- if isinstance(thinking, str) and thinking:- state.parts.append(thinking)- self._thinking_parts.append(thinking)- self._content_blocks[index] = state- self._open_stack.append(index)-- def _record_block_delta(self, index: int, delta: dict[str, Any]) -> None:- state = self._content_blocks.get(index)- if state is None:- return- if state.block_type == "text":- text = delta.get("text")- if isinstance(text, str):- state.parts.append(text)- self._text_parts.append(text)- elif state.block_type == "thinking":- thinking = delta.get("thinking")- if isinstance(thinking, str):- state.parts.append(thinking)- self._thinking_parts.append(thinking)- elif state.block_type == "tool_use":- partial = delta.get("partial_json")- if isinstance(partial, str):- state.parts.append(partial)-- def _record_block_stop(self, index: int) -> None:- if self._open_stack and self._open_stack[-1] == index:- self._open_stack.pop()- else:- with suppress(ValueError):- self._open_stack.remove(index)- state = self._content_blocks.get(index)- if state is not None:- state.open = False- self._clear_active_content_block(state)-- def _last_open_block(self, block_type: str) -> StreamBlockState | None:- for index in reversed(self._open_stack):- block = self._content_blocks.get(index)- if block is not None and block.block_type == block_type and block.open:- return block- return None-- def _clear_active_content_block(self, state: StreamBlockState) -> None:- if state.block_type == "text" and self.blocks.text_index == state.index:- self.blocks.text_started = False- elif (- state.block_type == "thinking" and self.blocks.thinking_index == state.index- ):- self.blocks.thinking_started = False---def _normalize_task_run_in_background(args_json: dict[str, Any]) -> None:- if args_json.get("run_in_background") is not False:- args_json["run_in_background"] = Falsediff --git a/src/free_claude_code/core/inference/__init__.py b/src/free_claude_code/core/inference/__init__.pynew file mode 100644index 00000000..eaf3934a--- /dev/null+++ b/src/free_claude_code/core/inference/__init__.py@@ -0,0 +1,65 @@+"""Provider-neutral inference contracts."""++from .events import (+ FinishReason,+ InferenceEvent,+ InferenceUsage,+ ReasoningBlockCompleted,+ ReasoningBlockStarted,+ ReasoningDelta,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ResponseCompleted,+ ResponseStarted,+ TextBlockCompleted,+ TextBlockStarted,+ TextDelta,+ TokenMeasurement,+ ToolCallArgumentsDelta,+ ToolCallCompleted,+ ToolCallKind,+ ToolCallStarted,+ UsageSource,+ UsageUpdated,+ inference_event_size,+ replay_payload_text,+)+from .ledger import (+ InferenceBlockLedger,+ InferenceBlockState,+ InferenceStreamLedger,+ ToolCallState,+)++__all__ = [+ "FinishReason",+ "InferenceBlockLedger",+ "InferenceBlockState",+ "InferenceEvent",+ "InferenceStreamLedger",+ "InferenceUsage",+ "ReasoningBlockCompleted",+ "ReasoningBlockStarted",+ "ReasoningDelta",+ "ReplayArtifact",+ "ReplayArtifactKind",+ "ReplayArtifactOrigin",+ "ReplayAttachment",+ "ResponseCompleted",+ "ResponseStarted",+ "TextBlockCompleted",+ "TextBlockStarted",+ "TextDelta",+ "TokenMeasurement",+ "ToolCallArgumentsDelta",+ "ToolCallCompleted",+ "ToolCallKind",+ "ToolCallStarted",+ "ToolCallState",+ "UsageSource",+ "UsageUpdated",+ "inference_event_size",+ "replay_payload_text",+]diff --git a/src/free_claude_code/core/inference/events.py b/src/free_claude_code/core/inference/events.pynew file mode 100644index 00000000..f12c6071--- /dev/null+++ b/src/free_claude_code/core/inference/events.py@@ -0,0 +1,330 @@+"""Provider-neutral streamed inference output values."""++import json+from collections.abc import Mapping, Sequence+from dataclasses import dataclass+from enum import StrEnum++from free_claude_code.core.json_types import JsonValue+++class FinishReason(StrEnum):+ """Canonical reason a successful provider stream stopped."""++ END_TURN = "end_turn"+ TOOL_CALLS = "tool_calls"+ OUTPUT_LIMIT = "output_limit"+ STOP_SEQUENCE = "stop_sequence"+ CONTENT_FILTER = "content_filter"+ PROVIDER_UNKNOWN = "provider_unknown"+++class UsageSource(StrEnum):+ """Whether a token measurement came from upstream or FCC estimation."""++ REPORTED = "reported"+ ESTIMATED = "estimated"+++@dataclass(frozen=True, slots=True)+class TokenMeasurement:+ """One non-negative token count with explicit provenance."""++ value: int+ source: UsageSource++ def __post_init__(self) -> None:+ if (+ not isinstance(self.value, int)+ or isinstance(self.value, bool)+ or self.value < 0+ ):+ raise ValueError("token measurements must be non-negative integers")+++@dataclass(frozen=True, slots=True)+class InferenceUsage:+ """Cumulative provider-neutral token usage."""++ input_tokens: TokenMeasurement | None = None+ cache_read_input_tokens: TokenMeasurement | None = None+ cache_creation_input_tokens: TokenMeasurement | None = None+ output_tokens: TokenMeasurement | None = None+ reasoning_output_tokens: TokenMeasurement | None = None+++class ReplayArtifactOrigin(StrEnum):+ """Protocol or provider family that owns an opaque replay value."""++ ANTHROPIC = "anthropic"+ OPENAI = "openai"+ OPENROUTER = "openrouter"+ GOOGLE = "google"+ OPENAI_COMPATIBLE = "openai_compatible"+++class ReplayArtifactKind(StrEnum):+ """Known opaque replay value kinds preserved by FCC."""++ THINKING_SIGNATURE = "thinking_signature"+ REDACTED_THINKING = "redacted_thinking"+ ENCRYPTED_REASONING = "encrypted_reasoning"+ REASONING_DETAILS = "reasoning_details"+ THOUGHT_SIGNATURE = "thought_signature"+ TOOL_EXTRA_CONTENT = "tool_extra_content"+++class ReplayAttachment(StrEnum):+ """Semantic item to which a replay artifact belongs."""++ REASONING = "reasoning"+ TOOL_CALL = "tool_call"+++@dataclass(frozen=True, slots=True)+class ReplayArtifact:+ """Opaque provider replay material with a typed owner and scope."""++ origin: ReplayArtifactOrigin+ kind: ReplayArtifactKind+ attachment: ReplayAttachment+ payload: JsonValue+++class ToolCallKind(StrEnum):+ """Canonical tool invocation representation."""++ FUNCTION = "function"+ CUSTOM = "custom"+++@dataclass(frozen=True, slots=True)+class ResponseStarted:+ response_id: str+ model: str+ initial_usage: InferenceUsage = InferenceUsage()+++@dataclass(frozen=True, slots=True)+class TextBlockStarted:+ item_id: str+ block_id: str+++@dataclass(frozen=True, slots=True)+class TextDelta:+ block_id: str+ delta: str+++@dataclass(frozen=True, slots=True)+class TextBlockCompleted:+ item_id: str+ block_id: str+ text: str+++@dataclass(frozen=True, slots=True)+class ReasoningBlockStarted:+ item_id: str+ block_id: str+ artifacts: tuple[ReplayArtifact, ...] = ()+++@dataclass(frozen=True, slots=True)+class ReasoningDelta:+ block_id: str+ delta: str+++@dataclass(frozen=True, slots=True)+class ReasoningBlockCompleted:+ item_id: str+ block_id: str+ reasoning: str+ artifacts: tuple[ReplayArtifact, ...] = ()+++@dataclass(frozen=True, slots=True)+class ToolCallStarted:+ item_id: str+ block_id: str+ call_id: str+ kind: ToolCallKind+ name: str+ namespace: str | None = None+ artifacts: tuple[ReplayArtifact, ...] = ()+++@dataclass(frozen=True, slots=True)+class ToolCallArgumentsDelta:+ block_id: str+ delta: str+++@dataclass(frozen=True, slots=True)+class ToolCallCompleted:+ item_id: str+ block_id: str+ call_id: str+ kind: ToolCallKind+ name: str+ arguments: str+ namespace: str | None = None+ artifacts: tuple[ReplayArtifact, ...] = ()+++@dataclass(frozen=True, slots=True)+class UsageUpdated:+ usage: InferenceUsage+++@dataclass(frozen=True, slots=True)+class ResponseCompleted:+ finish_reason: FinishReason+ final_usage: InferenceUsage+ stop_sequence: str | None = None+++type InferenceEvent = (+ ResponseStarted+ | TextBlockStarted+ | TextDelta+ | TextBlockCompleted+ | ReasoningBlockStarted+ | ReasoningDelta+ | ReasoningBlockCompleted+ | ToolCallStarted+ | ToolCallArgumentsDelta+ | ToolCallCompleted+ | UsageUpdated+ | ResponseCompleted+)+++def inference_event_size(event: InferenceEvent) -> int:+ """Return deterministic compact UTF-8 size for private holdback accounting."""++ payload = _event_projection(event)+ encoded = json.dumps(+ payload,+ ensure_ascii=False,+ separators=(",", ":"),+ sort_keys=True,+ )+ return len(encoded.encode("utf-8", errors="replace"))+++def replay_payload_text(artifact: ReplayArtifact) -> str:+ """Render one opaque artifact payload for a wire format that requires text."""++ if isinstance(artifact.payload, str):+ return artifact.payload+ return json.dumps(+ _json_projection(artifact.payload),+ ensure_ascii=False,+ separators=(",", ":"),+ sort_keys=True,+ )+++def _event_projection(event: InferenceEvent) -> JsonValue:+ if isinstance(event, ResponseStarted):+ return [+ "response_started",+ event.response_id,+ event.model,+ _usage(event.initial_usage),+ ]+ if isinstance(event, TextBlockStarted):+ return ["text_started", event.item_id, event.block_id]+ if isinstance(event, TextDelta):+ return ["text_delta", event.block_id, event.delta]+ if isinstance(event, TextBlockCompleted):+ return ["text_completed", event.item_id, event.block_id, event.text]+ if isinstance(event, ReasoningBlockStarted):+ return [+ "reasoning_started",+ event.item_id,+ event.block_id,+ _artifacts(event.artifacts),+ ]+ if isinstance(event, ReasoningDelta):+ return ["reasoning_delta", event.block_id, event.delta]+ if isinstance(event, ReasoningBlockCompleted):+ return [+ "reasoning_completed",+ event.item_id,+ event.block_id,+ event.reasoning,+ _artifacts(event.artifacts),+ ]+ if isinstance(event, ToolCallStarted):+ return [+ "tool_started",+ event.item_id,+ event.block_id,+ event.call_id,+ event.kind.value,+ event.namespace,+ event.name,+ _artifacts(event.artifacts),+ ]+ if isinstance(event, ToolCallArgumentsDelta):+ return ["tool_delta", event.block_id, event.delta]+ if isinstance(event, ToolCallCompleted):+ return [+ "tool_completed",+ event.item_id,+ event.block_id,+ event.call_id,+ event.kind.value,+ event.namespace,+ event.name,+ event.arguments,+ _artifacts(event.artifacts),+ ]+ if isinstance(event, UsageUpdated):+ return ["usage", _usage(event.usage)]+ return [+ "response_completed",+ event.finish_reason.value,+ event.stop_sequence,+ _usage(event.final_usage),+ ]+++def _usage(usage: InferenceUsage) -> JsonValue:+ return {+ "input": _measurement(usage.input_tokens),+ "cache_read": _measurement(usage.cache_read_input_tokens),+ "cache_creation": _measurement(usage.cache_creation_input_tokens),+ "output": _measurement(usage.output_tokens),+ "reasoning_output": _measurement(usage.reasoning_output_tokens),+ }+++def _measurement(measurement: TokenMeasurement | None) -> JsonValue:+ if measurement is None:+ return None+ return [measurement.value, measurement.source.value]+++def _artifacts(artifacts: tuple[ReplayArtifact, ...]) -> JsonValue:+ return [+ [+ artifact.origin.value,+ artifact.kind.value,+ artifact.attachment.value,+ _json_projection(artifact.payload),+ ]+ for artifact in artifacts+ ]+++def _json_projection(value: JsonValue) -> JsonValue:+ if isinstance(value, Mapping):+ return {str(key): _json_projection(item) for key, item in value.items()}+ if isinstance(value, Sequence) and not isinstance(value, str | bytes | bytearray):+ return [_json_projection(item) for item in value]+ return valuediff --git a/src/free_claude_code/core/inference/ledger.py b/src/free_claude_code/core/inference/ledger.pynew file mode 100644index 00000000..51df919a--- /dev/null+++ b/src/free_claude_code/core/inference/ledger.py@@ -0,0 +1,503 @@+"""Semantic state for one provider-neutral inference stream."""++import hashlib+import json+import uuid+from collections.abc import Iterator+from dataclasses import dataclass, field++from loguru import logger++from free_claude_code.core.json_types import JsonValue+from free_claude_code.core.token_estimation import estimate_text_tokens++from .events import (+ FinishReason,+ InferenceEvent,+ InferenceUsage,+ ReasoningBlockCompleted,+ ReasoningBlockStarted,+ ReasoningDelta,+ ReplayArtifact,+ ResponseCompleted,+ ResponseStarted,+ TextBlockCompleted,+ TextBlockStarted,+ TextDelta,+ TokenMeasurement,+ ToolCallArgumentsDelta,+ ToolCallCompleted,+ ToolCallKind,+ ToolCallStarted,+ UsageSource,+ UsageUpdated,+)+++def _new_identity(prefix: str) -> str:+ return f"{prefix}_{uuid.uuid4().hex}"+++@dataclass(slots=True)+class ToolCallState:+ """Mutable assembly state for one upstream tool-call index."""++ block_id: str = ""+ item_id: str = ""+ call_id: str = ""+ name: str = ""+ kind: ToolCallKind = ToolCallKind.FUNCTION+ namespace: str | None = None+ artifacts: tuple[ReplayArtifact, ...] = ()+ started: bool = False+ task_arg_buffer: str = ""+ task_args_emitted: bool = False+ pre_start_args: str = ""+++@dataclass(slots=True)+class InferenceBlockState:+ """Accumulated semantic state for one canonical output block."""++ block_id: str+ item_id: str+ block_type: str+ open: bool = True+ call_id: str = ""+ name: str = ""+ kind: ToolCallKind = ToolCallKind.FUNCTION+ namespace: str | None = None+ artifacts: tuple[ReplayArtifact, ...] = ()+ parts: list[str] = field(default_factory=list)++ @property+ def content(self) -> str:+ return "".join(self.parts)+++@dataclass(slots=True)+class InferenceBlockLedger:+ """Track active canonical blocks without assigning public wire indexes."""++ reasoning_block_id: str | None = None+ text_block_id: str | None = None+ reasoning_started: bool = False+ text_started: bool = False+ tool_states: dict[int, ToolCallState] = field(default_factory=dict)++ def ensure_tool_state(self, index: int) -> ToolCallState:+ return self.tool_states.setdefault(index, ToolCallState())++ def set_stream_tool_id(self, index: int, call_id: str | None) -> None:+ if call_id:+ self.ensure_tool_state(index).call_id = str(call_id)++ def set_tool_artifacts(+ self, index: int, artifacts: tuple[ReplayArtifact, ...]+ ) -> None:+ if artifacts:+ state = self.ensure_tool_state(index)+ state.artifacts = _merge_artifacts(state.artifacts, artifacts)++ def register_tool_name(self, index: int, name: str) -> None:+ state = self.ensure_tool_state(index)+ previous = state.name+ if not previous or name.startswith(previous):+ state.name = name+ elif not previous.startswith(name):+ state.name = "".join((previous, name))++ def buffer_task_args(self, index: int, args: str) -> dict[str, JsonValue] | None:+ state = self.tool_states.get(index)+ if state is None or state.task_args_emitted:+ return None++ state.task_arg_buffer += args+ try:+ parsed: JsonValue = json.loads(state.task_arg_buffer)+ except json.JSONDecodeError, TypeError, ValueError:+ return None+ if not isinstance(parsed, dict):+ return None++ normalized = {str(key): value for key, value in parsed.items()}+ _normalize_task_run_in_background(normalized)+ state.task_args_emitted = True+ state.task_arg_buffer = ""+ return normalized++ def flush_task_arg_buffers(self) -> list[tuple[int, str]]:+ results: list[tuple[int, str]] = []+ for tool_index, state in list(self.tool_states.items()):+ if not state.task_arg_buffer or state.task_args_emitted:+ continue++ output = "{}"+ try:+ parsed: JsonValue = json.loads(state.task_arg_buffer)+ if isinstance(parsed, dict):+ normalized = {str(key): value for key, value in parsed.items()}+ _normalize_task_run_in_background(normalized)+ output = json.dumps(normalized)+ except (json.JSONDecodeError, TypeError, ValueError) as exc:+ digest = hashlib.sha256(+ state.task_arg_buffer.encode("utf-8", errors="replace")+ ).hexdigest()[:16]+ logger.warning(+ "Task args invalid JSON (id={} len={} buffer_sha256_prefix={}): {}",+ state.call_id or "unknown",+ len(state.task_arg_buffer),+ digest,+ exc,+ )++ state.task_args_emitted = True+ state.task_arg_buffer = ""+ results.append((tool_index, output))+ return results+++class InferenceStreamLedger:+ """Validate and accumulate one canonical provider output stream."""++ def __init__(+ self,+ response_id: str | None,+ model: str,+ input_tokens: int = 0,+ ) -> None:+ self.response_id = response_id or _new_identity("response")+ self.model = model+ self.input_tokens = max(input_tokens, 0)+ self.blocks = InferenceBlockLedger()+ self._text_parts: list[str] = []+ self._reasoning_parts: list[str] = []+ self._open_stack: list[str] = []+ self._content_blocks: dict[str, InferenceBlockState] = {}+ self.response_started = False+ self.response_completed = False+ self.finish_reason: FinishReason | None = None+ self.usage = InferenceUsage(+ input_tokens=TokenMeasurement(self.input_tokens, UsageSource.ESTIMATED)+ )++ def start_response(self) -> ResponseStarted:+ if self.response_started:+ raise RuntimeError("response already started")+ self.response_started = True+ return ResponseStarted(self.response_id, self.model, self.usage)++ def start_reasoning_block(+ self, *, artifacts: tuple[ReplayArtifact, ...] = ()+ ) -> ReasoningBlockStarted:+ self._require_response_open()+ block_id = _new_identity("block")+ item_id = _new_identity("item")+ self.blocks.reasoning_block_id = block_id+ self.blocks.reasoning_started = True+ self._record_block_start(+ InferenceBlockState(+ block_id=block_id,+ item_id=item_id,+ block_type="reasoning",+ artifacts=artifacts,+ )+ )+ return ReasoningBlockStarted(item_id, block_id, artifacts)++ def emit_reasoning_delta(self, content: str) -> ReasoningDelta:+ block = self._active_block(self.blocks.reasoning_block_id, "reasoning")+ block.parts.append(content)+ self._reasoning_parts.append(content)+ return ReasoningDelta(block.block_id, content)++ def stop_reasoning_block(self) -> ReasoningBlockCompleted:+ block = self._active_block(self.blocks.reasoning_block_id, "reasoning")+ self._record_block_stop(block.block_id)+ return ReasoningBlockCompleted(+ block.item_id,+ block.block_id,+ block.content,+ block.artifacts,+ )++ def emit_reasoning_artifact(+ self, artifact: ReplayArtifact+ ) -> Iterator[InferenceEvent]:+ yield from self.close_content_blocks()+ yield self.start_reasoning_block(artifacts=(artifact,))+ yield self.stop_reasoning_block()++ def start_text_block(self) -> TextBlockStarted:+ self._require_response_open()+ block_id = _new_identity("block")+ item_id = _new_identity("item")+ self.blocks.text_block_id = block_id+ self.blocks.text_started = True+ self._record_block_start(+ InferenceBlockState(+ block_id=block_id,+ item_id=item_id,+ block_type="text",+ )+ )+ return TextBlockStarted(item_id, block_id)++ def emit_text_delta(self, content: str) -> TextDelta:+ block = self._active_block(self.blocks.text_block_id, "text")+ block.parts.append(content)+ self._text_parts.append(content)+ return TextDelta(block.block_id, content)++ def stop_text_block(self) -> TextBlockCompleted:+ block = self._active_block(self.blocks.text_block_id, "text")+ self._record_block_stop(block.block_id)+ return TextBlockCompleted(block.item_id, block.block_id, block.content)++ def start_tool_block(+ self,+ tool_index: int,+ call_id: str,+ name: str,+ *,+ kind: ToolCallKind = ToolCallKind.FUNCTION,+ namespace: str | None = None,+ artifacts: tuple[ReplayArtifact, ...] = (),+ ) -> ToolCallStarted:+ self._require_response_open()+ block_id = _new_identity("block")+ item_id = _new_identity("item")+ state = self.blocks.ensure_tool_state(tool_index)+ state.block_id = block_id+ state.item_id = item_id+ state.call_id = call_id+ state.name = name+ state.kind = kind+ state.namespace = namespace+ state.artifacts = _merge_artifacts(state.artifacts, artifacts)+ state.started = True+ block = InferenceBlockState(+ block_id=block_id,+ item_id=item_id,+ block_type="tool_call",+ call_id=call_id,+ name=name,+ kind=kind,+ namespace=namespace,+ artifacts=state.artifacts,+ )+ self._record_block_start(block)+ return ToolCallStarted(+ item_id,+ block_id,+ call_id,+ kind,+ name,+ namespace,+ block.artifacts,+ )++ def set_tool_artifacts(+ self, tool_index: int, artifacts: tuple[ReplayArtifact, ...]+ ) -> None:+ self.blocks.set_tool_artifacts(tool_index, artifacts)+ state = self.blocks.tool_states[tool_index]+ if not state.block_id:+ return+ block = self._content_blocks.get(state.block_id)+ if block is not None:+ block.artifacts = state.artifacts++ def emit_tool_delta(+ self, tool_index: int, partial_arguments: str+ ) -> ToolCallArgumentsDelta:+ state = self.blocks.tool_states[tool_index]+ block = self._active_block(state.block_id, "tool_call")+ block.parts.append(partial_arguments)+ return ToolCallArgumentsDelta(block.block_id, partial_arguments)++ def stop_tool_block(self, tool_index: int) -> ToolCallCompleted:+ state = self.blocks.tool_states[tool_index]+ block = self._active_block(state.block_id, "tool_call")+ self._record_block_stop(block.block_id)+ state.started = False+ return ToolCallCompleted(+ block.item_id,+ block.block_id,+ block.call_id,+ block.kind,+ block.name,+ block.content,+ block.namespace,+ block.artifacts,+ )++ def ensure_reasoning_block(self) -> Iterator[InferenceEvent]:+ if self.blocks.text_started:+ yield self.stop_text_block()+ if not self.blocks.reasoning_started:+ yield self.start_reasoning_block()++ def ensure_text_block(self) -> Iterator[InferenceEvent]:+ if self.blocks.reasoning_started:+ yield self.stop_reasoning_block()+ if not self.blocks.text_started:+ yield self.start_text_block()++ def close_content_blocks(self) -> Iterator[InferenceEvent]:+ if self.blocks.reasoning_started:+ yield self.stop_reasoning_block()+ if self.blocks.text_started:+ yield self.stop_text_block()++ def close_all_blocks(self) -> Iterator[InferenceEvent]:+ yield from self.close_content_blocks()+ for tool_index, state in list(self.blocks.tool_states.items()):+ if state.started:+ yield self.stop_tool_block(tool_index)++ def close_unclosed_blocks(self) -> Iterator[InferenceEvent]:+ while self._open_stack:+ block_id = self._open_stack[-1]+ block = self._content_blocks[block_id]+ if block.block_type == "text":+ yield self.stop_text_block()+ elif block.block_type == "reasoning":+ yield self.stop_reasoning_block()+ else:+ tool_index = self._tool_index_for_block(block_id)+ if tool_index is None:+ raise RuntimeError("tool block has no assembly state")+ yield self.stop_tool_block(tool_index)++ def finish_events(+ self,+ finish_reason: FinishReason,+ usage: InferenceUsage,+ *,+ stop_sequence: str | None = None,+ ) -> tuple[UsageUpdated, ResponseCompleted]:+ self._require_response_open()+ if self._open_stack:+ raise RuntimeError("response cannot complete with open output blocks")+ self.finish_reason = self.final_finish_reason(finish_reason)+ self.usage = usage+ self.response_completed = True+ return (+ UsageUpdated(usage),+ ResponseCompleted(self.finish_reason, usage, stop_sequence),+ )++ def tool_blocks(self) -> list[InferenceBlockState]:+ return [+ block+ for block in self._content_blocks.values()+ if block.block_type == "tool_call"+ ]++ def tool_block_for_tool_index(self, tool_index: int) -> InferenceBlockState | None:+ state = self.blocks.tool_states.get(tool_index)+ if state is None or not state.block_id:+ return None+ block = self._content_blocks.get(state.block_id)+ if block is None or block.block_type != "tool_call":+ return None+ return block++ def has_emitted_tool_block(self) -> bool:+ return bool(self.tool_blocks())++ def has_content_block(self) -> bool:+ return bool(self._content_blocks)++ def has_generated_output(self) -> bool:+ return self.has_content_block()++ def final_finish_reason(self, fallback: FinishReason) -> FinishReason:+ if self.has_emitted_tool_block():+ return FinishReason.TOOL_CALLS+ return fallback++ @property+ def accumulated_text(self) -> str:+ return "".join(self._text_parts)++ @property+ def accumulated_reasoning(self) -> str:+ return "".join(self._reasoning_parts)++ def estimate_output_tokens(self) -> int:+ text_tokens = estimate_text_tokens(self.accumulated_text)+ reasoning_tokens = estimate_text_tokens(self.accumulated_reasoning)+ tool_tokens = 0+ tool_count = 0+ for name, content in self._iter_tool_token_payloads():+ tool_tokens += estimate_text_tokens(name)+ tool_tokens += estimate_text_tokens(content)+ tool_tokens += 15+ tool_count += 1++ block_count = (+ (1 if self.accumulated_reasoning else 0)+ + (1 if self.accumulated_text else 0)+ + tool_count+ )+ return text_tokens + reasoning_tokens + tool_tokens + (block_count * 4)++ def estimate_reasoning_tokens(self) -> int:+ return estimate_text_tokens(self.accumulated_reasoning)++ def _iter_tool_token_payloads(self) -> Iterator[tuple[str, str]]:+ for block in self.tool_blocks():+ yield block.name, block.content++ def _record_block_start(self, block: InferenceBlockState) -> None:+ self._content_blocks[block.block_id] = block+ self._open_stack.append(block.block_id)++ def _record_block_stop(self, block_id: str) -> None:+ block = self._content_blocks[block_id]+ if not block.open:+ raise RuntimeError("canonical block already completed")+ try:+ self._open_stack.remove(block_id)+ except ValueError as exc:+ raise RuntimeError("canonical block is not open") from exc+ block.open = False+ if block.block_type == "text":+ self.blocks.text_started = False+ elif block.block_type == "reasoning":+ self.blocks.reasoning_started = False++ def _active_block(+ self, block_id: str | None, expected_type: str+ ) -> InferenceBlockState:+ if block_id is None:+ raise RuntimeError(f"no active {expected_type} block")+ block = self._content_blocks.get(block_id)+ if block is None or block.block_type != expected_type or not block.open:+ raise RuntimeError(f"no active {expected_type} block")+ return block++ def _tool_index_for_block(self, block_id: str) -> int | None:+ for tool_index, state in self.blocks.tool_states.items():+ if state.block_id == block_id:+ return tool_index+ return None++ def _require_response_open(self) -> None:+ if not self.response_started:+ raise RuntimeError("response has not started")+ if self.response_completed:+ raise RuntimeError("response already completed")+++def _merge_artifacts(+ existing: tuple[ReplayArtifact, ...], incoming: tuple[ReplayArtifact, ...]+) -> tuple[ReplayArtifact, ...]:+ return (*existing, *(artifact for artifact in incoming if artifact not in existing))+++def _normalize_task_run_in_background(args: dict[str, JsonValue]) -> None:+ if args.get("run_in_background") is not False:+ args["run_in_background"] = Falsediff --git a/src/free_claude_code/core/openai_responses/__init__.py b/src/free_claude_code/core/openai_responses/__init__.pyindex 48c47383..adf6b99a 100644--- a/src/free_claude_code/core/openai_responses/__init__.py+++ b/src/free_claude_code/core/openai_responses/__init__.py@@ -8,16 +8,22 @@ from .errors import (openai_failure_payload,)from .models import OpenAIResponsesRequest+from .presenter import (+ ResponsesEventPresenter,+ iter_responses_sse_from_events,+)+from .provider_events import ResponsesEventDecoder, ResponsesStreamFailurefrom .provider_input import build_responses_provider_request-from .provider_stream import ResponsesProviderStream, ResponsesStreamFailure__all__ = ["OpenAIResponsesAdapter","OpenAIResponsesRequest","ResponsesConversionError",- "ResponsesProviderStream",+ "ResponsesEventDecoder",+ "ResponsesEventPresenter","ResponsesStreamFailure","build_responses_provider_request",+ "iter_responses_sse_from_events","openai_error_payload","openai_error_type_for_failure","openai_failure_payload",diff --git a/src/free_claude_code/core/openai_responses/adapter.py b/src/free_claude_code/core/openai_responses/adapter.pyindex bb0e2ac5..60b0f2cb 100644--- a/src/free_claude_code/core/openai_responses/adapter.py+++ b/src/free_claude_code/core/openai_responses/adapter.py@@ -1,20 +1,15 @@"""Facade for OpenAI Responses protocol adaptation."""-from collections.abc import AsyncIterable, AsyncIteratorfrom typing import Any, ClassVarfrom .errors import ResponsesConversionError, openai_error_payloadfrom .events import OPENAI_RESPONSES_SSE_HEADERSfrom .input import convert_request_to_anthropic_payloadfrom .models import OpenAIResponsesRequest-from .stream import (- PostStartTerminalFailureObserver,- iter_responses_sse_from_anthropic,-)class OpenAIResponsesAdapter:- """Convert between OpenAI Responses and the proxy's Anthropic core path."""+ """Convert the current Responses request bridge and public error envelopes."""ConversionError: ClassVar[type[ResponsesConversionError]] = ResponsesConversionErrorsse_headers: ClassVar[dict[str, str]] = OPENAI_RESPONSES_SSE_HEADERS@@ -22,18 +17,5 @@ class OpenAIResponsesAdapter:def to_anthropic_payload(self, request: OpenAIResponsesRequest) -> dict[str, Any]:return convert_request_to_anthropic_payload(request)- def iter_sse_from_anthropic(- self,- chunks: AsyncIterable[Any],- request: OpenAIResponsesRequest,- *,- on_post_start_terminal_failure: PostStartTerminalFailureObserver | None = None,- ) -> AsyncIterator[str]:- return iter_responses_sse_from_anthropic(- chunks,- request,- on_post_start_terminal_failure=on_post_start_terminal_failure,- )-def error_payload(self, *, message: str, error_type: str) -> dict[str, Any]:return openai_error_payload(message=message, error_type=error_type)diff --git a/src/free_claude_code/core/openai_responses/anthropic_sse.py b/src/free_claude_code/core/openai_responses/anthropic_sse.pydeleted file mode 100644index 10f47943..00000000--- a/src/free_claude_code/core/openai_responses/anthropic_sse.py+++ /dev/null@@ -1,69 +0,0 @@-"""Anthropic SSE parsing used by the Responses stream adapter."""--import json-import sys-from collections.abc import AsyncIterable, AsyncIterator-from dataclasses import dataclass-from typing import Any--from free_claude_code.core.trace import close_stream_input---@dataclass(slots=True)-class AnthropicSseEvent:- event: str- data: dict[str, Any]---async def iter_sse_events(- chunks: AsyncIterable[Any],-) -> AsyncIterator[AnthropicSseEvent]:- buffer = ""- iterator = aiter(chunks)- try:- async for chunk in iterator:- if isinstance(chunk, bytes):- buffer += chunk.decode("utf-8", errors="replace")- else:- buffer += str(chunk)-- while "\n\n" in buffer:- raw, buffer = buffer.split("\n\n", 1)- event = parse_sse_event(raw)- if event is not None:- yield event-- if buffer.strip():- event = parse_sse_event(buffer)- if event is not None:- yield event- finally:- await close_stream_input(- iterator,- owner="openai_responses.anthropic_sse",- source="core",- preserved_error=sys.exception(),- )---def parse_sse_event(raw: str) -> AnthropicSseEvent | None:- event_type = ""- data_parts: list[str] = []- for line in raw.splitlines():- stripped = line.rstrip("\r")- if stripped.startswith("event:"):- event_type = stripped.split(":", 1)[1].strip()- elif stripped.startswith("data:"):- data_parts.append(stripped.split(":", 1)[1].strip())- if not event_type and not data_parts:- return None- data_text = "\n".join(data_parts)- if data_text == "[DONE]":- return None- try:- parsed = json.loads(data_text) if data_text else {}- except json.JSONDecodeError:- parsed = {"raw": data_text}- if not isinstance(parsed, dict):- parsed = {"value": parsed}- return AnthropicSseEvent(event=event_type, data=parsed)diff --git a/src/free_claude_code/core/openai_responses/presenter.py b/src/free_claude_code/core/openai_responses/presenter.pynew file mode 100644index 00000000..4cd6ac98--- /dev/null+++ b/src/free_claude_code/core/openai_responses/presenter.py@@ -0,0 +1,623 @@+"""Present canonical inference events through the OpenAI Responses protocol."""++import asyncio+import sys+import time+import uuid+from collections.abc import AsyncIterator, Callable, Mapping+from dataclasses import dataclass, field++from free_claude_code.core.diagnostics import safe_exception_message+from free_claude_code.core.failures import ExecutionFailure, find_execution_failure+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceUsage,+ ReasoningBlockCompleted,+ ReasoningBlockStarted,+ ReasoningDelta,+ ReplayArtifact,+ ReplayArtifactKind,+ ResponseCompleted,+ ResponseStarted,+ TextBlockCompleted,+ TextBlockStarted,+ TextDelta,+ ToolCallArgumentsDelta,+ ToolCallCompleted,+ ToolCallKind,+ ToolCallStarted,+ UsageUpdated,+ replay_payload_text,+)+from free_claude_code.core.json_types import JsonObject, JsonValue+from free_claude_code.core.token_estimation import estimate_text_tokens+from free_claude_code.core.trace import close_stream_input, trace_event++from .errors import (+ ResponsesConversionError,+ openai_error_from_failure,+ openai_error_payload,+)+from .ids import (+ new_call_id,+ new_message_item_id,+ new_reasoning_item_id,+ new_response_id,+)+from .models import OpenAIResponsesRequest+from .streaming.error_mapping import replay_unsafe_function_call_error+from .streaming.event_builders import ResponseEventBuilder+from .tools import (+ custom_tool_input_text_from_arguments,+ normalized_function_call_arguments,+ responses_tool_identity_from_anthropic_name,+)++PostStartTerminalFailureObserver = Callable[[BaseException], None]+++@dataclass(slots=True)+class _TextState:+ output_index: int+ item_id: str+ parts: list[str] = field(default_factory=list)+++@dataclass(slots=True)+class _ReasoningState:+ output_index: int+ item_id: str+ artifacts: tuple[ReplayArtifact, ...]+ parts: list[str] = field(default_factory=list)+++@dataclass(slots=True)+class _ToolState:+ output_index: int+ item_id: str+ call_id: str+ kind: ToolCallKind+ name: str+ namespace: str | None+ argument_parts: list[str] = field(default_factory=list)+++type _OutputState = _TextState | _ReasoningState | _ToolState+++class ResponsesEventPresenter:+ """Serialize one canonical stream while owning Responses envelope state."""++ def __init__(self, request: OpenAIResponsesRequest) -> None:+ self._request = request+ self._response_id = new_response_id()+ self._created_at = int(time.time())+ self._events = ResponseEventBuilder()+ self._blocks: dict[str, _OutputState] = {}+ self._output: list[JsonObject | None] = []+ self._usage = InferenceUsage()+ self._reasoning_tokens_estimate = 0+ self._provisional_error: JsonObject | None = None+ self.started = False+ self.terminal = False+ self.final_response: JsonObject | None = None++ def present(self, event: InferenceEvent) -> list[str]:+ if self.terminal:+ raise RuntimeError("canonical event arrived after response completion")+ if isinstance(event, ResponseStarted):+ return self._response_started(event)+ if not self.started:+ raise RuntimeError("canonical response must start before output")+ if isinstance(event, TextBlockStarted):+ return self._text_started(event)+ if isinstance(event, TextDelta):+ return self._text_delta(event)+ if isinstance(event, TextBlockCompleted):+ return self._text_completed(event)+ if isinstance(event, ReasoningBlockStarted):+ return self._reasoning_started(event)+ if isinstance(event, ReasoningDelta):+ return self._reasoning_delta(event)+ if isinstance(event, ReasoningBlockCompleted):+ return self._reasoning_completed(event)+ if isinstance(event, ToolCallStarted):+ return self._tool_started(event)+ if isinstance(event, ToolCallArgumentsDelta):+ return self._tool_delta(event)+ if isinstance(event, ToolCallCompleted):+ return self._tool_completed(event)+ if isinstance(event, UsageUpdated):+ self._usage = event.usage+ return []+ return self._response_completed(event)++ def response_payload(+ self,+ *,+ status: str,+ error: JsonObject | None = None,+ incomplete_details: JsonObject | None = None,+ ) -> JsonObject:+ return {+ "id": self._response_id,+ "object": "response",+ "created_at": self._created_at,+ "status": status,+ "model": self._request.model,+ "output": [item for item in self._output if item is not None],+ "parallel_tool_calls": (+ True+ if self._request.parallel_tool_calls is None+ else self._request.parallel_tool_calls+ ),+ "tool_choice": _json_value(+ "auto"+ if self._request.tool_choice is None+ else self._request.tool_choice+ ),+ "temperature": self._request.temperature,+ "top_p": self._request.top_p,+ "max_output_tokens": self._request.max_output_tokens,+ "usage": _responses_usage(+ self._usage,+ reasoning_estimate=self._reasoning_tokens_estimate,+ ),+ "error": error,+ "incomplete_details": incomplete_details,+ }++ def fail_execution(self, failure: ExecutionFailure) -> list[str]:+ return self._finish_failed(_json_object(openai_error_from_failure(failure)))++ def fail_unexpected(self, exc: BaseException) -> list[str]:+ payload = openai_error_payload(+ message=safe_exception_message(exc),+ error_type="api_error",+ )["error"]+ return self._finish_failed(_json_object(payload))++ def _response_started(self, event: ResponseStarted) -> list[str]:+ if self.started:+ raise RuntimeError("canonical response started more than once")+ self.started = True+ self._usage = event.initial_usage+ return [+ self._events.response_created(self.response_payload(status="in_progress"))+ ]++ def _text_started(self, event: TextBlockStarted) -> list[str]:+ output_index = self._reserve_output()+ state = _TextState(output_index, new_message_item_id())+ self._set_block(event.block_id, state)+ item: JsonObject = {+ "id": state.item_id,+ "type": "message",+ "status": "in_progress",+ "role": "assistant",+ "content": [],+ }+ return [+ self._events.output_item_added(output_index, item),+ self._events.content_part_added(state.item_id, output_index),+ ]++ def _text_delta(self, event: TextDelta) -> list[str]:+ state = self._require_block(event.block_id, _TextState)+ if not event.delta:+ return []+ state.parts.append(event.delta)+ return [+ self._events.output_text_delta(+ state.item_id, state.output_index, event.delta+ )+ ]++ def _text_completed(self, event: TextBlockCompleted) -> list[str]:+ state = self._pop_block(event.block_id, _TextState)+ text = event.text+ item = _message_item(state.item_id, text, "completed")+ self._commit_output(state.output_index, item)+ return [+ self._events.output_text_done(state.item_id, state.output_index, text),+ self._events.content_part_done(state.item_id, state.output_index, text),+ self._events.output_item_done(state.output_index, item),+ ]++ def _reasoning_started(self, event: ReasoningBlockStarted) -> list[str]:+ output_index = self._reserve_output()+ state = _ReasoningState(+ output_index,+ new_reasoning_item_id(),+ event.artifacts,+ )+ self._set_block(event.block_id, state)+ return [+ self._events.output_item_added(+ output_index,+ _reasoning_item(state, status="in_progress"),+ )+ ]++ def _reasoning_delta(self, event: ReasoningDelta) -> list[str]:+ state = self._require_block(event.block_id, _ReasoningState)+ if not event.delta:+ return []+ state.parts.append(event.delta)+ return [+ self._events.reasoning_text_delta(+ state.item_id, state.output_index, event.delta+ )+ ]++ def _reasoning_completed(self, event: ReasoningBlockCompleted) -> list[str]:+ state = self._pop_block(event.block_id, _ReasoningState)+ state.artifacts = event.artifacts+ text = event.reasoning+ item = _reasoning_item(state, status="completed", text=text)+ self._commit_output(state.output_index, item)+ chunks: list[str] = []+ if text:+ self._reasoning_tokens_estimate += estimate_text_tokens(text)+ chunks.append(+ self._events.reasoning_text_done(+ state.item_id,+ state.output_index,+ text,+ )+ )+ chunks.append(self._events.output_item_done(state.output_index, item))+ return chunks++ def _tool_started(self, event: ToolCallStarted) -> list[str]:+ identity = responses_tool_identity_from_anthropic_name(+ self._request.tools,+ event.name,+ )+ kind = (+ ToolCallKind.CUSTOM+ if event.kind is ToolCallKind.CUSTOM or identity.kind == "custom"+ else ToolCallKind.FUNCTION+ )+ state = _ToolState(+ output_index=self._reserve_output(),+ item_id=f"{'ctc' if kind is ToolCallKind.CUSTOM else 'fc'}_"+ f"{uuid.uuid4().hex[:24]}",+ call_id=event.call_id or new_call_id(),+ kind=kind,+ name=identity.name if identity.name else event.name,+ namespace=identity.namespace or event.namespace,+ )+ self._set_block(event.block_id, state)+ return [+ self._events.output_item_added(+ state.output_index,+ _tool_item(state, status="in_progress"),+ )+ ]++ def _tool_delta(self, event: ToolCallArgumentsDelta) -> list[str]:+ state = self._require_block(event.block_id, _ToolState)+ state.argument_parts.append(event.delta)+ return []++ def _tool_completed(self, event: ToolCallCompleted) -> list[str]:+ state = self._pop_block(event.block_id, _ToolState)+ arguments = event.arguments+ if state.kind is ToolCallKind.CUSTOM:+ return self._complete_custom_tool(state, arguments)+ try:+ normalized = normalized_function_call_arguments(arguments or "{}")+ except ResponsesConversionError as exc:+ trace_event(+ stage="responses",+ event="responses.output.function_call_invalid_arguments",+ source="openai_responses",+ call_id=state.call_id,+ tool_name=state.name,+ error_type=type(exc).__name__,+ )+ self._provisional_error = _json_object(replay_unsafe_function_call_error())+ return []+ item = _tool_item(state, status="completed", arguments=normalized)+ self._commit_output(state.output_index, item)+ chunks: list[str] = []+ if normalized:+ chunks.append(+ self._events.function_call_arguments_delta(+ state.item_id,+ state.output_index,+ normalized,+ )+ )+ chunks.extend(+ [+ self._events.function_call_arguments_done(+ state.item_id,+ state.output_index,+ normalized,+ ),+ self._events.output_item_done(state.output_index, item),+ ]+ )+ return chunks++ def _complete_custom_tool(self, state: _ToolState, arguments: str) -> list[str]:+ input_text = custom_tool_input_text_from_arguments(arguments)+ item = _tool_item(state, status="completed", input_text=input_text)+ self._commit_output(state.output_index, item)+ chunks: list[str] = []+ if input_text:+ chunks.append(+ self._events.custom_tool_call_input_delta(+ state.item_id,+ state.output_index,+ input_text,+ )+ )+ chunks.extend(+ [+ self._events.custom_tool_call_input_done(+ state.item_id,+ state.output_index,+ input_text,+ ),+ self._events.output_item_done(state.output_index, item),+ ]+ )+ return chunks++ def _response_completed(self, event: ResponseCompleted) -> list[str]:+ if self._blocks:+ raise RuntimeError("canonical response completed with open output blocks")+ self._usage = event.final_usage+ if self._provisional_error is not None:+ return self._finish_failed(self._provisional_error)+ if event.finish_reason is FinishReason.OUTPUT_LIMIT:+ self.final_response = self.response_payload(+ status="incomplete",+ incomplete_details={"reason": "max_output_tokens"},+ )+ self.terminal = True+ return [self._events.response_incomplete(self.final_response)]+ self.final_response = self.response_payload(status="completed")+ self.terminal = True+ return [self._events.response_completed(self.final_response)]++ def _finish_failed(self, error: JsonObject) -> list[str]:+ if self.terminal:+ return []+ self._blocks.clear()+ self._provisional_error = None+ self.final_response = self.response_payload(status="failed", error=error)+ self.terminal = True+ return [self._events.response_failed(self.final_response)]++ def _set_block(self, block_id: str, state: _OutputState) -> None:+ if block_id in self._blocks:+ raise RuntimeError("canonical block started more than once")+ self._blocks[block_id] = state++ def _require_block[State: _OutputState](+ self, block_id: str, expected: type[State]+ ) -> State:+ state = self._blocks.get(block_id)+ if not isinstance(state, expected):+ raise RuntimeError("canonical delta targeted an unknown output block")+ return state++ def _pop_block[State: _OutputState](+ self, block_id: str, expected: type[State]+ ) -> State:+ state = self._require_block(block_id, expected)+ del self._blocks[block_id]+ return state++ def _reserve_output(self) -> int:+ index = len(self._output)+ self._output.append(None)+ return index++ def _commit_output(self, output_index: int, item: JsonObject) -> None:+ self._output[output_index] = item+++async def iter_responses_sse_from_events(+ events: AsyncIterator[InferenceEvent],+ request: OpenAIResponsesRequest,+ *,+ on_post_start_terminal_failure: PostStartTerminalFailureObserver | None = None,+) -> AsyncIterator[str]:+ """Serialize canonical events and map only post-start failures to wire events."""++ presenter = ResponsesEventPresenter(request)+ emitted_any = False+ try:+ async for event in events:+ for chunk in presenter.present(event):+ emitted_any = True+ yield chunk+ if not presenter.terminal:+ raise RuntimeError(+ "canonical provider stream ended without response completion"+ )+ except GeneratorExit:+ raise+ except asyncio.CancelledError:+ raise+ except BaseExceptionGroup as exc:+ if not emitted_any:+ raise+ failure = find_execution_failure(exc)+ observed = failure or exc+ _observe(on_post_start_terminal_failure, observed)+ chunks = (+ presenter.fail_execution(failure)+ if failure is not None+ else presenter.fail_unexpected(exc)+ )+ for chunk in chunks:+ yield chunk+ except Exception as exc:+ if not emitted_any:+ raise+ failure = find_execution_failure(exc)+ observed = failure or exc+ _observe(on_post_start_terminal_failure, observed)+ chunks = (+ presenter.fail_execution(failure)+ if failure is not None+ else presenter.fail_unexpected(exc)+ )+ for chunk in chunks:+ yield chunk+ finally:+ await close_stream_input(+ events,+ owner="responses_event_presenter",+ source="core",+ preserved_error=sys.exception(),+ )+++def _observe(+ observer: PostStartTerminalFailureObserver | None,+ exc: BaseException,+) -> None:+ if observer is not None:+ observer(exc)+++def _message_item(item_id: str, text: str, status: str) -> JsonObject:+ return {+ "id": item_id,+ "type": "message",+ "status": status,+ "role": "assistant",+ "content": [{"type": "output_text", "text": text, "annotations": []}],+ }+++def _reasoning_item(+ state: _ReasoningState,+ *,+ status: str,+ text: str = "",+) -> JsonObject:+ encrypted = _encrypted_reasoning(state.artifacts)+ if encrypted is not None:+ return {+ "id": state.item_id,+ "type": "reasoning",+ "status": status,+ "summary": [],+ "encrypted_content": encrypted,+ }+ return {+ "id": state.item_id,+ "type": "reasoning",+ "status": status,+ "summary": [],+ "content": [{"type": "reasoning_text", "text": text}],+ }+++def _encrypted_reasoning(+ artifacts: tuple[ReplayArtifact, ...],+) -> str | None:+ for artifact in artifacts:+ if artifact.kind in {+ ReplayArtifactKind.REDACTED_THINKING,+ ReplayArtifactKind.ENCRYPTED_REASONING,+ ReplayArtifactKind.REASONING_DETAILS,+ }:+ return replay_payload_text(artifact)+ return None+++def _tool_item(+ state: _ToolState,+ *,+ status: str,+ arguments: str = "",+ input_text: str = "",+) -> JsonObject:+ if state.kind is ToolCallKind.CUSTOM:+ item: JsonObject = {+ "id": state.item_id,+ "type": "custom_tool_call",+ "status": status,+ "call_id": state.call_id,+ "name": state.name,+ "input": input_text,+ }+ else:+ item = {+ "id": state.item_id,+ "type": "function_call",+ "status": status,+ "call_id": state.call_id,+ "name": state.name,+ "arguments": arguments,+ }+ if state.namespace:+ item["namespace"] = state.namespace+ return item+++def _responses_usage(+ usage: InferenceUsage,+ *,+ reasoning_estimate: int,+) -> JsonObject | None:+ values = (+ usage.input_tokens,+ usage.cache_read_input_tokens,+ usage.cache_creation_input_tokens,+ usage.output_tokens,+ )+ if all(value is None for value in values):+ return None+ input_tokens = sum(+ value.value+ for value in (+ usage.input_tokens,+ usage.cache_read_input_tokens,+ usage.cache_creation_input_tokens,+ )+ if value is not None+ )+ output_tokens = usage.output_tokens.value if usage.output_tokens else 0+ reasoning_tokens = (+ usage.reasoning_output_tokens.value+ if usage.reasoning_output_tokens is not None+ else min(reasoning_estimate, output_tokens)+ )+ return {+ "input_tokens": input_tokens,+ "input_tokens_details": {+ "cached_tokens": (+ usage.cache_read_input_tokens.value+ if usage.cache_read_input_tokens is not None+ else 0+ )+ },+ "output_tokens": output_tokens,+ "output_tokens_details": {"reasoning_tokens": reasoning_tokens},+ "total_tokens": input_tokens + output_tokens,+ }+++def _json_object(value: Mapping[str, object]) -> JsonObject:+ return {str(key): _json_value(item) for key, item in value.items()}+++def _json_value(value: object) -> JsonValue:+ if isinstance(value, Mapping):+ return {str(key): _json_value(item) for key, item in value.items()}+ if isinstance(value, list | tuple):+ return [_json_value(item) for item in value]+ if isinstance(value, bool | int | float | str) or value is None:+ return value+ return str(value)diff --git a/src/free_claude_code/core/openai_responses/provider_stream.py b/src/free_claude_code/core/openai_responses/provider_events.pysimilarity index 60%rename from src/free_claude_code/core/openai_responses/provider_stream.pyrename to src/free_claude_code/core/openai_responses/provider_events.pyindex 960c5411..21307737 100644--- a/src/free_claude_code/core/openai_responses/provider_stream.py+++ b/src/free_claude_code/core/openai_responses/provider_events.py@@ -1,10 +1,21 @@-"""Translate upstream OpenAI Responses events into Anthropic Messages SSE."""+"""Decode upstream OpenAI Responses events into canonical inference events."""+from collections.abc import Mappingfrom dataclasses import dataclass-from typing import Anyfrom free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodec-from free_claude_code.core.anthropic.streaming import AnthropicStreamLedger+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+ InferenceUsage,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ TokenMeasurement,+ UsageSource,+)class ResponsesStreamFailure(RuntimeError):@@ -26,38 +37,28 @@ class _ToolState:stopped: bool = False-class ResponsesProviderStream:- """Stateful one-way adapter for one upstream response."""+class ResponsesEventDecoder:+ """Decode one upstream Responses stream without assigning public wire IDs."""def __init__(self,*,- message_id: str,+ response_id: str,model: str,input_tokens: int,- log_raw_events: bool = False,tool_names: OpenAIToolNameCodec | None = None,) -> None:- self.ledger = AnthropicStreamLedger(- message_id,- model,- input_tokens,- log_raw_events=log_raw_events,- )+ self.ledger = InferenceStreamLedger(response_id, model, input_tokens)self.completed = Falseself.generated_output = Falseself._tool_names = tool_names or OpenAIToolNameCodec.from_names(())self._tools: dict[str, _ToolState] = {}self._encrypted_reasoning: dict[str, str] = {}- def start(self) -> list[str]:- """Return the Anthropic message_start event."""-- return [self.ledger.message_start()]-- def feed(self, event_type: str, data: dict[str, Any]) -> list[str]:- """Consume one Responses event and return zero or more Anthropic events."""+ def start(self) -> list[InferenceEvent]:+ return [self.ledger.start_response()]+ def feed(self, event_type: str, data: Mapping[str, object]) -> list[InferenceEvent]:if self.completed:return []if event_type == "response.output_item.added":@@ -79,7 +80,7 @@ class ResponsesProviderStream:raise _stream_failure(data)return []- def _item_added(self, data: dict[str, Any]) -> list[str]:+ def _item_added(self, data: Mapping[str, object]) -> list[InferenceEvent]:item = data.get("item")if not isinstance(item, dict):return []@@ -96,16 +97,16 @@ class ResponsesProviderStream:self._encrypted_reasoning[item_id] = encryptedreturn []- def _reasoning_delta(self, data: dict[str, Any]) -> list[str]:+ def _reasoning_delta(self, data: Mapping[str, object]) -> list[InferenceEvent]:delta = data.get("delta")if not isinstance(delta, str) or not delta:return []- events = list(self.ledger.ensure_thinking_block())- events.append(self.ledger.emit_thinking_delta(delta))+ events = list(self.ledger.ensure_reasoning_block())+ events.append(self.ledger.emit_reasoning_delta(delta))self.generated_output = Truereturn events- def _text_delta(self, data: dict[str, Any]) -> list[str]:+ def _text_delta(self, data: Mapping[str, object]) -> list[InferenceEvent]:delta = data.get("delta")if not isinstance(delta, str) or not delta:return []@@ -114,7 +115,7 @@ class ResponsesProviderStream:self.generated_output = Truereturn events- def _tool_delta(self, data: dict[str, Any]) -> list[str]:+ def _tool_delta(self, data: Mapping[str, object]) -> list[InferenceEvent]:item_id = _string(data.get("item_id"))delta = data.get("delta")if not item_id or not isinstance(delta, str):@@ -135,7 +136,7 @@ class ResponsesProviderStream:self.generated_output = Truereturn events- def _item_done(self, data: dict[str, Any]) -> list[str]:+ def _item_done(self, data: Mapping[str, object]) -> list[InferenceEvent]:item = data.get("item")if not isinstance(item, dict):return []@@ -161,26 +162,28 @@ class ResponsesProviderStream:if not state.stopped:events.append(self.ledger.stop_tool_block(state.tool_index))state.stopped = True- self.ledger.blocks.tool_states[state.tool_index].started = Falsereturn eventsif item_type == "reasoning":+ events = list(self.ledger.close_content_blocks())encrypted = item.get("encrypted_content")if not isinstance(encrypted, str) or not encrypted:encrypted = self._encrypted_reasoning.get(item_id)if isinstance(encrypted, str) and encrypted:- events = list(self.ledger.close_content_blocks())- index = self.ledger.blocks.allocate_index()- events.append(- self.ledger.content_block_start(- index, "redacted_thinking", data=encrypted+ events.extend(+ self.ledger.emit_reasoning_artifact(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload=encrypted,+ )))- events.append(self.ledger.content_block_stop(index))self.generated_output = True- return events+ return eventsreturn []- def _ensure_tool_started(self, state: _ToolState) -> list[str]:+ def _ensure_tool_started(self, state: _ToolState) -> list[InferenceEvent]:if state.started:return []state.started = True@@ -193,7 +196,9 @@ class ResponsesProviderStream:)]- def _finish(self, data: dict[str, Any], *, incomplete: bool) -> list[str]:+ def _finish(+ self, data: Mapping[str, object], *, incomplete: bool+ ) -> list[InferenceEvent]:response = data.get("response")response = response if isinstance(response, dict) else {}events = list(self.ledger.close_all_blocks())@@ -201,39 +206,77 @@ class ResponsesProviderStream:events.extend(self.ledger.ensure_text_block())events.append(self.ledger.emit_text_delta(" "))events.append(self.ledger.stop_text_block())- usage = response.get("usage")- usage = usage if isinstance(usage, dict) else {}- input_tokens = _integer(usage.get("input_tokens"))- output_tokens = _integer(usage.get("output_tokens"))- details = usage.get("input_tokens_details")- details = details if isinstance(details, dict) else {}- cached_tokens = _integer(details.get("cached_tokens"))- usage_fields = None- if (- input_tokens is not None- and input_tokens >= 0- and cached_tokens is not None- and 0 <= cached_tokens <= input_tokens- ):- input_tokens -= cached_tokens- usage_fields = {"cache_read_input_tokens": cached_tokens}- stop_reason = "max_tokens" if incomplete else "end_turn"- events.append(- self.ledger.message_delta(- self.ledger.final_stop_reason(stop_reason),- output_tokens- if output_tokens is not None- else self.ledger.estimate_output_tokens(),- input_tokens=input_tokens,- usage_fields=usage_fields,++ usage = _response_usage(response, self.ledger)+ events.extend(+ self.ledger.finish_events(+ FinishReason.OUTPUT_LIMIT if incomplete else FinishReason.END_TURN,+ usage,))- events.append(self.ledger.message_stop())self.completed = Truereturn events-def _stream_failure(data: dict[str, Any]) -> ResponsesStreamFailure:+def _response_usage(+ response: Mapping[str, object], ledger: InferenceStreamLedger+) -> InferenceUsage:+ raw_usage = response.get("usage")+ raw_usage = raw_usage if isinstance(raw_usage, dict) else {}+ input_tokens = _integer(raw_usage.get("input_tokens"))+ output_tokens = _integer(raw_usage.get("output_tokens"))++ input_details = raw_usage.get("input_tokens_details")+ input_details = input_details if isinstance(input_details, dict) else {}+ cached_tokens = _integer(input_details.get("cached_tokens"))+ if input_tokens is None:+ cached_tokens = None+ if (+ input_tokens is not None+ and cached_tokens is not None+ and (cached_tokens < 0 or cached_tokens > input_tokens)+ ):+ cached_tokens = None+ uncached_tokens = (+ input_tokens - cached_tokens+ if input_tokens is not None and cached_tokens is not None+ else input_tokens+ )++ output_details = raw_usage.get("output_tokens_details")+ output_details = output_details if isinstance(output_details, dict) else {}+ reasoning_tokens = _integer(output_details.get("reasoning_tokens"))+ estimated_reasoning = ledger.estimate_reasoning_tokens()++ return InferenceUsage(+ input_tokens=_measurement(+ uncached_tokens,+ fallback=ledger.input_tokens,+ ),+ cache_read_input_tokens=(+ TokenMeasurement(cached_tokens, UsageSource.REPORTED)+ if cached_tokens is not None+ else None+ ),+ output_tokens=_measurement(+ output_tokens,+ fallback=ledger.estimate_output_tokens(),+ ),+ reasoning_output_tokens=(+ TokenMeasurement(reasoning_tokens, UsageSource.REPORTED)+ if reasoning_tokens is not None+ else TokenMeasurement(estimated_reasoning, UsageSource.ESTIMATED)+ ),+ )+++def _measurement(value: int | None, *, fallback: int) -> TokenMeasurement:+ if value is not None and value >= 0:+ return TokenMeasurement(value, UsageSource.REPORTED)+ return TokenMeasurement(max(fallback, 0), UsageSource.ESTIMATED)+++def _stream_failure(data: Mapping[str, object]) -> ResponsesStreamFailure:response = data.get("response")response = response if isinstance(response, dict) else {}error = response.get("error", data.get("error"))@@ -246,9 +289,9 @@ def _stream_failure(data: dict[str, Any]) -> ResponsesStreamFailure:)-def _string(value: Any) -> str:+def _string(value: object) -> str:return value if isinstance(value, str) else ""-def _integer(value: Any) -> int | None:+def _integer(value: object) -> int | None:return value if isinstance(value, int) and not isinstance(value, bool) else Nonediff --git a/src/free_claude_code/core/openai_responses/stream.py b/src/free_claude_code/core/openai_responses/stream.pydeleted file mode 100644index 833c31e1..00000000--- a/src/free_claude_code/core/openai_responses/stream.py+++ /dev/null@@ -1,92 +0,0 @@-"""Translate Anthropic SSE streams into OpenAI Responses SSE streams."""--import asyncio-import sys-from collections.abc import AsyncIterable, AsyncIterator, Callable-from typing import Any--from free_claude_code.core.diagnostics import safe_exception_message-from free_claude_code.core.failures import ExecutionFailure, find_execution_failure-from free_claude_code.core.trace import close_stream_input--from .anthropic_sse import iter_sse_events-from .models import OpenAIResponsesRequest-from .streaming import ResponsesStreamAssembler--PostStartTerminalFailureObserver = Callable[[BaseException], None]---async def iter_responses_sse_from_anthropic(- chunks: AsyncIterable[Any],- request: OpenAIResponsesRequest,- *,- on_post_start_terminal_failure: PostStartTerminalFailureObserver | None = None,-) -> AsyncIterator[str]:- """Yield Responses SSE events translated from an Anthropic SSE stream."""- assembler = ResponsesStreamAssembler(request)- emitted_any_chunk = False- events = iter_sse_events(chunks)- try:- async for event in events:- for chunk in assembler.process_anthropic_event(event):- yield chunk- emitted_any_chunk = True- if assembler.terminal:- return- for chunk in assembler.finish_if_needed():- yield chunk- emitted_any_chunk = True- except GeneratorExit:- raise- except asyncio.CancelledError:- raise- except ExecutionFailure as exc:- if not emitted_any_chunk:- raise- _observe_post_start_terminal_failure(on_post_start_terminal_failure, exc)- for chunk in assembler.fail_execution(exc):- yield chunk- except BaseExceptionGroup as exc:- if not emitted_any_chunk:- raise- failure = find_execution_failure(exc)- if failure is not None:- _observe_post_start_terminal_failure(- on_post_start_terminal_failure, failure- )- for chunk in assembler.fail_execution(failure):- yield chunk- else:- _observe_post_start_terminal_failure(on_post_start_terminal_failure, exc)- for chunk in assembler.fail_response(_unexpected_error_data(exc)):- yield chunk- except Exception as exc:- if not emitted_any_chunk:- raise- _observe_post_start_terminal_failure(on_post_start_terminal_failure, exc)- for chunk in assembler.fail_response(_unexpected_error_data(exc)):- yield chunk- finally:- await close_stream_input(- events,- owner="openai_responses.stream",- source="core",- preserved_error=sys.exception(),- )---def _observe_post_start_terminal_failure(- observer: PostStartTerminalFailureObserver | None,- exc: BaseException,-) -> None:- if observer is not None:- observer(exc)---def _unexpected_error_data(exc: BaseException) -> dict[str, dict[str, str]]:- return {- "error": {- "type": "api_error",- "message": safe_exception_message(exc),- }- }diff --git a/src/free_claude_code/core/openai_responses/streaming/__init__.py b/src/free_claude_code/core/openai_responses/streaming/__init__.pyindex fc3056aa..bc89cf0a 100644--- a/src/free_claude_code/core/openai_responses/streaming/__init__.py+++ b/src/free_claude_code/core/openai_responses/streaming/__init__.py@@ -1,5 +1 @@-"""OpenAI Responses streaming assembly internals."""--from .assembler import ResponsesStreamAssembler--__all__ = ["ResponsesStreamAssembler"]+"""OpenAI Responses wire-event formatting helpers."""diff --git a/src/free_claude_code/core/openai_responses/streaming/assembler.py b/src/free_claude_code/core/openai_responses/streaming/assembler.pydeleted file mode 100644index 557c774a..00000000--- a/src/free_claude_code/core/openai_responses/streaming/assembler.py+++ /dev/null@@ -1,386 +0,0 @@-"""Anthropic SSE to OpenAI Responses stream assembly."""--import json-import time-import uuid-from collections.abc import Mapping-from typing import Any--from free_claude_code.core.failures import ExecutionFailure-from free_claude_code.core.trace import trace_event--from ..anthropic_sse import AnthropicSseEvent-from ..errors import ResponsesConversionError, openai_error_from_failure-from ..ids import (- new_call_id,- new_message_item_id,- new_reasoning_item_id,- new_response_id,-)-from ..models import OpenAIResponsesRequest-from ..tools import responses_tool_identity_from_anthropic_name-from .blocks import ReasoningBlockState, TextBlockState, ToolBlockState-from .completion import ResponseBlockCompleter, reasoning_output_item, tool_item-from .error_mapping import (- openai_error_from_anthropic_error,- replay_unsafe_function_call_error,-)-from .event_builders import ResponseEventBuilder-from .ledger import ResponsesOutputLedger---class ResponsesStreamAssembler:- """Assemble Responses SSE events from indexed Anthropic content blocks."""-- def __init__(self, request: OpenAIResponsesRequest) -> None:- self._request = request- self._response_id = new_response_id()- self._created_at = int(time.time())- self._ledger = ResponsesOutputLedger()- self._events = ResponseEventBuilder()- self._completer = ResponseBlockCompleter(- self._ledger,- events=self._events,- on_invalid_function_call=self._fail_invalid_function_call,- )- self._started = False- self._stop_reason: str | None = None- self._provisional_error: dict[str, Any] | None = None- self.terminal = False- self.final_response: dict[str, Any] | None = None-- def process_anthropic_event(self, event: AnthropicSseEvent) -> list[str]:- if self.terminal:- return []-- chunks = self._ensure_started()- if event.event == "content_block_start":- chunks.extend(self._handle_content_block_start(event.data))- elif event.event == "content_block_delta":- chunks.extend(self._handle_content_block_delta(event.data))- elif event.event == "content_block_stop":- chunks.extend(self._handle_content_block_stop(event.data))- elif event.event == "message_delta":- self._record_message_delta(event.data)- elif event.event == "message_stop":- chunks.extend(self.finish_response())- elif event.event == "error":- chunks.extend(self.fail_response(event.data))- return chunks-- def finish_if_needed(self) -> list[str]:- if self.terminal:- return []- chunks = self._ensure_started()- chunks.extend(self.finish_response())- return chunks-- def response_payload(- self,- *,- status: str,- error: dict[str, Any] | None = None,- incomplete_details: dict[str, str] | None = None,- ) -> dict[str, Any]:- return {- "id": self._response_id,- "object": "response",- "created_at": self._created_at,- "status": status,- "model": self._request.model,- "output": self._ledger.output(),- "parallel_tool_calls": (- True- if self._request.parallel_tool_calls is None- else self._request.parallel_tool_calls- ),- "tool_choice": (- "auto"- if self._request.tool_choice is None- else self._request.tool_choice- ),- "temperature": self._request.temperature,- "top_p": self._request.top_p,- "max_output_tokens": self._request.max_output_tokens,- "usage": self._ledger.usage(),- "error": error,- "incomplete_details": incomplete_details,- }-- def finish_response(self) -> list[str]:- chunks = self._flush_active_blocks()- if self.terminal:- return chunks- if self._provisional_error is not None:- chunks.extend(self._finish_failed_response(self._provisional_error))- return chunks- if self._stop_reason == "max_tokens":- chunks.extend(self._finish_incomplete_response())- return chunks- self.final_response = self.response_payload(status="completed")- chunks.append(self._events.response_completed(self.final_response))- self.terminal = True- return chunks-- def fail_response(self, data: Mapping[str, Any]) -> list[str]:- chunks = self._flush_active_blocks()- if self.terminal:- return chunks- error = openai_error_from_anthropic_error(data)- chunks.extend(self._finish_failed_response(error))- return chunks-- def fail_execution(self, failure: ExecutionFailure) -> list[str]:- """Finish the current response with a canonical execution failure."""- chunks = self._flush_active_blocks()- if self.terminal:- return chunks- chunks.extend(self._finish_failed_response(openai_error_from_failure(failure)))- return chunks-- def _finish_failed_response(self, error: dict[str, Any]) -> list[str]:- self._provisional_error = None- self.final_response = self.response_payload(status="failed", error=error)- self.terminal = True- return [self._events.response_failed(self.final_response)]-- def _finish_incomplete_response(self) -> list[str]:- self.final_response = self.response_payload(- status="incomplete",- incomplete_details={"reason": "max_output_tokens"},- )- self.terminal = True- return [self._events.response_incomplete(self.final_response)]-- def _ensure_started(self) -> list[str]:- if self._started:- return []- self._started = True- return [- self._events.response_created(self.response_payload(status="in_progress"))- ]-- def _handle_content_block_start(self, data: Mapping[str, Any]) -> list[str]:- block = data.get("content_block")- if not isinstance(block, dict):- return []- block_type = block.get("type")- index = _event_index(data)- if block_type == "text":- index = self._ledger.safe_text_index(index)- chunks, state = self._start_text_block(index)- if state is None:- return chunks- if text := _string_value(block.get("text")):- chunks.extend(self._emit_text_delta(state, text))- return chunks- if block_type == "thinking":- if index is None:- return []- chunks, state = self._start_reasoning_block(index)- if state is None:- return chunks- if text := _string_value(block.get("thinking")):- chunks.extend(self._emit_reasoning_delta(state, text))- return chunks- if block_type == "redacted_thinking":- if index is None:- return []- chunks, _state = self._start_reasoning_block(- index, encrypted_content=_string_value(block.get("data"))- )- return chunks- if block_type == "tool_use":- if index is None:- return []- return self._start_tool_block(index, block)- return []-- def _handle_content_block_delta(self, data: Mapping[str, Any]) -> list[str]:- delta = data.get("delta")- if not isinstance(delta, dict):- return []- delta_type = delta.get("type")- index = _event_index(data)- if delta_type == "text_delta":- index = self._ledger.safe_text_index(index)- state = self._ledger.active_block(index)- chunks: list[str] = []- if not isinstance(state, TextBlockState):- chunks, state = self._start_text_block(index)- if state is None:- return chunks- chunks.extend(- self._emit_text_delta(state, _string_value(delta.get("text")))- )- return chunks- if delta_type == "thinking_delta":- if index is None:- return []- state = self._ledger.active_block(index)- chunks = []- if not isinstance(state, ReasoningBlockState):- chunks, state = self._start_reasoning_block(index)- if state is None:- return chunks- chunks.extend(- self._emit_reasoning_delta(state, _string_value(delta.get("thinking")))- )- return chunks- if delta_type == "input_json_delta":- state = self._ledger.active_block(index) if index is not None else None- if isinstance(state, ToolBlockState):- state.argument_parts.append(_string_value(delta.get("partial_json")))- return []-- def _handle_content_block_stop(self, data: Mapping[str, Any]) -> list[str]:- index = _event_index(data)- if index is None:- return []- state = self._ledger.pop_active_block(index)- if state is None:- return []- return self._completer.complete_block(state)-- def _record_message_delta(self, data: Mapping[str, Any]) -> None:- self._ledger.record_usage_delta(data)- delta = data.get("delta")- if not isinstance(delta, Mapping):- return- stop_reason = delta.get("stop_reason")- if isinstance(stop_reason, str):- self._stop_reason = stop_reason-- def _start_text_block(self, index: int) -> tuple[list[str], TextBlockState | None]:- chunks = self._complete_existing_block(index)- if self.terminal:- return chunks, None- output_index = self._ledger.reserve_output_slot()- state = TextBlockState(- index=index,- output_index=output_index,- item_id=new_message_item_id(),- )- self._ledger.set_active_block(state)- item = {- "id": state.item_id,- "type": "message",- "status": "in_progress",- "role": "assistant",- "content": [],- }- chunks.extend(- [- self._events.output_item_added(output_index, item),- self._events.content_part_added(state.item_id, output_index),- ]- )- return chunks, state-- def _start_reasoning_block(- self, index: int, *, encrypted_content: str | None = None- ) -> tuple[list[str], ReasoningBlockState | None]:- chunks = self._complete_existing_block(index)- if self.terminal:- return chunks, None- output_index = self._ledger.reserve_output_slot()- state = ReasoningBlockState(- index=index,- output_index=output_index,- item_id=new_reasoning_item_id(),- encrypted_content=encrypted_content,- )- self._ledger.set_active_block(state)- chunks.append(- self._events.output_item_added(- output_index,- reasoning_output_item(state, status="in_progress"),- )- )- return chunks, state-- def _start_tool_block(self, index: int, block: Mapping[str, Any]) -> list[str]:- chunks = self._complete_existing_block(index)- if self.terminal:- return chunks- identity = responses_tool_identity_from_anthropic_name(- self._request.tools, _string_value(block.get("name"))- )- state = ToolBlockState(- index=index,- output_index=self._ledger.reserve_output_slot(),- item_id=f"{'ctc' if identity.kind == 'custom' else 'fc'}_"- f"{uuid.uuid4().hex[:24]}",- call_id=_string_value(block.get("id")) or new_call_id(),- kind=identity.kind,- name=identity.name,- namespace=identity.namespace,- )- initial_input = block.get("input")- if (identity.kind == "custom" and initial_input not in (None, {}, "")) or (- isinstance(initial_input, dict) and initial_input- ):- state.argument_parts.append(json.dumps(initial_input))- self._ledger.set_active_block(state)- chunks.append(- self._events.output_item_added(- state.output_index,- tool_item(state, status="in_progress"),- )- )- return chunks-- def _emit_text_delta(self, state: TextBlockState, text: str) -> list[str]:- if not text:- return []- state.text_parts.append(text)- return [self._events.output_text_delta(state.item_id, state.output_index, text)]-- def _emit_reasoning_delta(self, state: ReasoningBlockState, text: str) -> list[str]:- if not text:- return []- state.text_parts.append(text)- return [- self._events.reasoning_text_delta(state.item_id, state.output_index, text)- ]-- def _complete_existing_block(self, index: int) -> list[str]:- existing = self._ledger.pop_active_block(index)- if existing is None:- return []- return self._completer.complete_block(existing)-- def _flush_active_blocks(self) -> list[str]:- chunks: list[str] = []- for state in self._ledger.pop_active_blocks_by_output_order():- if self.terminal:- break- chunks.extend(self._completer.complete_block(state))- return chunks-- def _fail_invalid_function_call(- self, state: ToolBlockState, exc: ResponsesConversionError- ) -> list[str]:- trace_event(- stage="responses",- event="responses.output.function_call_invalid_arguments",- source="openai_responses",- call_id=state.call_id,- tool_name=state.name,- error_type=type(exc).__name__,- )- error = replay_unsafe_function_call_error()- if self._provisional_error is None:- self._provisional_error = error- return []---def _event_index(data: Mapping[str, Any]) -> int | None:- value = data.get("index")- return value if isinstance(value, int) else None---def _string_value(value: Any) -> str:- if value is None:- return ""- return value if isinstance(value, str) else str(value)diff --git a/src/free_claude_code/core/openai_responses/streaming/blocks.py b/src/free_claude_code/core/openai_responses/streaming/blocks.pydeleted file mode 100644index 581f7b3a..00000000--- a/src/free_claude_code/core/openai_responses/streaming/blocks.py+++ /dev/null@@ -1,36 +0,0 @@-"""Block state for OpenAI Responses streaming assembly."""--from dataclasses import dataclass, field-from typing import Literal---@dataclass(slots=True)-class TextBlockState:- index: int- output_index: int- item_id: str- text_parts: list[str] = field(default_factory=list)---@dataclass(slots=True)-class ReasoningBlockState:- index: int- output_index: int- item_id: str- text_parts: list[str] = field(default_factory=list)- encrypted_content: str | None = None---@dataclass(slots=True)-class ToolBlockState:- index: int- output_index: int- item_id: str- call_id: str- kind: Literal["function", "custom"]- name: str- namespace: str | None = None- argument_parts: list[str] = field(default_factory=list)---BlockState = TextBlockState | ReasoningBlockState | ToolBlockStatediff --git a/src/free_claude_code/core/openai_responses/streaming/completion.py b/src/free_claude_code/core/openai_responses/streaming/completion.pydeleted file mode 100644index adbc7d5d..00000000--- a/src/free_claude_code/core/openai_responses/streaming/completion.py+++ /dev/null@@ -1,158 +0,0 @@-"""Block finalization for OpenAI Responses streams."""--from collections.abc import Callable--from ..errors import ResponsesConversionError-from ..items import encrypted_reasoning_item, message_item, reasoning_item-from ..tools import (- custom_tool_input_text_from_arguments,- normalized_function_call_arguments,-)-from .blocks import BlockState, ReasoningBlockState, TextBlockState, ToolBlockState-from .event_builders import ResponseEventBuilder-from .ledger import ResponsesOutputLedger--InvalidFunctionCallHandler = Callable[- [ToolBlockState, ResponsesConversionError], list[str]-]---class ResponseBlockCompleter:- """Finalize active Responses output blocks."""-- def __init__(- self,- ledger: ResponsesOutputLedger,- *,- events: ResponseEventBuilder,- on_invalid_function_call: InvalidFunctionCallHandler,- ) -> None:- self._ledger = ledger- self._events = events- self._on_invalid_function_call = on_invalid_function_call-- def complete_block(self, state: BlockState) -> list[str]:- if isinstance(state, TextBlockState):- return self._complete_text_block(state)- if isinstance(state, ReasoningBlockState):- return self._complete_reasoning_block(state)- return self._complete_tool_block(state)-- def _complete_text_block(self, state: TextBlockState) -> list[str]:- text = "".join(state.text_parts)- item = message_item(state.item_id, text, "completed")- self._ledger.commit_output(state.output_index, item)- return [- self._events.output_text_done(state.item_id, state.output_index, text),- self._events.content_part_done(state.item_id, state.output_index, text),- self._events.output_item_done(state.output_index, item),- ]-- def _complete_reasoning_block(self, state: ReasoningBlockState) -> list[str]:- item = _reasoning_output_item(state, status="completed")- self._ledger.commit_output(state.output_index, item)- chunks: list[str] = []- text = "".join(state.text_parts)- if text:- self._ledger.add_reasoning_text(text)- chunks.append(- self._events.reasoning_text_done(- state.item_id, state.output_index, text- )- )- chunks.append(self._events.output_item_done(state.output_index, item))- return chunks-- def _complete_tool_block(self, state: ToolBlockState) -> list[str]:- if state.kind == "custom":- return self._complete_custom_tool_block(state)- raw_arguments = "".join(state.argument_parts) or "{}"- try:- arguments = normalized_function_call_arguments(raw_arguments)- except ResponsesConversionError as exc:- return self._on_invalid_function_call(state, exc)- item = tool_item(state, status="completed", arguments=arguments)- self._ledger.commit_output(state.output_index, item)- chunks: list[str] = []- if arguments:- chunks.append(- self._events.function_call_arguments_delta(- state.item_id, state.output_index, arguments- )- )- chunks.extend(- [- self._events.function_call_arguments_done(- state.item_id, state.output_index, arguments- ),- self._events.output_item_done(state.output_index, item),- ]- )- return chunks-- def _complete_custom_tool_block(self, state: ToolBlockState) -> list[str]:- input_text = custom_tool_input_text_from_arguments(- "".join(state.argument_parts)- )- item = tool_item(state, status="completed", input_text=input_text)- self._ledger.commit_output(state.output_index, item)- chunks: list[str] = []- if input_text:- chunks.append(- self._events.custom_tool_call_input_delta(- state.item_id, state.output_index, input_text- )- )- chunks.extend(- [- self._events.custom_tool_call_input_done(- state.item_id, state.output_index, input_text- ),- self._events.output_item_done(state.output_index, item),- ]- )- return chunks---def tool_item(- state: ToolBlockState,- *,- status: str,- arguments: str = "",- input_text: str = "",-) -> dict[str, object]:- if state.kind == "custom":- item: dict[str, object] = {- "id": state.item_id,- "type": "custom_tool_call",- "status": status,- "call_id": state.call_id,- "name": state.name,- "input": input_text,- }- else:- item = {- "id": state.item_id,- "type": "function_call",- "status": status,- "call_id": state.call_id,- "name": state.name,- "arguments": arguments,- }- if state.namespace:- item["namespace"] = state.namespace- return item---def reasoning_output_item(- state: ReasoningBlockState, *, status: str-) -> dict[str, object]:- if state.encrypted_content is not None:- return encrypted_reasoning_item(state.item_id, state.encrypted_content, status)- return reasoning_item(state.item_id, "".join(state.text_parts), status)---def _reasoning_output_item(- state: ReasoningBlockState, *, status: str-) -> dict[str, object]:- return reasoning_output_item(state, status=status)diff --git a/src/free_claude_code/core/openai_responses/streaming/ledger.py b/src/free_claude_code/core/openai_responses/streaming/ledger.pydeleted file mode 100644index 0eb82d4f..00000000--- a/src/free_claude_code/core/openai_responses/streaming/ledger.py+++ /dev/null@@ -1,96 +0,0 @@-"""Output ledger for OpenAI Responses streaming assembly."""--from collections.abc import Mapping-from typing import Any--from free_claude_code.core.token_estimation import estimate_text_tokens--from .blocks import BlockState--_ANTHROPIC_INPUT_TOKEN_FIELDS = (- "input_tokens",- "cache_creation_input_tokens",- "cache_read_input_tokens",-)---class ResponsesOutputLedger:- """Track active blocks, reserved output slots, and accumulated usage."""-- def __init__(self) -> None:- self._output_slots: list[dict[str, Any] | None] = []- self._active_blocks: dict[int, BlockState] = {}- self._fallback_text_index = -1- self._input_token_counts: dict[str, int] = {}- self._output_tokens: int | None = None- self._reasoning_tokens_estimate = 0-- def active_block(self, index: int) -> BlockState | None:- return self._active_blocks.get(index)-- def set_active_block(self, state: BlockState) -> None:- self._active_blocks[state.index] = state-- def pop_active_block(self, index: int) -> BlockState | None:- return self._active_blocks.pop(index, None)-- def pop_active_blocks_by_output_order(self) -> list[BlockState]:- states = sorted(- self._active_blocks.values(), key=lambda state: state.output_index- )- self._active_blocks.clear()- return states-- def reserve_output_slot(self) -> int:- output_index = len(self._output_slots)- self._output_slots.append(None)- return output_index-- def commit_output(self, output_index: int, item: dict[str, Any]) -> None:- while output_index >= len(self._output_slots):- self._output_slots.append(None)- self._output_slots[output_index] = item-- def output(self) -> list[dict[str, Any]]:- return [item for item in self._output_slots if item is not None]-- def record_usage_delta(self, data: Mapping[str, Any]) -> None:- usage = data.get("usage")- if not isinstance(usage, dict):- return- for field in _ANTHROPIC_INPUT_TOKEN_FIELDS:- value = usage.get(field)- if isinstance(value, int) and not isinstance(value, bool) and value >= 0:- self._input_token_counts[field] = value- if isinstance(usage.get("output_tokens"), int):- self._output_tokens = usage["output_tokens"]-- def add_reasoning_text(self, text: str) -> None:- self._reasoning_tokens_estimate += estimate_text_tokens(text)-- def usage(self) -> dict[str, Any] | None:- if not self._input_token_counts and self._output_tokens is None:- return None- input_tokens = sum(self._input_token_counts.values())- output_tokens = self._output_tokens or 0- usage: dict[str, Any] = {- "input_tokens": input_tokens,- "input_tokens_details": {- "cached_tokens": self._input_token_counts.get(- "cache_read_input_tokens", 0- )- },- "output_tokens": output_tokens,- "output_tokens_details": {- "reasoning_tokens": min(self._reasoning_tokens_estimate, output_tokens)- },- "total_tokens": input_tokens + output_tokens,- }- return usage-- def safe_text_index(self, index: int | None) -> int:- if index is not None:- return index- value = self._fallback_text_index- self._fallback_text_index -= 1- return valuediff --git a/src/free_claude_code/core/trace.py b/src/free_claude_code/core/trace.pyindex 88606b47..202f1cd9 100644--- a/src/free_claude_code/core/trace.py+++ b/src/free_claude_code/core/trace.py@@ -8,7 +8,7 @@ INFO log level excludes these detailed request traces.import asyncioimport sys-from collections.abc import AsyncGenerator, AsyncIterator, Mapping+from collections.abc import AsyncGenerator, AsyncIterator, Callable, Mappingfrom typing import Anyfrom loguru import logger@@ -100,8 +100,8 @@ def extract_claude_session_id_from_headers(headers: Mapping[str, str]) -> str |return None-async def traced_async_stream(- agen: AsyncIterator[str],+async def traced_async_stream[StreamValue](+ agen: AsyncIterator[StreamValue],*,stage: str,source: str,@@ -110,8 +110,9 @@ async def traced_async_stream(chunk_event: str | None = None,chunk_interval: int = 250,extra: Mapping[str, Any] | None = None,-) -> AsyncGenerator[str]:- """Emit TRACE rows when a text stream completes, fails, cancels, or periodically."""+ item_size: Callable[[StreamValue], int] | None = None,+) -> AsyncGenerator[StreamValue]:+ """Trace completion and interruption for one typed asynchronous stream."""common = dict(extra or {})count = 0nbytes = 0@@ -119,7 +120,13 @@ async def traced_async_stream(try:async for chunk in agen:count += 1- nbytes += len(chunk.encode("utf-8", errors="replace"))+ nbytes += (+ item_size(chunk)+ if item_size is not None+ else len(chunk.encode("utf-8", errors="replace"))+ if isinstance(chunk, str)+ else 0+ )if chunk_event and chunk_interval > 0 and count % chunk_interval == 0:trace_event(stage=stage,diff --git a/src/free_claude_code/providers/base.py b/src/free_claude_code/providers/base.pyindex 4fd73c38..ab426729 100644--- a/src/free_claude_code/providers/base.py+++ b/src/free_claude_code/providers/base.py@@ -12,6 +12,7 @@ from free_claude_code.core.diagnostics import (exception_cause_types,redacted_exception_traceback,)+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.core.trace import trace_event@@ -112,5 +113,5 @@ class BaseProvider(ABC):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:- """Stream response in Anthropic SSE format."""+ ) -> AsyncIterator[InferenceEvent]:+ """Stream provider-neutral inference events."""diff --git a/src/free_claude_code/providers/cloudflare/client.py b/src/free_claude_code/providers/cloudflare/client.pyindex dafac98d..616d8348 100644--- a/src/free_claude_code/providers/cloudflare/client.py+++ b/src/free_claude_code/providers/cloudflare/client.py@@ -11,6 +11,10 @@ from free_claude_code.application.errors import ApplicationUnavailableErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.provider_catalog import CLOUDFLARE_AI_REST_ROOTfrom free_claude_code.core.anthropic import ReasoningReplayMode+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceStreamLedger,+)from free_claude_code.providers.admission import (ProviderAdmissionController,ProviderOperationKind,@@ -131,14 +135,14 @@ class CloudflareProvider(OpenAIChatProvider):await maybe_await_aclose(response)def _handle_extra_reasoning(- self, delta: Any, ledger: Any, *, output_reasoning: bool- ) -> Iterator[str]:- """Map Cloudflare's ``reasoning`` delta field to Anthropic thinking."""+ self, delta: Any, ledger: InferenceStreamLedger, *, output_reasoning: bool+ ) -> Iterator[InferenceEvent]:+ """Map Cloudflare's ``reasoning`` delta field to canonical reasoning."""reasoning = _cloudflare_reasoning(delta)if not output_reasoning or not reasoning:return- yield from ledger.ensure_thinking_block()- yield ledger.emit_thinking_delta(reasoning)+ yield from ledger.ensure_reasoning_block()+ yield ledger.emit_reasoning_delta(reasoning)def _model_list_headers(self) -> dict[str, str]:if self._api_key is None:diff --git a/src/free_claude_code/providers/deepseek/client.py b/src/free_claude_code/providers/deepseek/client.pyindex 7f264fa1..29a5a345 100644--- a/src/free_claude_code/providers/deepseek/client.py+++ b/src/free_claude_code/providers/deepseek/client.py@@ -44,7 +44,7 @@ class DeepSeekProvider(OpenAIChatProvider):reasoning=reasoning,)- def _anthropic_usage_fields(self, usage_info: Any) -> dict[str, int]:+ def _usage_fields(self, usage_info: Any) -> dict[str, int]:cache_hit_tokens = usage_int(usage_info, "prompt_cache_hit_tokens")cache_miss_tokens = usage_int(usage_info, "prompt_cache_miss_tokens")if (diff --git a/src/free_claude_code/providers/openai_chat/provider.py b/src/free_claude_code/providers/openai_chat/provider.pyindex 5154bc94..c4837be3 100644--- a/src/free_claude_code/providers/openai_chat/provider.py+++ b/src/free_claude_code/providers/openai_chat/provider.py@@ -22,17 +22,23 @@ from free_claude_code.core.anthropic import ()from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.streaming import (- AnthropicStreamLedger,accept_tool_json_repair,continuation_suffix,make_response_recovery_body,make_text_recovery_body,make_tool_repair_body,- map_stop_reason,parse_complete_tool_input,tool_schemas_by_name,)from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+ InferenceUsage,+ TokenMeasurement,+ UsageSource,+)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.core.trace import provider_chat_body_snapshot, trace_eventfrom free_claude_code.providers.admission import (@@ -74,8 +80,8 @@ from .tool_calls import (OpenAIToolCallAssembler,OpenAIToolCallCollector,all_emitted_tools_complete,- has_committed_sse_output,- iter_heuristic_tool_use_sse,+ has_generated_output,+ iter_heuristic_tool_use_events,started_tool_states,tool_call_extra_content,)@@ -87,7 +93,7 @@ from .usage import ()OpenAIAsyncCredentialProvider = Callable[[], Awaitable[str]]-_ExtraReasoningEvents = Callable[[Any, AnthropicStreamLedger], Iterator[str]]+_ExtraReasoningEvents = Callable[[Any, InferenceStreamLedger], Iterator[InferenceEvent]]@dataclass(frozen=True, slots=True)@@ -98,26 +104,26 @@ class _CollectedRecoveryOutput:def _iter_visible_text_events(- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,text: str,-) -> Iterator[str]:+) -> Iterator[InferenceEvent]:yield from ledger.ensure_text_block()yield ledger.emit_text_delta(text)def _iter_text_parser_events(- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,parser: HeuristicToolParser,text: str,*,tool_names: OpenAIToolNameCodec,-) -> Iterator[str]:+) -> Iterator[InferenceEvent]:"""Route visible text through the established heuristic tool parser."""filtered_text, detected_tools = parser.feed(text)if filtered_text:yield from _iter_visible_text_events(ledger, filtered_text)for tool_use in detected_tools:- yield from iter_heuristic_tool_use_sse(+ yield from iter_heuristic_tool_use_events(ledger,tool_use,tool_names=tool_names,@@ -125,13 +131,13 @@ def _iter_text_parser_events(def _iter_text_tool_use_events(- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,tool_uses: tuple[dict[str, Any], ...] | list[dict[str, Any]],*,tool_names: OpenAIToolNameCodec,-) -> Iterator[str]:+) -> Iterator[InferenceEvent]:for tool_use in tool_uses:- yield from iter_heuristic_tool_use_sse(+ yield from iter_heuristic_tool_use_events(ledger,tool_use,tool_names=tool_names,@@ -142,10 +148,80 @@ def _iter_text_tool_use_events(class _OpenAIChatCompletion:finish_reason: Anyoutput_tokens: int+ provider_output_tokens: int | Noneinput_tokens: intprovider_input_tokens: int | None+def _canonical_finish_reason(value: object) -> FinishReason:+ raw = str(value).lower() if value is not None else ""+ return {+ "stop": FinishReason.END_TURN,+ "length": FinishReason.OUTPUT_LIMIT,+ "max_tokens": FinishReason.OUTPUT_LIMIT,+ "tool_calls": FinishReason.TOOL_CALLS,+ "function_call": FinishReason.TOOL_CALLS,+ "content_filter": FinishReason.CONTENT_FILTER,+ "stop_sequence": FinishReason.STOP_SEQUENCE,+ }.get(raw, FinishReason.PROVIDER_UNKNOWN if raw else FinishReason.END_TURN)+++def _chat_completion_usage(+ completion: _OpenAIChatCompletion,+ usage_fields: Mapping[str, int],+) -> InferenceUsage:+ input_override = usage_fields.get("input_tokens")+ input_tokens = (+ input_override+ if isinstance(input_override, int) and not isinstance(input_override, bool)+ else completion.input_tokens+ )+ input_reported = (+ completion.provider_input_tokens is not None or input_override is not None+ )+ return InferenceUsage(+ input_tokens=TokenMeasurement(+ max(input_tokens, 0),+ UsageSource.REPORTED if input_reported else UsageSource.ESTIMATED,+ ),+ cache_read_input_tokens=_reported_usage_field(+ usage_fields, "cache_read_input_tokens"+ ),+ cache_creation_input_tokens=_reported_usage_field(+ usage_fields, "cache_creation_input_tokens"+ ),+ output_tokens=TokenMeasurement(+ max(completion.output_tokens, 0),+ (+ UsageSource.REPORTED+ if completion.provider_output_tokens is not None+ else UsageSource.ESTIMATED+ ),+ ),+ reasoning_output_tokens=_reported_usage_field(+ usage_fields, "reasoning_output_tokens"+ ),+ )+++def _reported_usage_field(+ usage_fields: Mapping[str, int], key: str+) -> TokenMeasurement | None:+ value = usage_fields.get(key)+ if not isinstance(value, int) or isinstance(value, bool) or value < 0:+ return None+ return TokenMeasurement(value, UsageSource.REPORTED)+++def _estimated_recovery_usage(+ *, input_tokens: int, output_tokens: int+) -> InferenceUsage:+ return InferenceUsage(+ input_tokens=TokenMeasurement(max(input_tokens, 0), UsageSource.ESTIMATED),+ output_tokens=TokenMeasurement(max(output_tokens, 0), UsageSource.ESTIMATED),+ )++class _OpenAIChatFailureOutcome(StrEnum):RETRY = "retry"COMPLETE = "complete"@@ -155,7 +231,7 @@ class _OpenAIChatFailureOutcome(StrEnum):@dataclass(frozen=True, slots=True)class _OpenAIChatFailureResolution:outcome: _OpenAIChatFailureOutcome- events: tuple[str, ...] = ()+ events: tuple[InferenceEvent, ...] = ()failure: ExecutionFailure | None = None@@ -166,7 +242,7 @@ class _OpenAIChatStreamAssembler:self,*,request: MessagesRequest,- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,profile: OpenAIChatProfile,provider_name: str,output_reasoning: bool,@@ -202,7 +278,7 @@ class _OpenAIChatStreamAssembler:self._completed = False@property- def ledger(self) -> AnthropicStreamLedger:+ def ledger(self) -> InferenceStreamLedger:return self._ledger@property@@ -217,7 +293,7 @@ class _OpenAIChatStreamAssembler:@propertydef generated_output(self) -> bool:- return has_committed_sse_output(self._ledger)+ return has_generated_output(self._ledger)@propertydef complete_tool_salvageable(self) -> bool:@@ -231,11 +307,11 @@ class _OpenAIChatStreamAssembler:def tool_argument_alias_buffers(self) -> Mapping[int, str]:return self._tool_argument_alias_buffers- def start_events(self) -> Iterator[str]:+ def start_events(self) -> Iterator[InferenceEvent]:if self._started:returnself._started = True- yield self._ledger.message_start()+ yield self._ledger.start_response()def bind_tool_argument_aliases(self, aliases: dict[str, dict[str, str]]) -> None:if self._aliases_bound:@@ -243,7 +319,7 @@ class _OpenAIChatStreamAssembler:self._aliases_bound = Trueself._tool_argument_aliases = aliases- def feed(self, chunk: Any) -> Iterator[str]:+ def feed(self, chunk: Any) -> Iterator[InferenceEvent]:if not self._started or self._upstream_finished:raise RuntimeError("stream assembler is not accepting chunks")@@ -276,9 +352,9 @@ class _OpenAIChatStreamAssembler:native_reasoning=reasoning,)elif reasoning is not None:- yield from self._ledger.ensure_thinking_block()+ yield from self._ledger.ensure_reasoning_block()if reasoning:- yield self._ledger.emit_thinking_delta(reasoning)+ yield self._ledger.emit_reasoning_delta(reasoning)yield from self._extra_reasoning_events(delta, self._ledger)@@ -293,8 +369,8 @@ class _OpenAIChatStreamAssembler:if part.type == ContentType.THINKING:if not self._output_reasoning:continue- yield from self._ledger.ensure_thinking_block()- yield self._ledger.emit_thinking_delta(part.content)+ yield from self._ledger.ensure_reasoning_block()+ yield self._ledger.emit_reasoning_delta(part.content)else:safe_text = self._function_tag_parser.feed(part.content)if safe_text:@@ -328,7 +404,7 @@ class _OpenAIChatStreamAssembler:tool_argument_alias_buffers=self._tool_argument_alias_buffers,)- def finish_upstream(self) -> Iterator[str]:+ def finish_upstream(self) -> Iterator[InferenceEvent]:if self._upstream_finished:returnif self._finish_reason is None:@@ -347,8 +423,8 @@ class _OpenAIChatStreamAssembler:if remaining:if remaining.type == ContentType.THINKING:if self._output_reasoning:- yield from self._ledger.ensure_thinking_block()- yield self._ledger.emit_thinking_delta(remaining.content)+ yield from self._ledger.ensure_reasoning_block()+ yield self._ledger.emit_reasoning_delta(remaining.content)else:safe_text = self._function_tag_parser.feed(remaining.content)if safe_text:@@ -374,7 +450,7 @@ class _OpenAIChatStreamAssembler:)self._upstream_finished = True- def prepare_completion(self) -> Iterator[str]:+ def prepare_completion(self) -> Iterator[InferenceEvent]:if not self._upstream_finished or self._completion is not None:raise RuntimeError("stream completion cannot be prepared")@@ -387,11 +463,7 @@ class _OpenAIChatStreamAssembler:)has_emitted_tool = self._ledger.has_emitted_tool_block()- has_content_blocks = (- self._ledger.blocks.text_index != -1- or self._ledger.blocks.thinking_index != -1- or has_emitted_tool- )+ has_content_blocks = self._ledger.has_content_block()if not has_content_blocks or (not has_emitted_tooland not self._ledger.accumulated_text.strip()@@ -421,21 +493,21 @@ class _OpenAIChatStreamAssembler:self._completion = _OpenAIChatCompletion(finish_reason=self._finish_reason,output_tokens=output_tokens,+ provider_output_tokens=completion,input_tokens=input_tokens,provider_input_tokens=provider_input,)- def terminal_events(self, *, usage_fields: dict[str, int]) -> Iterator[str]:+ def terminal_events(+ self, *, usage_fields: dict[str, int]+ ) -> Iterator[InferenceEvent]:if self._completed:returncompletion = self.completion- yield self._ledger.message_delta(- self._ledger.final_stop_reason(map_stop_reason(completion.finish_reason)),- completion.output_tokens,- input_tokens=completion.input_tokens,- usage_fields=usage_fields,+ yield from self._ledger.finish_events(+ _canonical_finish_reason(completion.finish_reason),+ _chat_completion_usage(completion, usage_fields),)- yield self._ledger.message_stop()self._completed = True@@ -614,8 +686,8 @@ class OpenAIChatProvider(BaseProvider):self._build_request_body(request, reasoning=reasoning)def _handle_extra_reasoning(- self, delta: Any, ledger: AnthropicStreamLedger, *, output_reasoning: bool- ) -> Iterator[str]:+ self, delta: Any, ledger: InferenceStreamLedger, *, output_reasoning: bool+ ) -> Iterator[InferenceEvent]:"""Hook for provider-specific reasoning."""return iter(())@@ -640,8 +712,8 @@ class OpenAIChatProvider(BaseProvider):"""Return provider-specific per-tool argument aliases for this request."""return {}- def _anthropic_usage_fields(self, usage_info: Any) -> dict[str, int]:- """Return provider-specific Anthropic usage fields for final SSE usage."""+ def _usage_fields(self, usage_info: Any) -> dict[str, int]:+ """Return provider-specific cumulative usage fields."""return {}async def _create_stream(@@ -770,8 +842,8 @@ class OpenAIChatProvider(BaseProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:- """Stream response in Anthropic SSE format."""+ ) -> AsyncIterator[InferenceEvent]:+ """Stream provider-neutral inference events."""runner = _OpenAIChatStreamRunner(self,request=request,@@ -805,13 +877,13 @@ class _OpenAIChatStreamRunner:)self._reasoning = reasoningself._tool_names = OpenAIToolNameCodec.from_request(request)- self._message_id = f"msg_{uuid.uuid4()}"+ self._response_id = f"response_{uuid.uuid4().hex}"self._tool_calls = OpenAIToolCallAssembler(record_extra_content=provider._record_tool_call_extra_content)- async def run(self) -> AsyncIterator[str]:- """Convert the upstream OpenAI-chat stream into Anthropic SSE."""+ async def run(self) -> AsyncIterator[InferenceEvent]:+ """Convert the upstream OpenAI-chat stream into canonical events."""execution = self._provider._admission.start_execution(request_id=self._request_id)@@ -833,13 +905,13 @@ class _OpenAIChatStreamRunner:async def _run_execution(self,execution: ProviderExecution,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:"""Run one provider execution while retaining transport-owned state."""tag = self._provider._provider_namereq_tag = f" request_id={self._request_id}" if self._request_id else ""recovery = RecoveryController()- def hold_event(event: str) -> Iterator[str]:+ def hold_event(event: InferenceEvent) -> Iterator[InferenceEvent]:yield from recovery.push(event)body = self._provider._build_request_body(@@ -949,7 +1021,7 @@ class _OpenAIChatStreamRunner:prompt_tokens_estimate=self._input_tokens,)for event in assembler.terminal_events(- usage_fields=self._provider._anthropic_usage_fields(assembler.usage_info)+ usage_fields=self._provider._usage_fields(assembler.usage_info)):for out_event in hold_event(event):yield out_event@@ -1063,7 +1135,7 @@ class _OpenAIChatStreamRunner:error_trace["error_message"] = failure.messagetrace_event(**error_trace)- failure_events: list[str] = []+ failure_events: list[InferenceEvent] = []if (not decision.committedand decision.has_buffered@@ -1188,12 +1260,12 @@ class _OpenAIChatStreamRunner:self,*,body: dict[str, Any],- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,error: Exception,tool_argument_alias_buffers: Mapping[int, str],output_reasoning: bool,execution: ProviderExecution,- ) -> list[str] | None:+ ) -> list[InferenceEvent] | None:"""Build terminal recovery events when the interrupted stream permits it."""if ledger.has_emitted_tool_block():if not all_emitted_tools_complete(ledger, self._request):@@ -1207,15 +1279,17 @@ class _OpenAIChatStreamRunner:return Noneelse:repair_events = []- events = list(repair_events)+ events: list[InferenceEvent] = list(repair_events)events.extend(ledger.close_all_blocks())- events.append(- ledger.message_delta(- ledger.final_stop_reason("end_turn"),- ledger.estimate_output_tokens(),+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ _estimated_recovery_usage(+ input_tokens=self._input_tokens,+ output_tokens=ledger.estimate_output_tokens(),+ ),))- events.append(ledger.message_stop())trace_event(stage="provider",event="provider.recovery.tool_salvaged",@@ -1250,10 +1324,10 @@ class _OpenAIChatStreamRunner:)text_suffix = continuation_suffix(partial_text, recovered.text)thinking_suffix = continuation_suffix(partial_thinking, recovered.thinking)- events: list[str] = []+ events: list[InferenceEvent] = []if thinking_suffix:- events.extend(ledger.ensure_thinking_block())- events.append(ledger.emit_thinking_delta(thinking_suffix))+ events.extend(ledger.ensure_reasoning_block())+ events.append(ledger.emit_reasoning_delta(thinking_suffix))if text_suffix:events.extend(ledger.ensure_text_block())events.append(ledger.emit_text_delta(text_suffix))@@ -1264,12 +1338,15 @@ class _OpenAIChatStreamRunner:if not events:return Noneevents.extend(ledger.close_all_blocks())- events.append(- ledger.message_delta(- ledger.final_stop_reason("end_turn"), ledger.estimate_output_tokens()+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ _estimated_recovery_usage(+ input_tokens=self._input_tokens,+ output_tokens=ledger.estimate_output_tokens(),+ ),))- events.append(ledger.message_stop())trace_event(stage="provider",event="provider.recovery.continued",@@ -1283,12 +1360,12 @@ class _OpenAIChatStreamRunner:self,*,body: dict[str, Any],- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,tool_argument_alias_buffers: Mapping[int, str],execution: ProviderExecution,- ) -> list[str] | None:+ ) -> list[InferenceEvent] | None:schemas = tool_schemas_by_name(self._request)- events: list[str] = []+ events: list[InferenceEvent] = []for tool_index, state in started_tool_states(ledger):block = ledger.tool_block_for_tool_index(tool_index)emitted_prefix = block.content if block is not None else ""@@ -1354,8 +1431,8 @@ class _OpenAIChatStreamRunner:self, *, output_reasoning: bool) -> _OpenAIChatStreamAssembler:def extra_reasoning_events(- delta: Any, ledger: AnthropicStreamLedger- ) -> Iterator[str]:+ delta: Any, ledger: InferenceStreamLedger+ ) -> Iterator[InferenceEvent]:yield from self._provider._handle_extra_reasoning(delta,ledger,@@ -1364,11 +1441,10 @@ class _OpenAIChatStreamRunner:return _OpenAIChatStreamAssembler(request=self._request,- ledger=AnthropicStreamLedger(- self._message_id,+ ledger=InferenceStreamLedger(+ self._response_id,self._response_model,self._input_tokens,- log_raw_events=self._provider._config.log_raw_sse_events,),profile=self._provider._profile,provider_name=self._provider._provider_name,diff --git a/src/free_claude_code/providers/openai_chat/reasoning_details.py b/src/free_claude_code/providers/openai_chat/reasoning_details.pyindex fa7852cb..2e2e5635 100644--- a/src/free_claude_code/providers/openai_chat/reasoning_details.py+++ b/src/free_claude_code/providers/openai_chat/reasoning_details.py@@ -8,7 +8,14 @@ from free_claude_code.core.anthropic import (is_synthetic_openai_tool_turn_boundary,)from free_claude_code.core.anthropic.models import MessagesRequest-from free_claude_code.core.anthropic.streaming import AnthropicStreamLedger+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceStreamLedger,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+)from free_claude_code.core.reasoning import ReasoningPolicy@@ -51,10 +58,10 @@ class StructuredReasoningStream:def events(self,delta: Any,- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,*,native_reasoning: str | None,- ) -> Iterator[str]:+ ) -> Iterator[InferenceEvent]:"""Emit plaintext once while preserving every opaque reasoning detail."""details = _reasoning_details(delta)if self._text_source is None:@@ -64,26 +71,26 @@ class StructuredReasoningStream:self._text_source = "details"if self._text_source == "native" and native_reasoning:- yield from ledger.ensure_thinking_block()- yield ledger.emit_thinking_delta(native_reasoning)+ yield from ledger.ensure_reasoning_block()+ yield ledger.emit_reasoning_delta(native_reasoning)for detail in details:if self._text_source == "details":text = _reasoning_detail_text(detail)if text:- yield from ledger.ensure_thinking_block()- yield ledger.emit_thinking_delta(text)+ yield from ledger.ensure_reasoning_block()+ yield ledger.emit_reasoning_delta(text)preserved = _preserved_reasoning_detail(detail)if preserved:- yield from ledger.close_content_blocks()- index = ledger.blocks.allocate_index()- yield ledger.content_block_start(- index,- "redacted_thinking",- data=preserved,+ yield from ledger.emit_reasoning_artifact(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENROUTER,+ kind=ReplayArtifactKind.REASONING_DETAILS,+ attachment=ReplayAttachment.REASONING,+ payload=preserved,+ ))- yield ledger.content_block_stop(index)def _reasoning_details(delta: Any) -> Sequence[Any]:diff --git a/src/free_claude_code/providers/openai_chat/tool_calls.py b/src/free_claude_code/providers/openai_chat/tool_calls.pyindex 58a8025d..174f4352 100644--- a/src/free_claude_code/providers/openai_chat/tool_calls.py+++ b/src/free_claude_code/providers/openai_chat/tool_calls.py@@ -9,10 +9,19 @@ from typing import Anyfrom free_claude_code.core.anthropic import OpenAIToolNameCodecfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.streaming import (- AnthropicStreamLedger,parse_complete_tool_input,tool_schemas_by_name,)+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceStreamLedger,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ToolCallKind,+ ToolCallState,+)RecordToolExtraContent = Callable[[str, dict[str, Any]], None]@@ -103,13 +112,13 @@ class OpenAIToolCallCollector:return tuple(completed)-def iter_heuristic_tool_use_sse(- ledger: AnthropicStreamLedger,+def iter_heuristic_tool_use_events(+ ledger: InferenceStreamLedger,tool_use: dict[str, Any],*,tool_names: OpenAIToolNameCodec | None = None,-) -> Iterator[str]:- """Emit SSE for one heuristic tool_use block."""+) -> Iterator[InferenceEvent]:+ """Emit canonical events for one heuristic tool-use block."""name = tool_use.get("name")if tool_names is not None and isinstance(name, str):decoded_name = tool_names.decode(name)@@ -120,19 +129,15 @@ def iter_heuristic_tool_use_sse(if task_input.get("run_in_background") is not False:task_input["run_in_background"] = Falseyield from ledger.close_content_blocks()- block_idx = ledger.blocks.allocate_index()- yield ledger.content_block_start(- block_idx,- "tool_use",- id=tool_use["id"],- name=tool_use["name"],- )- yield ledger.content_block_delta(- block_idx,- "input_json_delta",- json.dumps(tool_use["input"]),+ tool_index = len(ledger.blocks.tool_states)+ yield ledger.start_tool_block(+ tool_index,+ str(tool_use["id"]),+ str(tool_use["name"]),+ kind=ToolCallKind.FUNCTION,)- yield ledger.content_block_stop(block_idx)+ yield ledger.emit_tool_delta(tool_index, json.dumps(tool_use["input"]))+ yield ledger.stop_tool_block(tool_index)def tool_call_extra_content(tool_call: Any) -> dict[str, Any] | None:@@ -160,16 +165,14 @@ def tool_call_extra_content(tool_call: Any) -> dict[str, Any] | None:return None-def has_committed_sse_output(ledger: AnthropicStreamLedger) -> bool:- """Return whether any assistant content escaped the builder."""- return (- ledger.blocks.text_index != -1- or ledger.blocks.thinking_index != -1- or ledger.has_emitted_tool_block()- )+def has_generated_output(ledger: InferenceStreamLedger) -> bool:+ """Return whether one canonical assistant block has been generated."""+ return ledger.has_generated_output()-def started_tool_states(ledger: AnthropicStreamLedger) -> list[tuple[int, Any]]:+def started_tool_states(+ ledger: InferenceStreamLedger,+) -> list[tuple[int, ToolCallState]]:"""Return started tool states in stream order."""return [(tool_index, state)@@ -179,14 +182,23 @@ def started_tool_states(ledger: AnthropicStreamLedger) -> list[tuple[int, Any]]:def all_emitted_tools_complete(- ledger: AnthropicStreamLedger, request: MessagesRequest+ ledger: InferenceStreamLedger, request: MessagesRequest) -> bool:"""Return whether every emitted tool block has schema-valid input."""- return ledger.can_salvage_tool_use(tool_schemas_by_name(request))+ schemas = tool_schemas_by_name(request)+ tool_blocks = ledger.tool_blocks()+ if not tool_blocks:+ return False+ return all(+ block.call_id+ and block.name+ and parse_complete_tool_input(block.content, block.name, schemas) is not None+ for block in tool_blocks+ )class OpenAIToolCallAssembler:- """Assemble OpenAI tool-call deltas into Anthropic SSE tool blocks."""+ """Assemble OpenAI tool-call deltas into canonical tool events."""def __init__(self, *, record_extra_content: RecordToolExtraContent | None = None@@ -196,14 +208,14 @@ class OpenAIToolCallAssembler:def process_tool_call(self,tc: dict[str, Any],- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,*,tool_names: OpenAIToolNameCodec | None = None,tool_name_buffers: dict[int, str] | None = None,tool_argument_aliases: dict[str, dict[str, str]] | None = None,tool_argument_alias_buffers: dict[int, str] | None = None,- ) -> Iterator[str]:- """Process a single tool-call delta and yield Anthropic SSE events."""+ ) -> Iterator[InferenceEvent]:+ """Process one tool-call delta and yield canonical events."""raw_index = tc.get("index", 0)tc_index = raw_index if isinstance(raw_index, int) else 0if tc_index < 0:@@ -223,7 +235,10 @@ class OpenAIToolCallAssembler:else None)if extra_content:- ledger.blocks.set_tool_extra_content(tc_index, extra_content)+ ledger.set_tool_artifacts(+ tc_index,+ _tool_replay_artifacts(extra_content),+ )if isinstance(incoming_name, str) and incoming_name:resolved_name = _decode_streamed_tool_name(@@ -236,7 +251,7 @@ class OpenAIToolCallAssembler:ledger.blocks.register_tool_name(tc_index, resolved_name)state = ledger.blocks.tool_states.get(tc_index)- resolved_id = (state.tool_id if state and state.tool_id else None) or tc.get(+ resolved_id = (state.call_id if state and state.call_id else None) or tc.get("id")resolved_name = (state.name if state else "") or ""@@ -246,14 +261,14 @@ class OpenAIToolCallAssembler:if name_ok:tool_id = str(resolved_id) if resolved_id else f"tool_{uuid.uuid4()}"display_name = (resolved_name or "").strip() or "tool_call"- start_extra_content = state.extra_content if state else extra_content- if start_extra_content:- self._record_tool_call_extra_content(tool_id, start_extra_content)+ start_artifacts = state.artifacts if state else ()+ if extra_content:+ self._record_tool_call_extra_content(tool_id, extra_content)yield ledger.start_tool_block(tc_index,tool_id,display_name,- extra_content=start_extra_content,+ artifacts=start_artifacts,)state = ledger.blocks.tool_states[tc_index]if state.pre_start_args:@@ -268,8 +283,8 @@ class OpenAIToolCallAssembler:)state = ledger.blocks.tool_states.get(tc_index)- if state is not None and state.tool_id and extra_content:- self._record_tool_call_extra_content(state.tool_id, extra_content)+ if state is not None and state.call_id and extra_content:+ self._record_tool_call_extra_content(state.call_id, extra_content)if not arguments:returnif state is None or not state.started:@@ -286,20 +301,22 @@ class OpenAIToolCallAssembler:tool_argument_alias_buffers=tool_argument_alias_buffers,)- def flush_task_arg_buffers(self, ledger: AnthropicStreamLedger) -> Iterator[str]:+ def flush_task_arg_buffers(+ self, ledger: InferenceStreamLedger+ ) -> Iterator[InferenceEvent]:"""Emit buffered Task args as a single JSON delta."""for tool_index, out in ledger.blocks.flush_task_arg_buffers():yield ledger.emit_tool_delta(tool_index, out)def flush_tool_name_buffers(self,- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,*,tool_names: OpenAIToolNameCodec,tool_name_buffers: dict[int, str],tool_argument_aliases: dict[str, dict[str, str]],tool_argument_alias_buffers: dict[int, str],- ) -> Iterator[str]:+ ) -> Iterator[InferenceEvent]:"""Resolve names held only because they also prefix a generated alias."""for tool_index, name in list(tool_name_buffers.items()):tool_name_buffers.pop(tool_index, None)@@ -316,10 +333,10 @@ class OpenAIToolCallAssembler:def flush_tool_argument_alias_buffers(self,- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,tool_argument_aliases: dict[str, dict[str, str]],tool_argument_alias_buffers: dict[int, str],- ) -> Iterator[str]:+ ) -> Iterator[InferenceEvent]:"""Emit remaining aliased args without losing malformed JSON."""for tool_index, buffered_args in list(tool_argument_alias_buffers.items()):if not buffered_args:@@ -340,13 +357,13 @@ class OpenAIToolCallAssembler:def _emit_tool_arg_delta(self,- ledger: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,tc_index: int,args: str,*,tool_argument_aliases: dict[str, dict[str, str]] | None = None,tool_argument_alias_buffers: dict[int, str] | None = None,- ) -> Iterator[str]:+ ) -> Iterator[InferenceEvent]:"""Emit one argument fragment for a started tool block."""if not args:return@@ -447,3 +464,28 @@ def _decode_streamed_tool_name(return Nonebuffers.pop(tool_index, None)return tool_names.decode(combined)+++def _tool_replay_artifacts(+ extra_content: dict[str, Any],+) -> tuple[ReplayArtifact, ...]:+ google = extra_content.get("google")+ if isinstance(google, dict):+ signature = google.get("thought_signature")+ if isinstance(signature, str) and signature:+ return (+ ReplayArtifact(+ origin=ReplayArtifactOrigin.GOOGLE,+ kind=ReplayArtifactKind.THOUGHT_SIGNATURE,+ attachment=ReplayAttachment.TOOL_CALL,+ payload=signature,+ ),+ )+ return (+ ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI_COMPATIBLE,+ kind=ReplayArtifactKind.TOOL_EXTRA_CONTENT,+ attachment=ReplayAttachment.TOOL_CALL,+ payload=extra_content,+ ),+ )diff --git a/src/free_claude_code/providers/openai_codex/provider.py b/src/free_claude_code/providers/openai_codex/provider.pyindex 9bc69b17..53882025 100644--- a/src/free_claude_code/providers/openai_codex/provider.py+++ b/src/free_claude_code/providers/openai_codex/provider.py@@ -20,9 +20,10 @@ from free_claude_code.core.diagnostics import (extract_upstream_error_detail,)from free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.openai_responses import (ResponsesConversionError,- ResponsesProviderStream,+ ResponsesEventDecoder,ResponsesStreamFailure,build_responses_provider_request,)@@ -180,8 +181,8 @@ class OpenAICodexProvider(BaseProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:- """Stream Responses output in Anthropic Messages format."""+ ) -> AsyncIterator[InferenceEvent]:+ """Stream private Responses output as canonical inference events."""tool_names = OpenAIToolNameCodec.from_request(request)body = self._build_body(request, reasoning=reasoning)@@ -217,7 +218,7 @@ class OpenAICodexProvider(BaseProvider):request_id: str | None,response_model: str,tool_names: OpenAIToolNameCodec,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:execution = self._admission.start_execution(request_id=request_id)provider_stream = self._run_stream_execution(body,@@ -250,10 +251,10 @@ class OpenAICodexProvider(BaseProvider):response_model: str,tool_names: OpenAIToolNameCodec,execution: ProviderExecution,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:"""Run one Codex execution while retaining Responses transport ownership."""recovery = RecoveryController()- message_id = f"msg_{uuid.uuid4()}"+ response_id = f"response_{uuid.uuid4().hex}"session_id = str(uuid.uuid4())authentication_recovered = Falsetrace_event(@@ -270,11 +271,10 @@ class OpenAICodexProvider(BaseProvider):)while execution.can_attempt:- stream = ResponsesProviderStream(- message_id=message_id,+ stream = ResponsesEventDecoder(+ response_id=response_id,model=response_model,input_tokens=input_tokens,- log_raw_events=self._config.log_raw_sse_events,tool_names=tool_names,)for event in stream.start():diff --git a/src/free_claude_code/providers/openai_responses/transport.py b/src/free_claude_code/providers/openai_responses/transport.pyindex ba5aaa80..38c2bd30 100644--- a/src/free_claude_code/providers/openai_responses/transport.py+++ b/src/free_claude_code/providers/openai_responses/transport.py@@ -15,9 +15,10 @@ from free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.openai_tool_names import OpenAIToolNameCodecfrom free_claude_code.core.diagnostics import extract_upstream_error_detailfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.openai_responses import (ResponsesConversionError,- ResponsesProviderStream,+ ResponsesEventDecoder,ResponsesStreamFailure,build_responses_provider_request,)@@ -70,13 +71,11 @@ class OpenAIResponsesTransport:admission: ProviderAdmissionController,provider_name: str,read_timeout_s: float,- log_raw_sse_events: bool,) -> None:self._client = clientself._admission = admissionself._provider_name = provider_nameself._read_timeout_s = read_timeout_s- self._log_raw_sse_events = log_raw_sse_eventsdef preflight_stream(self,@@ -94,7 +93,7 @@ class OpenAIResponsesTransport:request_id: str | None,response_model: str,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:body = self._build_body(request, reasoning=reasoning)tool_names = OpenAIToolNameCodec.from_request(request)return self._run_stream(@@ -127,7 +126,7 @@ class OpenAIResponsesTransport:request_id: str | None,response_model: str,tool_names: OpenAIToolNameCodec,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:execution = self._admission.start_execution(request_id=request_id)provider_stream = self._run_execution(body,@@ -160,9 +159,9 @@ class OpenAIResponsesTransport:response_model: str,tool_names: OpenAIToolNameCodec,execution: ProviderExecution,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:recovery = RecoveryController()- message_id = f"msg_{uuid.uuid4()}"+ response_id = f"response_{uuid.uuid4().hex}"trace_event(stage="provider",event="provider.request.sent",@@ -176,12 +175,11 @@ class OpenAIResponsesTransport:)while execution.can_attempt:- stream_adapter = ResponsesProviderStream(- message_id=message_id,+ stream_adapter = ResponsesEventDecoder(+ response_id=response_id,model=response_model,input_tokens=input_tokens,tool_names=tool_names,- log_raw_events=self._log_raw_sse_events,)for event in stream_adapter.start():for held in recovery.push(event):diff --git a/src/free_claude_code/providers/opencode/provider.py b/src/free_claude_code/providers/opencode/provider.pyindex 9e6e9bd6..d48f116d 100644--- a/src/free_claude_code/providers/opencode/provider.py+++ b/src/free_claude_code/providers/opencode/provider.py@@ -10,6 +10,7 @@ from free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -96,7 +97,6 @@ class OpenCodeProvider(OpenAIChatProvider):admission=admission,provider_name=profile.provider_name,read_timeout_s=config.http_read_timeout,- log_raw_sse_events=config.log_raw_sse_events,)async def cleanup(self) -> None:@@ -144,7 +144,7 @@ class OpenCodeProvider(OpenAIChatProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:return self._dispatch_stream(request,input_tokens=input_tokens,@@ -161,11 +161,11 @@ class OpenCodeProvider(OpenAIChatProvider):request_id: str | None,response_model: str,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:snapshot = await self._catalog.snapshot(request_id=request_id)route = self._require_route(snapshot, request.model)routed = _routed_request(request, route)- selected_stream: AsyncIterator[str] | None = None+ selected_stream: AsyncIterator[InferenceEvent] | None = Nonetry:if route.transport is OpenCodeUpstreamTransport.RESPONSES:self._responses.preflight_stream(routed, reasoning=reasoning)diff --git a/src/free_claude_code/providers/stream_recovery.py b/src/free_claude_code/providers/stream_recovery.pyindex 149bef2c..658f5c2f 100644--- a/src/free_claude_code/providers/stream_recovery.py+++ b/src/free_claude_code/providers/stream_recovery.py@@ -5,6 +5,12 @@ from collections.abc import Callablefrom dataclasses import dataclassfrom enum import StrEnum+from free_claude_code.core.inference import (+ InferenceEvent,+ ResponseStarted,+ inference_event_size,+)+from .failure_policy import RetryableProviderProtocolErrorEARLY_HOLDBACK_SECONDS = 0.75@@ -34,7 +40,7 @@ class RecoveryDecision:class RecoveryHoldbackBuffer:- """Briefly retain SSE so early cutoffs can be retried invisibly."""+ """Briefly retain canonical output so early cutoffs retry invisibly."""def __init__(self,@@ -46,26 +52,26 @@ class RecoveryHoldbackBuffer:self._holdback_seconds = holdback_secondsself._max_bytes = max_bytesself._now = now or time.monotonic- self._events: list[str] = []+ self._events: list[InferenceEvent] = []self._bytes = 0self._started_at: float | None = Noneself.committed = False- def push(self, event: str) -> list[str]:+ def push(self, event: InferenceEvent) -> list[InferenceEvent]:if self.committed:return [event]- if self._started_at is None:+ if self._started_at is None and not isinstance(event, ResponseStarted):self._started_at = self._now()self._events.append(event)- self._bytes += len(event.encode("utf-8", errors="replace"))- if (- self._bytes >= self._max_bytes- or self._now() - self._started_at >= self._holdback_seconds+ self._bytes += inference_event_size(event)+ if self._bytes >= self._max_bytes or (+ self._started_at is not None+ and self._now() - self._started_at >= self._holdback_seconds):return self.flush()return []- def flush(self) -> list[str]:+ def flush(self) -> list[InferenceEvent]:if self.committed:return []self.committed = True@@ -99,16 +105,16 @@ class RecoveryController:def has_buffered(self) -> bool:return self._holdback.has_buffered- def push(self, event: str) -> list[str]:+ def push(self, event: InferenceEvent) -> list[InferenceEvent]:return self._holdback.push(event)- def flush(self) -> list[str]:+ def flush(self) -> list[InferenceEvent]:return self._holdback.flush()def discard(self) -> None:self._holdback.discard()- def flush_uncommitted(self, decision: RecoveryDecision) -> list[str]:+ def flush_uncommitted(self, decision: RecoveryDecision) -> list[InferenceEvent]:if not decision.committed and decision.has_buffered:return self.flush()return []diff --git a/tests/api/model_fallback_support.py b/tests/api/model_fallback_support.pyindex ce7a4336..e01428ec 100644--- a/tests/api/model_fallback_support.py+++ b/tests/api/model_fallback_support.py@@ -9,10 +9,11 @@ from fastapi.testclient import TestClientfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequest-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.reasoning import ReasoningPolicyfrom tests.api.support import create_test_app+from tests.inference_support import text_event_streamdef execution_failure(message: str, *, retryable: bool = True) -> ExecutionFailure:@@ -24,54 +25,8 @@ def execution_failure(message: str, *, retryable: bool = True) -> ExecutionFailu)-def text_stream(text: str, *, model: str) -> list[str]:- return [- format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_fallback",- "type": "message",- "role": "assistant",- "model": model,- "content": [],- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": 3, "output_tokens": 0},- },- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": text},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+def text_stream(text: str, *, model: str) -> list[InferenceEvent]:+ return text_event_stream(text, model=model)class ControlledFallbackProvider:@@ -79,7 +34,7 @@ class ControlledFallbackProvider:self,*,failure: ExecutionFailure | None = None,- chunks_before_failure: tuple[str, ...] = (),+ chunks_before_failure: tuple[InferenceEvent, ...] = (),text: str | None = None,preflight_error: InvalidRequestError | None = None,) -> None:@@ -111,7 +66,7 @@ class ControlledFallbackProvider:request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:del input_tokens, request_id, reasoningself.stream_models.append(request.model)public_model = response_model or request.modeldiff --git a/tests/api/test_api.py b/tests/api/test_api.pyindex 7bbb8f8e..c2ed2a7b 100644--- a/tests/api/test_api.py+++ b/tests/api/test_api.py@@ -7,6 +7,7 @@ from free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom tests.api.support import create_test_app+from tests.inference_support import text_event_streamapp = create_test_app()@@ -20,8 +21,13 @@ _stream_response_calls: list = []async def _mock_stream_response(*args, **kwargs):"""Minimal async generator for streaming tests."""_stream_response_calls.append((args, kwargs))- yield "event: message_start\ndata: {}\n\n"- yield "[DONE]\n\n"+ for event in text_event_stream(+ "",+ model=kwargs.get("response_model", "test-model"),+ input_tokens=0,+ output_tokens=0,+ ):+ yield eventasync def _mock_pre_start_rate_limit(*args, **kwargs):diff --git a/tests/api/test_api_handlers.py b/tests/api/test_api_handlers.pyindex 6caea988..7752b793 100644--- a/tests/api/test_api_handlers.py+++ b/tests/api/test_api_handlers.py@@ -19,10 +19,11 @@ from free_claude_code.core.anthropic.models import (MessagesRequest,TokenCountRequest,)-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.openai_responses import OpenAIResponsesRequestfrom free_claude_code.core.reasoning import ReasoningPolicy+from tests.inference_support import text_event_stream_LEGACY_CLASSIFIER_SYSTEM = ("You are a security monitor. Respond with <block>yes</block> or <block>no</block>."@@ -38,14 +39,17 @@ _CLASSIFIER_USER = (class FakeProvider:- def __init__(self, events: list[str] | None = None) -> None:+ def __init__(+ self,+ events: list[InferenceEvent] | None = None,+ *,+ failure: ExecutionFailure | None = None,+ ) -> None:self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []self.requests: list[MessagesRequest] = []self.stream_kwargs: list[dict[str, Any]] = []- self.events = events or [- 'event: message_start\ndata: {"type":"message_start"}\n\n',- 'event: message_stop\ndata: {"type":"message_stop"}\n\n',- ]+ self.events = text_event_stream("ok") if events is None else events+ self.failure = failuredef preflight_stream(self, request: MessagesRequest, *, reasoning: ReasoningPolicy@@ -66,7 +70,7 @@ class FakeProvider:request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:self.requests.append(request)self.stream_kwargs.append({@@ -78,6 +82,8 @@ class FakeProvider:)for event in self.events:yield event+ if self.failure is not None:+ raise self.failureasync def _streaming_body_text(response: StreamingResponse) -> str:@@ -158,56 +164,13 @@ async def test_messages_handler_preflight_invalid_request_stays_http_error(@pytest.mark.asyncioasync def test_messages_handler_aggregates_provider_stream_when_stream_false() -> None:provider = FakeProvider(- [- format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_test",- "type": "message",- "role": "assistant",- "content": [],- "model": "test-model",- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": 7, "output_tokens": 1},- },- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "OK"},- },- ),- format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 0}- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {- "input_tokens": 20,- "output_tokens": 2,- "cache_read_input_tokens": 10,- },- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+ text_event_stream(+ "OK",+ model="test-model",+ input_tokens=20,+ output_tokens=2,+ cache_read_input_tokens=10,+ ))handler = MessagesHandler(Settings(), provider_resolver=lambda _: provider)request = MessagesRequest(@@ -222,7 +185,7 @@ async def test_messages_handler_aggregates_provider_stream_when_stream_false() -assert isinstance(response, JSONResponse)assert response.headers["content-type"].startswith("application/json")body = _json_response_content(response)- assert body["id"] == "msg_test"+ assert body["id"].startswith("msg_")assert body["type"] == "message"assert body["role"] == "assistant"assert body["model"] == "test-model"@@ -238,15 +201,13 @@ async def test_messages_handler_aggregates_provider_stream_when_stream_false() -@pytest.mark.asyncioasync def test_messages_handler_returns_error_json_for_stream_false_sse_error() -> None:provider = FakeProvider(- [- format_sse_event(- "error",- {- "type": "error",- "error": {"type": "api_error", "message": "upstream failed"},- },- )- ]+ [],+ failure=ExecutionFailure(+ kind=FailureKind.UPSTREAM,+ status_code=500,+ message="upstream failed",+ retryable=False,+ ),)handler = MessagesHandler(Settings(), provider_resolver=lambda _: provider)request = MessagesRequest(@@ -269,51 +230,15 @@ async def test_messages_handler_returns_error_json_for_stream_false_sse_error()@pytest.mark.asyncioasync def test_messages_handler_discards_partial_stream_false_output_on_error() -> None:+ partial = text_event_stream("incomplete", model="test-model")[:3]provider = FakeProvider(- [- format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_partial",- "type": "message",- "role": "assistant",- "content": [],- "model": "test-model",- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": 1, "output_tokens": 1},- },- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "incomplete"},- },- ),- format_sse_event(- "error",- {- "type": "error",- "error": {- "type": "overloaded_error",- "message": "provider overloaded",- },- },- ),- ]+ partial,+ failure=ExecutionFailure(+ kind=FailureKind.OVERLOADED,+ status_code=529,+ message="provider overloaded",+ retryable=False,+ ),)handler = MessagesHandler(Settings(), provider_resolver=lambda _: provider)request = MessagesRequest(@@ -347,7 +272,7 @@ async def test_messages_handler_stream_false_provider_exception_keeps_status() -request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:self.requests.append(request)self.stream_kwargs.append({@@ -363,7 +288,7 @@ async def test_messages_handler_stream_false_provider_exception_keeps_status() -message="upstream is busy",retryable=True,)- yield "unreachable"+ yield text_event_stream("unreachable")[0]provider = FailingProvider()handler = MessagesHandler(Settings(), provider_resolver=lambda _: provider)diff --git a/tests/api/test_execution_failure_contract.py b/tests/api/test_execution_failure_contract.pyindex 7a05200e..770a5b4c 100644--- a/tests/api/test_execution_failure_contract.py+++ b/tests/api/test_execution_failure_contract.py@@ -11,8 +11,12 @@ from fastapi.testclient import TestClientfrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceStreamLedger,+ ResponseStarted,+)from free_claude_code.core.reasoning import ReasoningPolicyfrom tests.api.support import create_test_app@@ -24,7 +28,7 @@ class CanonicalFailureProvider:def __init__(self,- chunks: list[str],+ chunks: list[InferenceEvent],*,kind: FailureKind,status_code: int,@@ -45,7 +49,7 @@ class CanonicalFailureProvider:self,_request: object,**kwargs: Any,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:self.stream_kwargs.append(kwargs)for chunk in self._chunks:yield chunk@@ -89,11 +93,11 @@ class StalledProvider:request_id: str,response_model: str,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:del input_tokens, request_id, response_model, reasoningtry:await asyncio.Event().wait()- yield ""+ yield ResponseStarted("response_unreachable", "test-model")finally:self.close_calls += 1@@ -115,33 +119,13 @@ def _responses_payload() -> dict[str, object]:}-def _partial_anthropic_stream(*, close_block: bool) -> list[str]:- chunks = [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": _PARTIAL_CONTENT},- },- ),- ]+def _partial_anthropic_stream(*, close_block: bool) -> list[InferenceEvent]:+ ledger = InferenceStreamLedger("response_partial", "test-model")+ chunks: list[InferenceEvent] = [ledger.start_response()]+ chunks.extend(ledger.ensure_text_block())+ chunks.append(ledger.emit_text_delta(_PARTIAL_CONTENT))if close_block:- chunks.append(- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- )- )+ chunks.append(ledger.stop_text_block())return chunks@@ -168,7 +152,9 @@ def _terminal_trace(trace_mock: MagicMock) -> dict[str, Any]:)-def _grouped_rate_limit_provider(chunks: list[str]) -> CanonicalFailureProvider:+def _grouped_rate_limit_provider(+ chunks: list[InferenceEvent],+) -> CanonicalFailureProvider:return CanonicalFailureProvider(chunks,kind=FailureKind.RATE_LIMIT,@@ -179,7 +165,7 @@ def _grouped_rate_limit_provider(chunks: list[str]) -> CanonicalFailureProvider:)-def _timeout_provider(chunks: list[str]) -> CanonicalFailureProvider:+def _timeout_provider(chunks: list[InferenceEvent]) -> CanonicalFailureProvider:return CanonicalFailureProvider(chunks,kind=FailureKind.TIMEOUT,diff --git a/tests/api/test_model_fallback.py b/tests/api/test_model_fallback.pyindex 9001fe7e..08460fc3 100644--- a/tests/api/test_model_fallback.py+++ b/tests/api/test_model_fallback.py@@ -4,7 +4,6 @@ import pytestfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom tests.api.model_fallback_support import (ControlledFallbackProvider,@@ -124,10 +123,7 @@ def test_lazy_fallback_preflight_error_remains_ordinary(def test_postframe_failure_never_opens_fallback_for_streaming_messages() -> None:- first = format_sse_event(- "message_start",- {"type": "message_start", "message": {}},- )+ first = text_stream("unused", model="nvidia_nim/primary-model")[0]primary = ControlledFallbackProvider(chunks_before_failure=(first,),failure=execution_failure("primary failed after start"),@@ -145,22 +141,7 @@ def test_postframe_failure_never_opens_fallback_for_streaming_messages() -> Nonedef test_postframe_failure_never_opens_fallback_for_responses() -> None:- first = format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_primary",- "type": "message",- "role": "assistant",- "model": "nvidia_nim/primary-model",- "content": [],- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": 3, "output_tokens": 0},- },- },- )+ first = text_stream("unused", model="nvidia_nim/primary-model")[0]primary = ControlledFallbackProvider(chunks_before_failure=(first,),failure=execution_failure("primary failed after start"),diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.pyindex 4d10355d..04184cf1 100644--- a/tests/api/test_openai_responses.py+++ b/tests/api/test_openai_responses.py@@ -6,19 +6,36 @@ from fastapi.testclient import TestClientfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ResponseStarted,+ ToolCallKind,+)from free_claude_code.core.reasoning import (ReasoningControl,ReasoningEffort,ReasoningPolicy,)from tests.api.support import create_test_app+from tests.inference_support import reported_usageclass FakeProvider:- def __init__(self, chunks: list[str]) -> None:+ def __init__(+ self,+ chunks: list[InferenceEvent],+ *,+ failure: Exception | None = None,+ ) -> None:self.chunks = chunks+ self.failure = failureself.preflight_stream = MagicMock()self.requests: list[Any] = []self.stream_kwargs: list[dict[str, Any]] = []@@ -28,6 +45,8 @@ class FakeProvider:self.stream_kwargs.append(_kwargs)for chunk in self.chunks:yield chunk+ if self.failure is not None:+ raise self.failureclass PreStartFailingProvider(FakeProvider):@@ -43,12 +62,12 @@ class PreStartFailingProvider(FakeProvider):message="upstream is busy",retryable=True,)- yield "unreachable"+ yield ResponseStarted("response_unreachable", "test-model")class PostStartFailingProvider(FakeProvider):def __init__(self) -> None:- super().__init__([format_sse_event("message_start", {"type": "message_start"})])+ super().__init__([ResponseStarted("response_test", "test-model")])async def stream_response(self, request_data, **_kwargs):self.requests.append(request_data)@@ -541,18 +560,8 @@ def test_create_response_accepts_codex_custom_tool_request() -> None:def test_create_response_stream_provider_error_returns_response_failed() -> None:provider = FakeProvider(- [- format_sse_event(- "error",- {- "type": "error",- "error": {- "type": "api_error",- "message": "provider failed",- },- },- )- ]+ [ResponseStarted("response_test", "test-model")],+ failure=RuntimeError("provider failed"),)app = create_test_app()with (@@ -770,292 +779,114 @@ def test_create_response_unsupported_tool_returns_openai_error(assert "Unsupported Responses tool type" in payload["error"]["message"]-def _anthropic_text_stream(text: str, *, stop_reason: str = "end_turn") -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": text},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": stop_reason, "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+def _anthropic_text_stream(+ text: str,+ *,+ stop_reason: str = "end_turn",+) -> list[InferenceEvent]:+ ledger = InferenceStreamLedger("response_test", "test-model", 3)+ events: list[InferenceEvent] = [ledger.start_response()]+ events.extend(ledger.ensure_text_block())+ events.append(ledger.emit_text_delta(text))+ events.extend(ledger.close_all_blocks())+ finish_reason = (+ FinishReason.OUTPUT_LIMIT+ if stop_reason == "max_tokens"+ else FinishReason.END_TURN+ )+ events.extend(+ ledger.finish_events(+ finish_reason,+ reported_usage(input_tokens=3, output_tokens=4),+ )+ )+ return eventsdef _anthropic_tool_stream(- tool_name: str = "echo", partial_json: str = '{"value":"FCC"}'-) -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": tool_name,- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {- "type": "input_json_delta",- "partial_json": partial_json,- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "tool_use", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]---def _anthropic_reasoning_text_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {- "type": "thinking_delta",- "thinking": "provider reasoning",- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "provider answer"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]---def _anthropic_interleaved_reasoning_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "thinking_delta", "thinking": "first thought"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "first answer"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 2,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": "echo",- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 2,- "delta": {- "type": "input_json_delta",- "partial_json": '{"value":"FCC"}',- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 2},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 3,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 3,- "delta": {"type": "thinking_delta", "thinking": "second thought"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 3},- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 4,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 4,- "delta": {"type": "text_delta", "text": "final answer"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 4},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]---def _anthropic_redacted_thinking_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {- "type": "redacted_thinking",- "data": "opaque-redacted",- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+ tool_name: str = "echo",+ partial_json: str = '{"value":"FCC"}',+) -> list[InferenceEvent]:+ ledger = InferenceStreamLedger("response_test", "test-model", 3)+ events: list[InferenceEvent] = [ledger.start_response()]+ events.append(+ ledger.start_tool_block(+ 0,+ "toolu_1",+ tool_name,+ kind=ToolCallKind.FUNCTION,+ )+ )+ events.append(ledger.emit_tool_delta(0, partial_json))+ events.append(ledger.stop_tool_block(0))+ events.extend(+ ledger.finish_events(+ FinishReason.TOOL_CALLS,+ reported_usage(input_tokens=3, output_tokens=4),+ )+ )+ return events+++def _anthropic_reasoning_text_stream() -> list[InferenceEvent]:+ ledger = InferenceStreamLedger("response_test", "test-model", 3)+ events: list[InferenceEvent] = [ledger.start_response()]+ events.extend(ledger.ensure_reasoning_block())+ events.append(ledger.emit_reasoning_delta("provider reasoning"))+ events.extend(ledger.ensure_text_block())+ events.append(ledger.emit_text_delta("provider answer"))+ events.extend(ledger.close_all_blocks())+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=3, output_tokens=4),+ )+ )+ return events+++def _anthropic_interleaved_reasoning_stream() -> list[InferenceEvent]:+ ledger = InferenceStreamLedger("response_test", "test-model", 3)+ events: list[InferenceEvent] = [ledger.start_response()]+ events.extend(ledger.ensure_reasoning_block())+ events.append(ledger.emit_reasoning_delta("first thought"))+ events.extend(ledger.ensure_text_block())+ events.append(ledger.emit_text_delta("first answer"))+ events.extend(ledger.close_content_blocks())+ events.append(ledger.start_tool_block(0, "toolu_1", "echo"))+ events.append(ledger.emit_tool_delta(0, '{"value":"FCC"}'))+ events.append(ledger.stop_tool_block(0))+ events.extend(ledger.ensure_reasoning_block())+ events.append(ledger.emit_reasoning_delta("second thought"))+ events.extend(ledger.ensure_text_block())+ events.append(ledger.emit_text_delta("final answer"))+ events.extend(ledger.close_all_blocks())+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=3, output_tokens=4),+ )+ )+ return events+++def _anthropic_redacted_thinking_stream() -> list[InferenceEvent]:+ ledger = InferenceStreamLedger("response_test", "test-model", 3)+ events: list[InferenceEvent] = [ledger.start_response()]+ events.extend(+ ledger.emit_reasoning_artifact(+ ReplayArtifact(+ origin=ReplayArtifactOrigin.ANTHROPIC,+ kind=ReplayArtifactKind.REDACTED_THINKING,+ attachment=ReplayAttachment.REASONING,+ payload="opaque-redacted",+ )+ )+ )+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=3, output_tokens=4),+ )+ )+ return eventsdiff --git a/tests/api/test_request_lifetime.py b/tests/api/test_request_lifetime.pyindex 103624a7..a75d70dc 100644--- a/tests/api/test_request_lifetime.py+++ b/tests/api/test_request_lifetime.py@@ -22,7 +22,7 @@ from free_claude_code.application.ports import ()from free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic import MessagesRequest-from free_claude_code.core.anthropic.streaming import format_sse_event+from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedgerfrom free_claude_code.core.reasoning import ReasoningPolicy@@ -378,7 +378,7 @@ async def test_outer_cancellation_drains_both_owned_tasks() -> None:class _ControlledProvider:- def __init__(self, chunks: tuple[str, ...]) -> None:+ def __init__(self, chunks: tuple[InferenceEvent, ...]) -> None:self._chunks = chunksself.blocked = asyncio.Event()self.closed = asyncio.Event()@@ -400,7 +400,7 @@ class _ControlledProvider:request_id: str,response_model: str,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:del input_tokens, response_model, reasoningself.request_ids.append(request_id)try:@@ -454,44 +454,16 @@ class _Requests:return ()-def _message_start() -> str:- return format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_lifetime",- "type": "message",- "role": "assistant",- "model": "test-model",- "content": [],- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": 1, "output_tokens": 0},- },- },- )+def _message_start() -> InferenceEvent:+ return InferenceStreamLedger("msg_lifetime", "test-model", 1).start_response()-def _partial_message_stream() -> tuple[str, ...]:+def _partial_message_stream() -> tuple[InferenceEvent, ...]:+ ledger = InferenceStreamLedger("msg_lifetime", "test-model", 1)return (- _message_start(),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "partial"},- },- ),+ ledger.start_response(),+ ledger.start_text_block(),+ ledger.emit_text_delta("partial"),)diff --git a/tests/api/test_safe_logging.py b/tests/api/test_safe_logging.pyindex 8c718473..31cf00ba 100644--- a/tests/api/test_safe_logging.py+++ b/tests/api/test_safe_logging.py@@ -10,8 +10,10 @@ from free_claude_code.api import request_errorsfrom free_claude_code.api.handlers import MessagesHandler, TokenCountHandlerfrom free_claude_code.application import executionfrom free_claude_code.config.settings import Settings-from free_claude_code.core.anthropic import AnthropicStreamLedger+from free_claude_code.core.anthropic import AnthropicEventPresenterfrom free_claude_code.core.anthropic.models import Message, MessagesRequest+from free_claude_code.core.inference import InferenceStreamLedger+from tests.inference_support import text_event_stream@pytest.mark.asyncio@@ -21,7 +23,8 @@ async def test_create_message_skips_full_payload_debug_log_by_default():mock_provider = MagicMock()async def fake_stream(*_a, **_kw):- yield "event: ping\ndata: {}\n\n"+ for event in text_event_stream("ok"):+ yield eventmock_provider.stream_response = fake_streamservice = MessagesHandler(settings, provider_resolver=lambda _: mock_provider)@@ -50,7 +53,8 @@ async def test_create_message_logs_full_payload_when_opt_in():mock_provider = MagicMock()async def fake_stream(*_a, **_kw):- yield "event: ping\ndata: {}\n\n"+ for event in text_event_stream("ok"):+ yield eventmock_provider.stream_response = fake_streamservice = MessagesHandler(settings, provider_resolver=lambda _: mock_provider)@@ -67,22 +71,24 @@ async def test_create_message_logs_full_payload_when_opt_in():assert any(k == "FULL_PAYLOAD [{}]: {}" for k in keys)-def test_stream_ledger_default_debug_has_no_serialized_json_content():+def test_anthropic_presenter_default_debug_has_no_serialized_json_content():with patch("free_claude_code.core.anthropic.streaming.emitter.logger.debug") as mock_debug:- ledger = AnthropicStreamLedger("msg_x", "m", 1, log_raw_events=False)- ledger.message_start()+ ledger = InferenceStreamLedger("response_x", "m", 1)+ presenter = AnthropicEventPresenter(log_raw_events=False)+ presenter.present(ledger.start_response())assert mock_debug.call_count == 0-def test_stream_ledger_raw_logging_includes_event_body_when_enabled():+def test_anthropic_presenter_raw_logging_includes_event_body_when_enabled():with patch("free_claude_code.core.anthropic.streaming.emitter.logger.debug") as mock_debug:- ledger = AnthropicStreamLedger("msg_x", "m", 1, log_raw_events=True)- ledger.message_start()+ ledger = InferenceStreamLedger("response_x", "m", 1)+ presenter = AnthropicEventPresenter(log_raw_events=True)+ presenter.present(ledger.start_response())assert mock_debug.call_count == 1message = str(mock_debug.call_args)diff --git a/tests/api/test_web_server_tools.py b/tests/api/test_web_server_tools.pyindex d0dca6ff..c1f475a6 100644--- a/tests/api/test_web_server_tools.py+++ b/tests/api/test_web_server_tools.py@@ -49,11 +49,16 @@ from free_claude_code.core.anthropic.stream_contracts import (parse_sse_text,text_content,)-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+)from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.core.version import package_versionfrom free_claude_code.messaging.event_parser import parse_cli_event+from tests.inference_support import reported_usage, text_event_stream_STRICT_EGRESS = WebFetchEgressPolicy(allow_private_network_targets=False,@@ -111,7 +116,7 @@ class ScriptedSelectionProvider:def __init__(self,- events: list[str],+ events: list[InferenceEvent],*,failure: ExecutionFailure | None = None,failure_after_events: bool = False,@@ -139,7 +144,7 @@ class ScriptedSelectionProvider:request_id: str,response_model: str,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:self.requests.append(request)self.stream_kwargs.append({@@ -163,53 +168,13 @@ class ScriptedSelectionProvider:self.close_count += 1-def _provider_text_events(text: str) -> list[str]:- return [- format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_provider",- "type": "message",- "role": "assistant",- "content": [],- "model": "gateway-model",- "stop_reason": None,- "stop_sequence": None,- "usage": {"input_tokens": 11, "output_tokens": 1},- },- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": text},- },- ),- format_sse_event(- "content_block_stop", {"type": "content_block_stop", "index": 0}- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": {"output_tokens": 3},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+def _provider_text_events(text: str) -> list[InferenceEvent]:+ return text_event_stream(+ text,+ model="gateway-model",+ input_tokens=11,+ output_tokens=3,+ )def _provider_tool_events(@@ -217,78 +182,30 @@ def _provider_tool_events(name: str = HIDDEN_WEB_SEARCH_NAME,arguments: dict[str, object] | None = None,additional_calls: int = 0,-) -> list[str]:+) -> list[InferenceEvent]:calls = [(name, arguments if arguments is not None else {"query": "selected"})]calls.extend((name, {"query": f"extra-{index}"}) for index in range(additional_calls))- events = [- format_sse_event(- "message_start",- {- "type": "message_start",- "message": {- "id": "msg_provider",- "type": "message",- "role": "assistant",- "content": [],- "model": "gateway-model",- "stop_reason": None,- "stop_sequence": None,- "usage": {- "input_tokens": 17,- "output_tokens": 1,- "cache_read_input_tokens": 5,- },- },- },- )- ]+ ledger = InferenceStreamLedger("msg_provider", "gateway-model", 17)+ events: list[InferenceEvent] = [ledger.start_response()]for index, (tool_name, tool_input) in enumerate(calls):events.extend([- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": index,- "content_block": {- "type": "tool_use",- "id": f"call_{index}",- "name": tool_name,- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": index,- "delta": {- "type": "input_json_delta",- "partial_json": json.dumps(tool_input),- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": index},- ),+ ledger.start_tool_block(index, f"call_{index}", tool_name),+ ledger.emit_tool_delta(index, json.dumps(tool_input)),+ ledger.stop_tool_block(index),])events.extend(- [- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "tool_use", "stop_sequence": None},- "usage": {"output_tokens": 9},- },+ ledger.finish_events(+ FinishReason.TOOL_CALLS,+ reported_usage(+ input_tokens=17,+ output_tokens=9,+ cache_read_input_tokens=5,),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+ ))return events@@ -578,7 +495,13 @@ async def test_automatic_web_search_replays_provider_response_when_declined()assert isinstance(response, StreamingResponse)- assert await _streaming_body_text(response) == "".join(events)+ replayed = parse_sse_text(await _streaming_body_text(response))+ assert_anthropic_stream_contract(replayed)+ assert text_content(replayed) == "No search needed"+ final_usage = next(+ event.data["usage"] for event in replayed if event.event == "message_delta"+ )+ assert final_usage == {"input_tokens": 11, "output_tokens": 3}search.assert_not_awaited()assert provider.close_count == 1assert len(provider.requests) == 1@@ -723,7 +646,7 @@ async def test_automatic_web_search_aggregates_when_stream_false(ids=["blank-query", "wrong-tool", "multiple-tools"],)async def test_automatic_web_search_rejects_malformed_provider_selection(- events: list[str],+ events: list[InferenceEvent],monkeypatch: pytest.MonkeyPatch,) -> None:provider = ScriptedSelectionProvider(events)diff --git a/tests/application/test_execution.py b/tests/application/test_execution.pyindex a9581a11..43076af8 100644--- a/tests/application/test_execution.py+++ b/tests/application/test_execution.py@@ -17,9 +17,14 @@ from free_claude_code.config.reasoning import ReasoningPreferencefrom free_claude_code.core.anthropic.models import Message, MessagesRequestfrom free_claude_code.core.async_iterators import AsyncCloseablefrom free_claude_code.core.failures import ExecutionFailure, FailureKind+from free_claude_code.core.inference import InferenceEvent, TextDeltafrom free_claude_code.core.reasoning import ReasoningPolicy+def _event(label: str) -> TextDelta:+ return TextDelta(block_id="test-block", delta=label)++class FakeProvider:def __init__(self) -> None:self.preflight_calls: list[tuple[MessagesRequest, ReasoningPolicy]] = []@@ -42,7 +47,7 @@ class FakeProvider:request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:self._record_stream_call(request,input_tokens=input_tokens,@@ -51,7 +56,7 @@ class FakeProvider:reasoning=reasoning,)try:- yield "event: message_stop\ndata: {}\n\n"+ yield _event("provider-event")finally:self.stream_close_calls += 1@@ -93,7 +98,7 @@ class DelayStep:self.seconds = seconds-type StreamStep = str | WaitStep | DelayStep | EmptyForever | BaseException+type StreamStep = TextDelta | WaitStep | DelayStep | EmptyForever | BaseExceptionclass ControlledProvider(FakeProvider):@@ -109,7 +114,7 @@ class ControlledProvider(FakeProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:self._record_stream_call(request,input_tokens=input_tokens,@@ -119,7 +124,7 @@ class ControlledProvider(FakeProvider):)try:for step in self._steps:- if isinstance(step, str):+ if isinstance(step, TextDelta):yield stepelif isinstance(step, WaitStep):step.started.set()@@ -127,8 +132,7 @@ class ControlledProvider(FakeProvider):elif isinstance(step, DelayStep):await asyncio.sleep(step.seconds)elif isinstance(step, EmptyForever):- while True:- yield ""+ await asyncio.Event().wait()else:raise stepfinally:@@ -168,7 +172,7 @@ class FailingStreamConstructionProvider(FakeProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:raise RuntimeError("stream construction failed")@@ -204,7 +208,7 @@ def _executor_stream(*,timeout_seconds: float,request_id: str,-) -> AsyncIterator[str]:+) -> AsyncIterator[InferenceEvent]:executor = ProviderExecutor(lambda _provider_id: provider,token_counter=lambda _messages, _system, _tools: 17,@@ -239,7 +243,7 @@ async def test_executor_uses_structural_provider_port_and_preflights_eagerly() -)assert provider.preflight_calls == [(request, ReasoningPolicy.on())]- assert [chunk async for chunk in stream] == ["event: message_stop\ndata: {}\n\n"]+ assert [chunk async for chunk in stream] == [_event("provider-event")]assert provider.stream_calls == [{"request": request,@@ -284,7 +288,7 @@ async def test_primary_success_never_resolves_fallback() -> None:request_id="req_primary_success",)- assert [chunk async for chunk in stream] == ["event: message_stop\ndata: {}\n\n"]+ assert [chunk async for chunk in stream] == [_event("provider-event")]assert resolved_ids == ["provider"]assert fallback.preflight_calls == []assert fallback.stream_calls == []@@ -296,7 +300,7 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primary):order: list[str] = []primary = ControlledProvider([_execution_failure("primary overloaded")])- fallback = ControlledProvider(["fallback-frame"])+ fallback = ControlledProvider([_event("fallback-frame")])def resolve(provider_id: str) -> FakeProvider:if provider_id == "fallback":@@ -324,7 +328,7 @@ async def test_retryable_preframe_failure_selects_fallback_after_closing_primary)]- assert chunks == ["fallback-frame"]+ assert chunks == [_event("fallback-frame")]assert order == ["fallback-resolved"]assert primary.stream_close_calls == 1assert fallback.stream_close_calls == 1@@ -398,7 +402,7 @@ async def test_multiple_retryable_failures_walk_fallbacks_in_order() -> None:providers = {"provider": ControlledProvider([_execution_failure("primary")]),"second": ControlledProvider([_execution_failure("second")]),- "third": ControlledProvider(["third-frame"]),+ "third": ControlledProvider([_event("third-frame")]),}resolved_ids: list[str] = []@@ -418,7 +422,7 @@ async def test_multiple_retryable_failures_walk_fallbacks_in_order() -> None:request_id="req_ordered_fallbacks",)- assert [chunk async for chunk in stream] == ["third-frame"]+ assert [chunk async for chunk in stream] == [_event("third-frame")]assert resolved_ids == ["provider", "second", "third"]assert all(provider.stream_close_calls == 1 for provider in providers.values())@@ -503,7 +507,7 @@ async def test_nonretryable_failure_never_resolves_fallback() -> None:@pytest.mark.asyncioasync def test_failure_after_first_frame_never_selects_fallback() -> None:primary_failure = _execution_failure("after frame")- primary = ControlledProvider(["first-frame", primary_failure])+ primary = ControlledProvider([_event("first-frame"), primary_failure])fallback = FakeProvider()resolved_ids: list[str] = []@@ -520,7 +524,7 @@ async def test_failure_after_first_frame_never_selects_fallback() -> None:request_id="req_committed",)- assert await anext(stream) == "first-frame"+ assert await anext(stream) == _event("first-frame")with pytest.raises(ExecutionFailure) as exc_info:await anext(stream)@@ -565,7 +569,7 @@ async def test_candidate_requests_are_isolated_from_provider_mutation() -> None:request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:request.messages[0].content = "mutated"async for chunk in super().stream_response(request,@@ -618,7 +622,7 @@ async def test_closing_executor_stream_closes_provider_stream_once() -> None:request_id="req_early_close",)- assert await anext(stream) == "event: message_stop\ndata: {}\n\n"+ assert await anext(stream) == _event("provider-event")assert isinstance(stream, AsyncCloseable)await stream.aclose()@@ -735,17 +739,19 @@ async def test_progress_timeout_before_first_chunk_is_canonical_and_correlated()async def test_progress_timeout_renews_after_output_without_crossing_yield() -> None:second_wait = WaitStep()third_wait = WaitStep()- provider = ControlledProvider(["first", second_wait, "second", third_wait, "third"])+ provider = ControlledProvider(+ [_event("first"), second_wait, _event("second"), third_wait, _event("third")]+ )stream = _executor_stream(provider,timeout_seconds=0.02,request_id="req_progress_renewal",)- assert await anext(stream) == "first"+ assert await anext(stream) == _event("first")await asyncio.sleep(0.05)second_wait.release.set()- assert await anext(stream) == "second"+ assert await anext(stream) == _event("second")with pytest.raises(ExecutionFailure) as exc_info:await anext(stream)diff --git a/tests/contracts/test_stream_contracts.py b/tests/contracts/test_stream_contracts.pyindex 4c164558..b386bd5d 100644--- a/tests/contracts/test_stream_contracts.py+++ b/tests/contracts/test_stream_contracts.py@@ -1,12 +1,8 @@-"""Stream/SSE contract tests. Strict transcript *ordering* is covered here for-``AnthropicStreamLedger`` output; for integration ordering, add messaging or API-integration tests.-"""+"""Cross-protocol stream ordering contracts."""from collections.abc import Iterablefrom free_claude_code.core.anthropic import (- AnthropicStreamLedger,ContentType,HeuristicToolParser,ThinkTagParser,@@ -19,6 +15,12 @@ from free_claude_code.core.anthropic.stream_contracts import (thinking_content,)from free_claude_code.core.anthropic.streaming import format_sse_event+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+)+from tests.inference_support import present_anthropic, reported_usagedef test_interleaved_thinking_text_blocks_are_valid() -> None:@@ -43,21 +45,28 @@ def test_split_think_tags_preserve_text_and_thinking() -> None:def test_mixed_reasoning_content_and_think_tags_keep_order() -> None:- builder = AnthropicStreamLedger("msg_contract", "contract-model")- chunks = [builder.message_start()]- chunks.extend(builder.ensure_thinking_block())- chunks.append(builder.emit_thinking_delta("reasoning field"))- chunks.extend(- _events_from_text_chunks([" visible <think>tagged</think> done"], builder)+ ledger = InferenceStreamLedger("response_contract", "contract-model")+ events: list[InferenceEvent] = [ledger.start_response()]+ events.extend(ledger.ensure_reasoning_block())+ events.append(ledger.emit_reasoning_delta("reasoning field"))+ events.extend(+ _events_from_text_chunks(+ [" visible <think>tagged</think> done"],+ ledger,+ )+ )+ events.extend(ledger.close_all_blocks())+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=0, output_tokens=10),+ ))- chunks.extend(builder.close_all_blocks())- chunks.append(builder.message_delta("end_turn", 10))- chunks.append(builder.message_stop())- events = parse_sse_text("".join(chunks))- assert_anthropic_stream_contract(events)- assert thinking_content(events) == "reasoning fieldtagged"- assert text_content(events) == " visible done"+ parsed = parse_sse_text("".join(present_anthropic(events)))+ assert_anthropic_stream_contract(parsed)+ assert thinking_content(parsed) == "reasoning fieldtagged"+ assert text_content(parsed) == " visible done"def test_redacted_thinking_block_start_stop_is_valid() -> None:@@ -133,62 +142,71 @@ def test_task_tool_arguments_force_foreground_execution() -> None:def _interleaved_thinking_text_events(parts: tuple[str, str, str, str],-) -> Iterable[str]:- builder = AnthropicStreamLedger("msg_contract", "contract-model")- yield builder.message_start()- yield from builder.ensure_thinking_block()- yield builder.emit_thinking_delta(parts[0])- yield from builder.ensure_text_block()- yield builder.emit_text_delta(parts[1])- yield from builder.ensure_thinking_block()- yield builder.emit_thinking_delta(parts[2])- yield from builder.ensure_text_block()- yield builder.emit_text_delta(parts[3])- yield from builder.close_all_blocks()- yield builder.message_delta("end_turn", 20)- yield builder.message_stop()+) -> Iterable[InferenceEvent]:+ ledger = InferenceStreamLedger("response_contract", "contract-model")+ yield ledger.start_response()+ yield from ledger.ensure_reasoning_block()+ yield ledger.emit_reasoning_delta(parts[0])+ yield from ledger.ensure_text_block()+ yield ledger.emit_text_delta(parts[1])+ yield from ledger.ensure_reasoning_block()+ yield ledger.emit_reasoning_delta(parts[2])+ yield from ledger.ensure_text_block()+ yield ledger.emit_text_delta(parts[3])+ yield from ledger.close_all_blocks()+ yield from ledger.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=0, output_tokens=20),+ )def _events_from_text_chunks(chunks: list[str],- builder: AnthropicStreamLedger | None = None,+ ledger: InferenceStreamLedger | None = None,*,enable_thinking: bool = True,-) -> list[str]:- sse = builder or AnthropicStreamLedger("msg_contract", "contract-model")- out: list[str] = [] if builder else [sse.message_start()]+) -> list[InferenceEvent]:+ stream = ledger or InferenceStreamLedger(+ "response_contract",+ "contract-model",+ )+ out: list[InferenceEvent] = [] if ledger else [stream.start_response()]parser = ThinkTagParser()for chunk in chunks:- out.extend(_emit_parser_parts(sse, parser.feed(chunk), enable_thinking))+ out.extend(_emit_parser_parts(stream, parser.feed(chunk), enable_thinking))remaining = parser.flush()if remaining is not None:- out.extend(_emit_parser_parts(sse, [remaining], enable_thinking))-- if builder is None:- out.extend(sse.close_all_blocks())- out.append(sse.message_delta("end_turn", 20))- out.append(sse.message_stop())+ out.extend(_emit_parser_parts(stream, [remaining], enable_thinking))++ if ledger is None:+ out.extend(stream.close_all_blocks())+ out.extend(+ stream.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=0, output_tokens=20),+ )+ )return outdef _emit_parser_parts(- builder: AnthropicStreamLedger,+ ledger: InferenceStreamLedger,parts: Iterable,enable_thinking: bool,-) -> list[str]:- out: list[str] = []+) -> list[InferenceEvent]:+ out: list[InferenceEvent] = []for part in parts:if part.type == ContentType.THINKING:if enable_thinking:- out.extend(builder.ensure_thinking_block())- out.append(builder.emit_thinking_delta(part.content))+ out.extend(ledger.ensure_reasoning_block())+ out.append(ledger.emit_reasoning_delta(part.content))continue- out.extend(builder.ensure_text_block())- out.append(builder.emit_text_delta(part.content))+ out.extend(ledger.ensure_text_block())+ out.append(ledger.emit_text_delta(part.content))return out-def _parse_builder_events(chunks: Iterable[str]):- return parse_sse_text("".join(chunks))+def _parse_builder_events(events: Iterable[InferenceEvent]):+ return parse_sse_text("".join(present_anthropic(events)))diff --git a/tests/core/anthropic/test_stream_ledger.py b/tests/core/anthropic/test_stream_ledger.pyindex 3a20fb5f..7f08ed17 100644--- a/tests/core/anthropic/test_stream_ledger.py+++ b/tests/core/anthropic/test_stream_ledger.py@@ -1,22 +1,33 @@-"""Tests for the provider-neutral Anthropic stream ledger."""+"""Contracts for the canonical ledger and Anthropic event presenter."""-import json+from typing import castfrom unittest.mock import patchimport pytest-from free_claude_code.core.anthropic.streaming import (- AnthropicStreamLedger,- StreamBlockLedger,- ToolSchema,- map_stop_reason,+from free_claude_code.core.anthropic.stream_contracts import (+ assert_anthropic_stream_contract,+ parse_sse_text,)+from free_claude_code.core.anthropic.streaming import map_stop_reason+from free_claude_code.core.inference import (+ FinishReason,+ InferenceBlockLedger,+ InferenceStreamLedger,+ ReasoningBlockCompleted,+ TextBlockCompleted,+ TextBlockStarted,+ TokenMeasurement,+ ToolCallCompleted,+ UsageSource,+)+from tests.inference_support import present_anthropic, reported_usage-def _payload(event: str) -> dict:- return json.loads(- next(line[6:] for line in event.splitlines() if line.startswith("data:"))- )[email protected]("value", [True, -1, cast(int, 1.5)])+def test_token_measurement_rejects_non_integer_or_negative_values(value: int) -> None:+ with pytest.raises(ValueError, match="non-negative integers"):+ TokenMeasurement(value, UsageSource.REPORTED)@pytest.mark.parametrize(@@ -33,91 +44,131 @@ def test_map_stop_reason(upstream: str | None, anthropic: str) -> None:assert map_stop_reason(upstream) == anthropic-def test_stream_block_ledger_allocates_monotonic_indexes() -> None:- blocks = StreamBlockLedger()+def test_block_ledger_reuses_tool_state_by_upstream_index() -> None:+ blocks = InferenceBlockLedger()- assert (blocks.allocate_index(), blocks.allocate_index()) == (0, 1)+ assert blocks.ensure_tool_state(2) is blocks.ensure_tool_state(2)+ assert set(blocks.tool_states) == {2}-def test_message_lifecycle() -> None:- ledger = AnthropicStreamLedger("msg_1", "model", input_tokens=7)+def test_response_lifecycle_is_canonical_until_anthropic_presentation() -> None:+ ledger = InferenceStreamLedger("response_1", "model", input_tokens=7)+ events = [ledger.start_response()]+ events.extend(ledger.ensure_text_block())+ events.append(ledger.emit_text_delta("done"))+ events.extend(ledger.close_all_blocks())+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=7, output_tokens=3),+ )+ )- start = _payload(ledger.message_start())- delta = _payload(ledger.message_delta("end_turn", 3))- stop = _payload(ledger.message_stop())+ parsed = parse_sse_text("".join(present_anthropic(events)))- assert start["message"]["id"] == "msg_1"- assert start["message"]["usage"]["input_tokens"] == 7+ assert_anthropic_stream_contract(parsed)+ start = parsed[0].data["message"]+ assert start["id"].startswith("msg_")+ assert start["model"] == "model"+ assert start["usage"]["input_tokens"] == 7+ delta = next(event.data for event in parsed if event.event == "message_delta")assert delta["delta"]["stop_reason"] == "end_turn"assert delta["usage"]["output_tokens"] == 3- assert stop == {"type": "message_stop"}- assert ledger.has_terminal_message()-+ assert parsed[-1].data == {"type": "message_stop"}-def test_text_and_thinking_blocks_accumulate_content() -> None:- ledger = AnthropicStreamLedger("msg_1", "model")- ledger.start_thinking_block()- ledger.emit_thinking_delta("step")- ledger.stop_thinking_block()+def test_text_and_reasoning_blocks_accumulate_semantic_content() -> None:+ ledger = InferenceStreamLedger("response_1", "model")+ ledger.start_response()+ ledger.start_reasoning_block()+ ledger.emit_reasoning_delta("step")+ reasoning = ledger.stop_reasoning_block()ledger.start_text_block()ledger.emit_text_delta("answer")- ledger.stop_text_block()+ text = ledger.stop_text_block()+ assert isinstance(reasoning, ReasoningBlockCompleted)+ assert reasoning.reasoning == "step"+ assert isinstance(text, TextBlockCompleted)+ assert text.text == "answer"assert ledger.accumulated_reasoning == "step"assert ledger.accumulated_text == "answer"-def test_ensure_block_switches_close_the_previous_kind() -> None:- ledger = AnthropicStreamLedger("msg_1", "model")- ledger.start_thinking_block()+def test_ensure_block_switch_closes_previous_kind() -> None:+ ledger = InferenceStreamLedger("response_1", "model")+ ledger.start_response()+ ledger.start_reasoning_block()events = list(ledger.ensure_text_block())- assert [_payload(event)["type"] for event in events] == [- "content_block_stop",- "content_block_start",- ]- assert not ledger.blocks.thinking_started+ assert isinstance(events[0], ReasoningBlockCompleted)+ assert isinstance(events[1], TextBlockStarted)+ assert not ledger.blocks.reasoning_startedassert ledger.blocks.text_started-def test_tool_blocks_drive_stop_reason_and_salvage() -> None:- ledger = AnthropicStreamLedger("msg_1", "model")+def test_tool_blocks_drive_finish_reason() -> None:+ ledger = InferenceStreamLedger("response_1", "model")+ ledger.start_response()ledger.start_tool_block(0, "toolu_1", "Read")ledger.emit_tool_delta(0, '{"path":"test.py"}')- assert ledger.final_stop_reason("end_turn") == "tool_use"- assert ledger.can_salvage_tool_use(- {- "Read": ToolSchema(- name="Read",- input_schema={- "type": "object",- "properties": {"path": {"type": "string"}},- },- )- }- )+ assert ledger.final_finish_reason(FinishReason.END_TURN) is FinishReason.TOOL_CALLS-def test_close_unclosed_blocks_closes_each_block_once() -> None:- ledger = AnthropicStreamLedger("msg_1", "model")+def test_close_unclosed_blocks_closes_each_semantic_block_once() -> None:+ ledger = InferenceStreamLedger("response_1", "model")+ ledger.start_response()ledger.start_text_block()ledger.start_tool_block(0, "toolu_1", "Read")events = list(ledger.close_unclosed_blocks())assert len(events) == 2- assert all(_payload(event)["type"] == "content_block_stop" for event in events)+ assert isinstance(events[0], ToolCallCompleted)+ assert isinstance(events[1], TextBlockCompleted)assert list(ledger.close_unclosed_blocks()) == []+def test_parallel_tool_blocks_complete_independently() -> None:+ ledger = InferenceStreamLedger("response_1", "model")+ events = [ledger.start_response()]+ events.extend(+ [+ ledger.start_tool_block(0, "toolu_1", "Read"),+ ledger.start_tool_block(1, "toolu_2", "Write"),+ ledger.emit_tool_delta(0, '{"path":"README.md"}'),+ ledger.emit_tool_delta(1, '{"path":"notes.md"}'),+ ledger.stop_tool_block(0),+ ledger.stop_tool_block(1),+ ]+ )+ events.extend(+ ledger.finish_events(+ FinishReason.TOOL_CALLS,+ reported_usage(input_tokens=7, output_tokens=8),+ )+ )++ parsed = parse_sse_text("".join(present_anthropic(events)))++ assert_anthropic_stream_contract(parsed)+ starts = [+ event.data["content_block"]+ for event in parsed+ if event.event == "content_block_start"+ ]+ assert [block["id"] for block in starts] == ["toolu_1", "toolu_2"]+ assert [block["name"] for block in starts] == ["Read", "Write"]++def test_output_token_estimate_combines_shared_estimates_and_block_overhead() -> None:- ledger = AnthropicStreamLedger("msg_1", "model")- ledger.start_thinking_block()- ledger.emit_thinking_delta("why")- ledger.stop_thinking_block()+ ledger = InferenceStreamLedger("response_1", "model")+ ledger.start_response()+ ledger.start_reasoning_block()+ ledger.emit_reasoning_delta("why")+ ledger.stop_reasoning_block()ledger.start_text_block()ledger.emit_text_delta("abcd")ledger.stop_text_block()@@ -125,7 +176,7 @@ def test_output_token_estimate_combines_shared_estimates_and_block_overhead() ->ledger.emit_tool_delta(0, "{}")with patch(- "free_claude_code.core.anthropic.streaming.ledger.estimate_text_tokens",+ "free_claude_code.core.inference.ledger.estimate_text_tokens",side_effect=len,):assert ledger.estimate_output_tokens() == 40diff --git a/tests/core/openai_responses/test_provider_stream.py b/tests/core/openai_responses/test_provider_stream.pyindex 53a2b12f..79c2a1cf 100644--- a/tests/core/openai_responses/test_provider_stream.py+++ b/tests/core/openai_responses/test_provider_stream.py@@ -6,15 +6,16 @@ from free_claude_code.core.anthropic.stream_contracts import (parse_sse_text,thinking_content,)-from free_claude_code.core.openai_responses.provider_stream import (- ResponsesProviderStream,+from free_claude_code.core.openai_responses.provider_events import (+ ResponsesEventDecoder,ResponsesStreamFailure,)+from tests.inference_support import present_anthropic-def test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() -> None:- stream = ResponsesProviderStream(- message_id="msg_test",+def test_responses_decoder_preserves_reasoning_tools_usage_and_ids() -> None:+ stream = ResponsesEventDecoder(+ response_id="response_test",model="openai/gpt-test",input_tokens=12,)@@ -102,7 +103,7 @@ def test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() ->))- events = parse_sse_text("".join(output))+ events = parse_sse_text("".join(present_anthropic(output)))assert_anthropic_stream_contract(events)assert thinking_content(events) == "reasoning"starts = [@@ -140,13 +141,13 @@ def test_responses_provider_stream_preserves_reasoning_tools_usage_and_ids() ->(None, 5, 12),],)-def test_responses_provider_stream_ignores_invalid_cache_partitions(+def test_responses_decoder_ignores_invalid_cache_partitions(input_tokens: int | None,cached_tokens: int | bool,expected_input_tokens: int,) -> None:- stream = ResponsesProviderStream(- message_id="msg_test",+ stream = ResponsesEventDecoder(+ response_id="response_test",model="openai/gpt-test",input_tokens=12,)@@ -168,7 +169,7 @@ def test_responses_provider_stream_ignores_invalid_cache_partitions(message_delta = next(event- for event in parse_sse_text("".join(output))+ for event in parse_sse_text("".join(present_anthropic(output)))if event.event == "message_delta")assert message_delta.data["usage"] == {@@ -177,9 +178,9 @@ def test_responses_provider_stream_ignores_invalid_cache_partitions(}-def test_responses_provider_stream_surfaces_failed_event() -> None:- stream = ResponsesProviderStream(- message_id="msg_test",+def test_responses_decoder_surfaces_failed_event() -> None:+ stream = ResponsesEventDecoder(+ response_id="response_test",model="gpt-test",input_tokens=0,)@@ -200,14 +201,14 @@ def test_responses_provider_stream_surfaces_failed_event() -> None:assert exc_info.value.code == "server_error"-def test_responses_provider_stream_restores_added_and_done_only_tool_names() -> None:+def test_responses_decoder_restores_added_and_done_only_tool_names() -> None:originals = ("mcp__responses_added__" + "x" * 70,"mcp__responses_done__" + "y" * 70,)codec = OpenAIToolNameCodec.from_names(originals)- stream = ResponsesProviderStream(- message_id="msg_test",+ stream = ResponsesEventDecoder(+ response_id="response_test",model="gpt-test",input_tokens=0,tool_names=codec,@@ -255,7 +256,7 @@ def test_responses_provider_stream_restores_added_and_done_only_tool_names() ->))- event_text = "".join(output)+ event_text = "".join(present_anthropic(output))starts = [event.data["content_block"]for event in parse_sse_text(event_text)diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.pyindex a4419512..d4d0f082 100644--- a/tests/core/openai_responses/test_sse.py+++ b/tests/core/openai_responses/test_sse.py@@ -1,29 +1,34 @@+"""OpenAI Responses presentation contracts for canonical inference events."""+from collections.abc import AsyncIterator-from typing import Any-from unittest.mock import patchimport pytestfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_text-from free_claude_code.core.anthropic.streaming import format_sse_eventfrom free_claude_code.core.async_iterators import AsyncCloseablefrom free_claude_code.core.failures import ExecutionFailure, FailureKind-from free_claude_code.core.openai_responses import (- OpenAIResponsesAdapter,- OpenAIResponsesRequest,+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+ ReplayArtifact,+ ReplayArtifactKind,+ ReplayArtifactOrigin,+ ReplayAttachment,+ ResponseStarted,)-from free_claude_code.core.openai_responses.anthropic_sse import (- AnthropicSseEvent,- iter_sse_events,+from free_claude_code.core.openai_responses import OpenAIResponsesRequest+from free_claude_code.core.openai_responses.presenter import (+ ResponsesEventPresenter,+ iter_responses_sse_from_events,)--_ADAPTER = OpenAIResponsesAdapter()+from tests.inference_support import reported_usage, text_event_stream-class _CloseTrackingAsyncIterator:+class _CloseTrackingEvents:def __init__(self,- values: list[Any],+ values: list[InferenceEvent],*,iteration_error: Exception | None = None,close_error: Exception | None = None,@@ -33,10 +38,10 @@ class _CloseTrackingAsyncIterator:self._close_error = close_errorself.close_calls = 0- def __aiter__(self) -> _CloseTrackingAsyncIterator:+ def __aiter__(self) -> _CloseTrackingEvents:return self- async def __anext__(self) -> Any:+ async def __anext__(self) -> InferenceEvent:try:return next(self._values)except StopIteration:@@ -52,1040 +57,199 @@ class _CloseTrackingAsyncIterator:raise self._close_error-def _responses_sse(- chunks: AsyncIterator[str], request: dict[str, Any]-) -> AsyncIterator[str]:- return _ADAPTER.iter_sse_from_anthropic(- chunks,- OpenAIResponsesRequest.model_validate(request),- )---async def test_anthropic_sse_parser_closes_source_after_normal_completion() -> None:- source = _CloseTrackingAsyncIterator(- [format_sse_event("message_start", {"type": "message_start"})]- )-- events = [event async for event in iter_sse_events(source)]-- assert [event.event for event in events] == ["message_start"]- assert source.close_calls == 1---async def test_anthropic_sse_parser_closes_source_on_early_close() -> None:- source = _CloseTrackingAsyncIterator(- [- format_sse_event("message_start", {"type": "message_start"}),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- )- events = iter_sse_events(source)-- assert (await anext(events)).event == "message_start"- assert isinstance(events, AsyncCloseable)- await events.aclose()-- assert source.close_calls == 1---async def test_anthropic_sse_parser_preserves_source_failure() -> None:- source_failure = RuntimeError("source failed")- source = _CloseTrackingAsyncIterator(- [],- iteration_error=source_failure,- close_error=RuntimeError("close failed"),- )+def _request(**overrides: object) -> OpenAIResponsesRequest:+ payload: dict[str, object] = {+ "model": "nvidia_nim/test-model",+ "input": "hello",+ "stream": True,+ }+ payload.update(overrides)+ return OpenAIResponsesRequest.model_validate(payload)- with pytest.raises(RuntimeError) as exc_info:- [event async for event in iter_sse_events(source)]- assert exc_info.value is source_failure- assert source.close_calls == 1+async def _aiter(events: list[InferenceEvent]) -> AsyncIterator[InferenceEvent]:+ for event in events:+ yield event-async def test_responses_transform_closes_direct_event_source_on_early_close() -> None:- events = _CloseTrackingAsyncIterator(- [- AnthropicSseEvent(- event="message_start",- data={"type": "message_start", "message": {}},- ),- AnthropicSseEvent(- event="message_stop",- data={"type": "message_stop"},- ),- ]- )- with patch(- "free_claude_code.core.openai_responses.stream.iter_sse_events",- return_value=events,- ):- stream = _responses_sse(- _aiter([]),- {"model": "nvidia_nim/test-model", "stream": True},+async def _collect(events: list[InferenceEvent]) -> list[str]:+ return [+ chunk+ async for chunk in iter_responses_sse_from_events(+ _aiter(events),+ _request(),)- assert parse_sse_text(await anext(stream))[0].event == "response.created"- assert isinstance(stream, AsyncCloseable)- await stream.aclose()-- assert events.close_calls == 1---async def test_responses_transform_preserves_direct_source_failure() -> None:- source_failure = RuntimeError("event source failed")- events = _CloseTrackingAsyncIterator(- [],- iteration_error=source_failure,- close_error=RuntimeError("event close failed"),- )- with (- patch(- "free_claude_code.core.openai_responses.stream.iter_sse_events",- return_value=events,- ),- pytest.raises(RuntimeError) as exc_info,- ):- [- chunk- async for chunk in _responses_sse(- _aiter([]),- {"model": "nvidia_nim/test-model", "stream": True},- )- ]-- assert exc_info.value is source_failure- assert events.close_calls == 1+ ]@pytest.mark.asyncio-async def test_anthropic_text_stream_converts_to_responses_sse() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_text_stream("Hello Codex")),- {"model": "nvidia_nim/test-model", "stream": True},+async def test_text_stream_has_one_stable_lifecycle_and_monotonic_sequences() -> None:+ chunks = await _collect(+ text_event_stream(+ "hello",+ model="public-model",+ input_tokens=5,+ output_tokens=2,))+ events = parse_sse_text("".join(chunks))- events = parse_sse_text(text)- event_names = [event.event for event in events]+ assert events[0].event == "response.created"+ assert events[-1].event == "response.completed"+ response_ids = {+ event.data["response"]["id"]+ for event in events+ if isinstance(event.data.get("response"), dict)+ }+ assert len(response_ids) == 1assert [event.data["sequence_number"] for event in events] == list(range(len(events)))- assert event_names[:3] == [- "response.created",- "response.output_item.added",- "response.content_part.added",- ]- assert "response.output_text.delta" in event_names- assert events[-1].event == "response.completed"- completed = events[-1].data["response"]- assert completed["output"][0]["content"][0]["text"] == "Hello Codex"- assert completed["parallel_tool_calls"] is True- assert completed["tool_choice"] == "auto"---async def test_max_tokens_stop_reason_converts_to_response_incomplete() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_text_stream("partial output", stop_reason="max_tokens")),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[-1].event == "response.incomplete"- assert "response.completed" not in [event.event for event in events]- incomplete = events[-1].data["response"]- assert incomplete["id"] == events[0].data["response"]["id"]- assert incomplete["status"] == "incomplete"- assert incomplete["incomplete_details"] == {"reason": "max_output_tokens"}- assert incomplete["error"] is None- assert incomplete["output"][0]["content"][0]["text"] == "partial output"- assert incomplete["usage"] == {- "input_tokens": 3,+ final = events[-1].data["response"]+ assert final["status"] == "completed"+ assert final["model"] == "nvidia_nim/test-model"+ assert final["output"][0]["content"][0]["text"] == "hello"+ assert final["usage"] == {+ "input_tokens": 5,"input_tokens_details": {"cached_tokens": 0},- "output_tokens": 4,+ "output_tokens": 2,"output_tokens_details": {"reasoning_tokens": 0},"total_tokens": 7,}@pytest.mark.asyncio-async def test_max_tokens_without_visible_output_is_still_incomplete() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(- [- format_sse_event(- "message_start", {"type": "message_start", "message": {}}- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "max_tokens"},- "usage": {"input_tokens": 3, "output_tokens": 64},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+async def test_reasoning_replay_and_tool_call_remain_semantic_until_presented() -> None:+ ledger = InferenceStreamLedger("response_internal", "provider-model", 3)+ replay = ReplayArtifact(+ origin=ReplayArtifactOrigin.OPENAI,+ kind=ReplayArtifactKind.ENCRYPTED_REASONING,+ attachment=ReplayAttachment.REASONING,+ payload="opaque",+ )+ events: list[InferenceEvent] = [ledger.start_response()]+ events.append(ledger.start_reasoning_block(artifacts=(replay,)))+ events.append(ledger.emit_reasoning_delta("inspect"))+ events.append(ledger.stop_reasoning_block())+ events.append(ledger.start_tool_block(0, "call_1", "Read"))+ events.append(ledger.emit_tool_delta(0, '{"path":"README.md"}'))+ events.append(ledger.stop_tool_block(0))+ events.extend(+ ledger.finish_events(+ FinishReason.TOOL_CALLS,+ reported_usage(+ input_tokens=3,+ output_tokens=8,+ reasoning_output_tokens=2,),- {"model": "nvidia_nim/test-model", "stream": True},))- incomplete = parse_sse_text(text)[-1]- assert incomplete.event == "response.incomplete"- assert incomplete.data["response"]["output"] == []- assert incomplete.data["response"]["incomplete_details"] == {- "reason": "max_output_tokens"+ parsed = parse_sse_text("".join(await _collect(events)))+ final = parsed[-1].data["response"]+ reasoning, tool = final["output"]+ assert reasoning["type"] == "reasoning"+ assert reasoning["encrypted_content"] == "opaque"+ assert tool == {+ "id": tool["id"],+ "type": "function_call",+ "status": "completed",+ "call_id": "call_1",+ "name": "Read",+ "arguments": '{"path":"README.md"}',}+ assert final["usage"]["output_tokens_details"] == {"reasoning_tokens": 2}@pytest.mark.asyncio-async def test_response_payload_preserves_explicit_request_options() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_text_stream("done")),- {- "model": "nvidia_nim/test-model",- "parallel_tool_calls": False,- "tool_choice": "none",- "temperature": 0.0,- "top_p": 0.0,- "max_output_tokens": 0,- },- )-- assert response["parallel_tool_calls"] is False- assert response["tool_choice"] == "none"- assert response["temperature"] == 0.0- assert response["top_p"] == 0.0- assert response["max_output_tokens"] == 0---async def test_response_payload_maps_explicit_null_options_to_wire_defaults() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_text_stream("done")),- {- "model": "nvidia_nim/test-model",- "parallel_tool_calls": None,- "tool_choice": None,- },- )-- assert response["parallel_tool_calls"] is True- assert response["tool_choice"] == "auto"---async def test_anthropic_tool_stream_converts_to_function_call_item() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_tool_stream()),- {"model": "nvidia_nim/test-model", "stream": True},+async def test_output_limit_maps_to_incomplete_response() -> None:+ ledger = InferenceStreamLedger("response_internal", "provider-model")+ events: list[InferenceEvent] = [ledger.start_response()]+ events.extend(ledger.ensure_text_block())+ events.append(ledger.emit_text_delta("partial"))+ events.extend(ledger.close_all_blocks())+ events.extend(+ ledger.finish_events(+ FinishReason.OUTPUT_LIMIT,+ reported_usage(input_tokens=1, output_tokens=2),))- events = parse_sse_text(text)- names = [event.event for event in events]- assert "response.function_call_arguments.delta" in names- assert "response.function_call_arguments.done" in names- completed = events[-1].data["response"]- function_call = completed["output"][0]- assert function_call["type"] == "function_call"- assert function_call["call_id"] == "toolu_1"- assert function_call["name"] == "echo"- assert function_call["arguments"] == '{"value":"FCC"}'---async def test_anthropic_function_tool_arguments_are_normalized() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_tool_stream(partial_json='{ "value" : "FCC" }')),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["output"][0]["arguments"] == '{"value":"FCC"}'+ parsed = parse_sse_text("".join(await _collect(events)))--async def test_anthropic_malformed_function_tool_arguments_fail_response() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_tool_stream(partial_json='{"value":"FCC" "bad"}')),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[-1].event == "response.failed"- assert "response.function_call_arguments.done" not in [- event.event for event in events- ]- assert "response.output_item.done" not in [event.event for event in events]- failed = events[-1].data["response"]- assert failed["status"] == "failed"- assert failed["output"] == []- assert failed["error"]["type"] == "api_error"- assert "replay-unsafe Responses output" in failed["error"]["message"]---async def test_anthropic_malformed_function_tool_arguments_fail_on_eof() -> None:- stream = _anthropic_tool_stream(- partial_json='{"value":"FCC" "bad"}',- include_block_stop=False,- )- text = await _collect_sse(- _responses_sse(- _aiter(stream[:-1]),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[-1].event == "response.failed"- assert events[-1].data["response"]["output"] == []+ assert parsed[-1].event == "response.incomplete"+ assert parsed[-1].data["response"]["status"] == "incomplete"+ assert parsed[-1].data["response"]["incomplete_details"] == {+ "reason": "max_output_tokens"+ }@pytest.mark.asyncio-async def test_provider_failure_outranks_provisional_incomplete_function_call() -> None:+async def test_pre_start_failure_is_not_hidden_in_a_responses_envelope() -> None:failure = ExecutionFailure(kind=FailureKind.RATE_LIMIT,status_code=429,- message="provider is busy\n\nRequest ID: req_failure_precedence",+ message="busy",retryable=True,)- incomplete_tool = _anthropic_tool_stream(partial_json='{"value":')[:4]+ source = _CloseTrackingEvents([], iteration_error=failure)- text = await _collect_sse(- _responses_sse(- _aiter_then_raise(incomplete_tool, failure),- {"model": "nvidia_nim/test-model", "stream": True},- )- )+ with pytest.raises(ExecutionFailure) as exc_info:+ [chunk async for chunk in iter_responses_sse_from_events(source, _request())]- events = parse_sse_text(text)- assert [event.event for event in events].count("response.failed") == 1- assert events[-1].event == "response.failed"- failed = events[-1].data["response"]- assert failed["id"] == events[0].data["response"]["id"]- assert failed["error"] == {- "message": "provider is busy\n\nRequest ID: req_failure_precedence",- "type": "rate_limit_error",- "param": None,- "code": None,- }+ assert exc_info.value is failure+ assert source.close_calls == 1@pytest.mark.asyncio-async def test_post_start_failure_observer_runs_before_terminal_failure_event() -> None:- failure = RuntimeError("socket closed")- timeline: list[tuple[str, object]] = []-- def observe_terminal_failure(exc: BaseException) -> None:- timeline.append(("observed", exc))-- stream = _ADAPTER.iter_sse_from_anthropic(- _aiter_then_raise(_anthropic_text_stream("partial")[:3], failure),- OpenAIResponsesRequest.model_validate(- {"model": "nvidia_nim/test-model", "stream": True}- ),- on_post_start_terminal_failure=observe_terminal_failure,+async def test_post_start_failure_becomes_one_terminal_response_event() -> None:+ failure = ExecutionFailure(+ kind=FailureKind.OVERLOADED,+ status_code=529,+ message="busy",+ retryable=True,)- parts: list[str] = []- async for chunk in stream:- parts.append(chunk)- event = parse_sse_text(chunk)- assert len(event) == 1- timeline.append(("emitted", event[0].event))-- events = parse_sse_text("".join(parts))- assert timeline.count(("observed", failure)) == 1- assert timeline.index(("observed", failure)) < timeline.index(- ("emitted", "response.failed")+ source = _CloseTrackingEvents(+ [ResponseStarted("response_internal", "provider-model")],+ iteration_error=failure,)- assert events[-1].data["response"]["error"]["message"] == "socket closed"---async def test_unrelated_post_start_exception_group_remains_unexpected() -> None:- grouped = ExceptionGroup("stream failed", [RuntimeError("socket closed")])observed: list[BaseException] = []- stream = _ADAPTER.iter_sse_from_anthropic(- _aiter_then_raise(_anthropic_text_stream("partial")[:3], grouped),- OpenAIResponsesRequest.model_validate(- {"model": "nvidia_nim/test-model", "stream": True}- ),- on_post_start_terminal_failure=observed.append,- )-- events = parse_sse_text(await _collect_sse(stream))-- assert observed == [grouped]- assert events[-1].event == "response.failed"- assert events[-1].data["response"]["error"]["type"] == "api_error"---async def test_namespaced_anthropic_tool_stream_restores_responses_namespace() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_anthropic_tool_stream(tool_name="mcp__node_repl__js")),- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [- {- "type": "namespace",- "name": "mcp__node_repl",- "tools": [- {- "type": "function",- "name": "js",- "parameters": {"type": "object", "properties": {}},- }- ],- }- ],- },- )- )-- events = parse_sse_text(text)- completed = events[-1].data["response"]- function_call = completed["output"][0]- assert function_call["type"] == "function_call"- assert function_call["namespace"] == "mcp__node_repl"- assert function_call["name"] == "js"---async def test_anthropic_custom_tool_stream_converts_to_custom_tool_call() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(- _anthropic_tool_stream(- tool_name="apply_patch",- partial_json='{"input":"*** Begin Patch"}',- )- ),- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [- {- "type": "custom",- "name": "apply_patch",- "format": {"type": "text"},- }- ],- },- )- )- events = parse_sse_text(text)- names = [event.event for event in events]- assert "response.custom_tool_call_input.delta" in names- assert "response.custom_tool_call_input.done" in names- assert "response.function_call_arguments.delta" not in names- completed = events[-1].data["response"]- custom_call = completed["output"][0]- assert custom_call["type"] == "custom_tool_call"- assert custom_call["call_id"] == "toolu_1"- assert custom_call["name"] == "apply_patch"- assert custom_call["input"] == "*** Begin Patch"---async def test_custom_tool_input_remains_free_form_when_not_json() -> None:- response = await _completed_response_from_sse(- _aiter(- _anthropic_tool_stream(- tool_name="apply_patch",- partial_json="*** Begin Patch",- )- ),- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [{"type": "custom", "name": "apply_patch"}],- },- )-- custom_call = response["output"][0]- assert custom_call["type"] == "custom_tool_call"- assert custom_call["input"] == "*** Begin Patch"---async def test_anthropic_error_stream_converts_to_response_failed_event() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(- [- format_sse_event(- "error",- {- "type": "error",- "error": {- "type": "api_error",- "message": "upstream failed",- },- },- )- ]- ),- {"model": "nvidia_nim/test-model", "stream": True},- )- )-- events = parse_sse_text(text)- assert events[0].event == "response.created"- assert events[1].event == "response.failed"- failed = events[1].data["response"]- assert failed["status"] == "failed"- assert failed["error"]["message"] == "upstream failed"---async def test_split_usage_deltas_sum_latest_anthropic_input_categories() -> None:- response = await _completed_response_from_sse(- _aiter(- [- *_anthropic_text_stream("usage")[:-2],- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn"},- "usage": {- "input_tokens": 20,- "cache_creation_input_tokens": 5,- "cache_read_input_tokens": 10,- },- },- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {},- "usage": {- "cache_read_input_tokens": 11,- "output_tokens": 7,- },- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 36,- "input_tokens_details": {"cached_tokens": 11},- "output_tokens": 7,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 43,- }- assert "stop_reason" not in response---async def test_usage_ignores_invalid_anthropic_input_categories() -> None:- response = await _completed_response_from_sse(- _aiter(- [- *_anthropic_text_stream("usage")[:-2],- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn"},- "usage": {- "input_tokens": 20,- "cache_creation_input_tokens": 5,- "cache_read_input_tokens": 10,- },- },- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {},- "usage": {- "input_tokens": -1,- "cache_creation_input_tokens": -2,- "cache_read_input_tokens": True,- "output_tokens": 7,- },- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 35,- "input_tokens_details": {"cached_tokens": 10},- "output_tokens": 7,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 42,- }---async def test_reasoning_stream_reports_reasoning_usage_detail() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_reasoning_stream("inspect the code before answering")),- {"model": "nvidia_nim/test-model", "stream": True},- )-- usage = response["usage"]- assert usage["input_tokens"] == 3- assert usage["output_tokens"] == 20- assert usage["total_tokens"] == 23- assert usage["output_tokens_details"]["reasoning_tokens"] > 0---async def test_reasoning_usage_detail_is_capped_at_output_tokens() -> None:- response = await _completed_response_from_sse(- _aiter(- _anthropic_reasoning_stream(- "this reasoning text is intentionally long enough to exceed one token",- output_tokens=1,- )- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"]["output_tokens"] == 1- assert response["usage"]["output_tokens_details"]["reasoning_tokens"] == 1---async def test_reasoning_usage_detail_reports_zero_capped_count() -> None:- response = await _completed_response_from_sse(- _aiter(- _anthropic_reasoning_stream(- "reasoning text exists without reported output tokens",- output_tokens=None,- )- ),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 3,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens": 0,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 3,- }---async def test_text_only_usage_reports_zero_reasoning_usage_detail() -> None:- response = await _completed_response_from_sse(- _aiter(_anthropic_text_stream("plain text only")),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert response["usage"] == {- "input_tokens": 3,- "input_tokens_details": {"cached_tokens": 0},- "output_tokens": 4,- "output_tokens_details": {"reasoning_tokens": 0},- "total_tokens": 7,- }--- ("request_payload", "tool_name", "partial_json", "expected_type", "expected_field"),- [- (- {"model": "nvidia_nim/test-model", "stream": True},- "echo",- '{"value":"FCC"}',- "function_call",- ("arguments", '{"value":"FCC"}'),- ),- (- {- "model": "nvidia_nim/test-model",- "stream": True,- "tools": [{"type": "custom", "name": "apply_patch"}],- },- "apply_patch",- '{"input":"*** Begin Patch"}',- "custom_tool_call",- ("input", "*** Begin Patch"),- ),- ],-)-async def test_pending_tool_blocks_flush_on_message_stop_and_eof(- request_payload: dict[str, object],- tool_name: str,- partial_json: str,- expected_type: str,- expected_field: tuple[str, str],-) -> None:- stream = _anthropic_tool_stream(- tool_name=tool_name, partial_json=partial_json, include_block_stop=False- )- message_stop_response = await _completed_response_from_sse(- _aiter(stream), request_payload- )- eof_response = await _completed_response_from_sse(- _aiter(stream[:-1]), request_payload- )-- for response in (message_stop_response, eof_response):- call = response["output"][0]- assert call["type"] == expected_type- assert call[expected_field[0]] == expected_field[1]---async def test_overlapping_text_and_tool_blocks_keep_reserved_output_indexes() -> None:- text = await _collect_sse(- _responses_sse(- _aiter(_overlapping_text_tool_stream()),- {"model": "nvidia_nim/test-model", "stream": True},+ chunks = [+ chunk+ async for chunk in iter_responses_sse_from_events(+ source,+ _request(),+ on_post_start_terminal_failure=observed.append,)- )-- events = parse_sse_text(text)- item_events = [- (event.event, event.data["output_index"])- for event in events- if event.event in {"response.output_item.added", "response.output_item.done"}- ]- assert item_events == [- ("response.output_item.added", 0),- ("response.output_item.added", 1),- ("response.output_item.done", 1),- ("response.output_item.done", 0),- ]- completed = events[-1].data["response"]- assert [item["type"] for item in completed["output"]] == [- "message",- "function_call",- ]- assert completed["output"][0]["content"][0]["text"] == "text"- assert completed["output"][1]["arguments"] == '{"value":"FCC"}'---async def test_overlapping_text_blocks_do_not_merge_content_by_index() -> None:- response = await _completed_response_from_sse(- _aiter(_overlapping_text_stream()),- {"model": "nvidia_nim/test-model", "stream": True},- )-- assert [item["content"][0]["text"] for item in response["output"]] == [- "A1-A2",- "B1-B2",- ]---async def _collect_sse(chunks: AsyncIterator[str]) -> str:- parts = [chunk async for chunk in chunks]- return "".join(parts)---async def _completed_response_from_sse(- chunks: AsyncIterator[str],- request: dict[str, object],-) -> dict[str, Any]:- text = await _collect_sse(_responses_sse(chunks, request))- events = parse_sse_text(text)- assert events[-1].event == "response.completed"- return events[-1].data["response"]---async def _aiter(chunks: list[str]) -> AsyncIterator[str]:- for chunk in chunks:- yield chunk---async def _aiter_then_raise(- chunks: list[str], failure: BaseException-) -> AsyncIterator[str]:- for chunk in chunks:- yield chunk- raise failure---def _anthropic_text_stream(text: str, *, stop_reason: str = "end_turn") -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": text},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": stop_reason, "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),]+ parsed = parse_sse_text("".join(chunks))--def _anthropic_tool_stream(- tool_name: str = "echo",- partial_json: str = '{"value":"FCC"}',- *,- include_block_stop: bool = True,-) -> list[str]:- chunks = [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": tool_name,- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {- "type": "input_json_delta",- "partial_json": partial_json,- },- },- ),+ assert [event.event for event in parsed] == [+ "response.created",+ "response.failed",]- if include_block_stop:- chunks.append(- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- )- )- chunks.extend(- [- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "tool_use", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]- )- return chunks+ assert parsed[-1].data["response"]["error"]["type"] == "overloaded_error"+ assert observed == [failure]+ assert source.close_calls == 1-def _anthropic_reasoning_stream(- reasoning: str,- *,- output_tokens: int | None = 20,-) -> list[str]:- usage = {"input_tokens": 3}- if output_tokens is not None:- usage["output_tokens"] = output_tokens+async def test_early_consumer_close_closes_canonical_source_once() -> None:+ source = _CloseTrackingEvents(text_event_stream("hello"))+ stream = iter_responses_sse_from_events(source, _request())- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "thinking", "thinking": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "thinking_delta", "thinking": reasoning},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "end_turn", "stop_sequence": None},- "usage": usage,- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+ assert parse_sse_text(await anext(stream))[0].event == "response.created"+ assert isinstance(stream, AsyncCloseable)+ await stream.aclose()+ assert source.close_calls == 1-def _overlapping_text_tool_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "text"},- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {- "type": "tool_use",- "id": "toolu_1",- "name": "echo",- "input": {},- },- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {- "type": "input_json_delta",- "partial_json": '{"value":"FCC"}',- },- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": "tool_use", "stop_sequence": None},- "usage": {"input_tokens": 3, "output_tokens": 4},- },- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+def test_presenter_rejects_events_after_terminal_completion() -> None:+ presenter = ResponsesEventPresenter(_request())+ for event in text_event_stream("done"):+ presenter.present(event)-def _overlapping_text_stream() -> list[str]:- return [- format_sse_event("message_start", {"type": "message_start", "message": {}}),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 0,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "A1-"},- },- ),- format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": 1,- "content_block": {"type": "text", "text": ""},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "B1-"},- },- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 0,- "delta": {"type": "text_delta", "text": "A2"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 0},- ),- format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": 1,- "delta": {"type": "text_delta", "text": "B2"},- },- ),- format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": 1},- ),- format_sse_event("message_stop", {"type": "message_stop"}),- ]+ with pytest.raises(RuntimeError, match="after response completion"):+ presenter.present(ResponseStarted("response_again", "provider-model"))diff --git a/tests/inference_support.py b/tests/inference_support.pynew file mode 100644index 00000000..eaf62591--- /dev/null+++ b/tests/inference_support.py@@ -0,0 +1,97 @@+"""Test fixtures for the provider-neutral inference stream contract."""++from collections.abc import AsyncIterator, Iterable++from free_claude_code.core.anthropic import AnthropicEventPresenter+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+ InferenceUsage,+ TokenMeasurement,+ UsageSource,+)+++def reported_usage(+ *,+ input_tokens: int,+ output_tokens: int,+ cache_read_input_tokens: int | None = None,+ cache_creation_input_tokens: int | None = None,+ reasoning_output_tokens: int | None = None,+) -> InferenceUsage:+ """Build cumulative upstream-reported usage for a test stream."""++ return InferenceUsage(+ input_tokens=TokenMeasurement(input_tokens, UsageSource.REPORTED),+ cache_read_input_tokens=(+ TokenMeasurement(cache_read_input_tokens, UsageSource.REPORTED)+ if cache_read_input_tokens is not None+ else None+ ),+ cache_creation_input_tokens=(+ TokenMeasurement(cache_creation_input_tokens, UsageSource.REPORTED)+ if cache_creation_input_tokens is not None+ else None+ ),+ output_tokens=TokenMeasurement(output_tokens, UsageSource.REPORTED),+ reasoning_output_tokens=(+ TokenMeasurement(reasoning_output_tokens, UsageSource.REPORTED)+ if reasoning_output_tokens is not None+ else None+ ),+ )+++def text_event_stream(+ text: str,+ *,+ model: str = "test-model",+ input_tokens: int = 3,+ output_tokens: int = 4,+ cache_read_input_tokens: int | None = None,+ cache_creation_input_tokens: int | None = None,+) -> list[InferenceEvent]:+ """Build one complete canonical text response."""++ ledger = InferenceStreamLedger("response_test", model, input_tokens)+ events: list[InferenceEvent] = [ledger.start_response()]+ events.extend(ledger.ensure_text_block())+ if text:+ events.append(ledger.emit_text_delta(text))+ events.extend(ledger.close_all_blocks())+ events.extend(+ ledger.finish_events(+ FinishReason.END_TURN,+ reported_usage(+ input_tokens=input_tokens,+ output_tokens=output_tokens,+ cache_read_input_tokens=cache_read_input_tokens,+ cache_creation_input_tokens=cache_creation_input_tokens,+ ),+ )+ )+ return events+++def present_anthropic(events: Iterable[InferenceEvent]) -> list[str]:+ """Render canonical test events at the Anthropic protocol boundary."""++ presenter = AnthropicEventPresenter()+ chunks: list[str] = []+ for event in events:+ chunks.extend(presenter.present(event))+ return chunks+++async def collect_anthropic(+ events: AsyncIterator[InferenceEvent],+) -> list[str]:+ """Collect a canonical provider stream through the Anthropic presenter."""++ presenter = AnthropicEventPresenter()+ chunks: list[str] = []+ async for event in events:+ chunks.extend(presenter.present(event))+ return chunksdiff --git a/tests/messaging/test_stream_transcript_contract.py b/tests/messaging/test_stream_transcript_contract.pyindex ab5b8ac5..a61f279e 100644--- a/tests/messaging/test_stream_transcript_contract.py+++ b/tests/messaging/test_stream_transcript_contract.py@@ -1,40 +1,40 @@"""Messaging-specific assertions built on neutral Anthropic stream contracts."""-from free_claude_code.core.anthropic import AnthropicStreamLedgerfrom free_claude_code.core.anthropic.stream_contracts import (assert_anthropic_stream_contract,has_tool_use,parse_sse_text,)+from free_claude_code.core.inference import (+ FinishReason,+ InferenceEvent,+ InferenceStreamLedger,+)from free_claude_code.messaging.event_parser import parse_cli_eventfrom free_claude_code.messaging.transcript import RenderCtx, TranscriptBuffer+from tests.inference_support import present_anthropic, reported_usagedef test_thinking_tool_text_and_transcript_order_contract() -> None:- builder = AnthropicStreamLedger("msg_contract", "contract-model")- chunks = [builder.message_start()]- chunks.extend(builder.ensure_thinking_block())- chunks.append(builder.emit_thinking_delta("inspect first"))- chunks.extend(builder.close_content_blocks())- tool_block_index = builder.blocks.allocate_index()- chunks.append(- builder.content_block_start(- tool_block_index, "tool_use", id="toolu_1", name="Read"- )- )- chunks.append(- builder.content_block_delta(- tool_block_index, "input_json_delta", '{"file":"README.md"}'+ builder = InferenceStreamLedger("response_contract", "contract-model")+ canonical: list[InferenceEvent] = [builder.start_response()]+ canonical.extend(builder.ensure_reasoning_block())+ canonical.append(builder.emit_reasoning_delta("inspect first"))+ canonical.extend(builder.close_content_blocks())+ canonical.append(builder.start_tool_block(0, "toolu_1", "Read"))+ canonical.append(builder.emit_tool_delta(0, '{"file":"README.md"}'))+ canonical.append(builder.stop_tool_block(0))+ canonical.extend(builder.ensure_text_block())+ canonical.append(builder.emit_text_delta("done"))+ canonical.extend(builder.close_all_blocks())+ canonical.extend(+ builder.finish_events(+ FinishReason.END_TURN,+ reported_usage(input_tokens=0, output_tokens=20),))- chunks.append(builder.content_block_stop(tool_block_index))- chunks.extend(builder.ensure_text_block())- chunks.append(builder.emit_text_delta("done"))- chunks.extend(builder.close_all_blocks())- chunks.append(builder.message_delta("end_turn", 20))- chunks.append(builder.message_stop())- events = parse_sse_text("".join(chunks))+ events = parse_sse_text("".join(present_anthropic(canonical)))assert_anthropic_stream_contract(events)assert has_tool_use(events)diff --git a/tests/providers/test_cerebras.py b/tests/providers/test_cerebras.pyindex a1e61a71..dd5ed871 100644--- a/tests/providers/test_cerebras.py+++ b/tests/providers/test_cerebras.py@@ -5,6 +5,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom free_claude_code.config.provider_catalog import CEREBRAS_DEFAULT_BASE+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -211,7 +212,7 @@ async def test_stream_response_text(cerebras_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in cerebras_provider.stream_response(req)]+ events = await collect_anthropic(cerebras_provider.stream_response(req))assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -244,7 +245,7 @@ async def test_stream_response_reasoning(cerebras_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in cerebras_provider.stream_response(req)]+ events = await collect_anthropic(cerebras_provider.stream_response(req))assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_cline_pass.py b/tests/providers/test_cline_pass.pyindex 726e61a5..d07e9e90 100644--- a/tests/providers/test_cline_pass.py+++ b/tests/providers/test_cline_pass.py@@ -21,6 +21,7 @@ from free_claude_code.core.json_types import JsonObject, JsonValuefrom free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.inference_support import collect_anthropicfrom tests.providers.support import (REASONING_DEFAULT,REASONING_OFF,@@ -314,13 +315,12 @@ async def test_stream_uses_upstream_sse_and_preserves_reasoning_details(create,):event_text = "".join(- [- event- async for event in cline_pass_provider.stream_response(+ await collect_anthropic(+ cline_pass_provider.stream_response(_request(),reasoning=ReasoningPolicy.on(),)- ]+ ))events = parse_sse_text(event_text)diff --git a/tests/providers/test_cloudflare.py b/tests/providers/test_cloudflare.pyindex b64c4bfe..be2e5cf8 100644--- a/tests/providers/test_cloudflare.py+++ b/tests/providers/test_cloudflare.py@@ -17,6 +17,7 @@ from free_claude_code.providers.cloudflare import (CloudflareProvider,cloudflare_ai_base_url,)+from tests.inference_support import collect_anthropicfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -224,9 +225,9 @@ async def test_stream_uses_openai_chat_completions(new_callable=AsyncMock,return_value=_stream(_chunk(delta)),) as mock_create:- events = [- event async for event in cloudflare_provider.stream_response(_request())- ]+ events = await collect_anthropic(+ cloudflare_provider.stream_response(_request())+ )parsed = parse_sse_text("".join(events))assert any(@@ -255,9 +256,9 @@ async def test_stream_maps_cloudflare_reasoning_delta_to_thinking(new_callable=AsyncMock,return_value=_stream(_chunk(delta)),):- events = [- event async for event in cloudflare_provider.stream_response(_request())- ]+ events = await collect_anthropic(+ cloudflare_provider.stream_response(_request())+ )parsed = parse_sse_text("".join(events))assert any(@@ -306,7 +307,7 @@ async def test_stream_maps_openai_tool_calls_to_tool_use(new_callable=AsyncMock,return_value=_stream(_chunk(delta, finish_reason="tool_calls")),):- events = [event async for event in cloudflare_provider.stream_response(request)]+ events = await collect_anthropic(cloudflare_provider.stream_response(request))parsed = parse_sse_text("".join(events))assert any(diff --git a/tests/providers/test_codestral.py b/tests/providers/test_codestral.pyindex f97b5793..f3fbe398 100644--- a/tests/providers/test_codestral.py+++ b/tests/providers/test_codestral.py@@ -5,6 +5,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom free_claude_code.config.provider_catalog import CODESTRAL_DEFAULT_BASE+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -107,7 +108,7 @@ async def test_stream_response_text(codestral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in codestral_provider.stream_response(req)]+ events = await collect_anthropic(codestral_provider.stream_response(req))assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -140,7 +141,7 @@ async def test_stream_response_reasoning_content(codestral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in codestral_provider.stream_response(req)]+ events = await collect_anthropic(codestral_provider.stream_response(req))assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_cohere.py b/tests/providers/test_cohere.pyindex 14dfc4e9..978a46b3 100644--- a/tests/providers/test_cohere.py+++ b/tests/providers/test_cohere.py@@ -7,6 +7,7 @@ import pytestfrom free_claude_code.application.errors import InvalidRequestErrorfrom free_claude_code.config.provider_catalog import COHERE_DEFAULT_BASE+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -207,9 +208,9 @@ async def test_stream_response_text(cohere_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in cohere_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ cohere_provider.stream_response(make_request())+ )assert any('"text_delta"' in event and "Hello from Cohere" in event for event in events@@ -242,9 +243,9 @@ async def test_stream_response_tool_call(cohere_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in cohere_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ cohere_provider.stream_response(make_request())+ )assert any('"content_block_start"' in event and '"tool_use"' in event for event in events@@ -277,9 +278,9 @@ async def test_stream_response_reasoning_content(cohere_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in cohere_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ cohere_provider.stream_response(make_request())+ )assert any('"thinking_delta"' in event and "Thinking via Cohere" in eventdiff --git a/tests/providers/test_deepseek.py b/tests/providers/test_deepseek.pyindex 89e7ac20..05f7e154 100644--- a/tests/providers/test_deepseek.py+++ b/tests/providers/test_deepseek.py@@ -18,6 +18,7 @@ from free_claude_code.core.anthropic.models import ()from free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.providers.deepseek import DeepSeekProvider+from tests.inference_support import collect_anthropicfrom tests.providers.support import (REASONING_OFF,REASONING_ON,@@ -141,7 +142,7 @@ def test_init(deepseek_config):def test_maps_only_complete_consistent_cache_usage(deepseek_provider, usage, expected) -> None:- assert deepseek_provider._anthropic_usage_fields(usage) == expected+ assert deepseek_provider._usage_fields(usage) == expecteddef test_build_request_body_openai_chat_shape(deepseek_provider):@@ -1079,12 +1080,9 @@ async def test_stream_uses_chat_completions_and_maps_cache_usage(deepseek_providcreate = AsyncMock(return_value=fake_stream())with patch.object(deepseek_provider._client.chat.completions, "create", create):- chunks = [- chunk- async for chunk in deepseek_provider.stream_response(- request, input_tokens=7, request_id="r1"- )- ]+ chunks = await collect_anthropic(+ deepseek_provider.stream_response(request, input_tokens=7, request_id="r1")+ )create.assert_awaited_once()await_args = create.await_argsdiff --git a/tests/providers/test_execution_failure_boundary.py b/tests/providers/test_execution_failure_boundary.pyindex 434ca634..6b14170d 100644--- a/tests/providers/test_execution_failure_boundary.py+++ b/tests/providers/test_execution_failure_boundary.py@@ -8,6 +8,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom free_claude_code.config.nim import NimSettings+from free_claude_code.core.anthropic import AnthropicEventPresenterfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.core.async_iterators import AsyncCloseablefrom free_claude_code.core.failures import ExecutionFailure, FailureKind@@ -17,6 +18,7 @@ from free_claude_code.providers.http import (close_provider_stream,)from free_claude_code.providers.nvidia_nim import NvidiaNimProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -88,6 +90,7 @@ async def test_committed_provider_failure_closes_block_then_raises_canonical_valRuntimeError("connection lost after commit"),)emitted: deque[str] = deque()+ presenter = AnthropicEventPresenter()with (patch.object(@@ -102,7 +105,7 @@ async def test_committed_provider_failure_closes_block_then_raises_canonical_valrequest,request_id="req_committed_failure",):- emitted.append(event)+ emitted.extend(presenter.present(event))events = parse_sse_text("".join(emitted))assert [event.event for event in events][-1] == "content_block_stop"@@ -138,13 +141,12 @@ async def test_openai_stream_close_failure_cannot_mask_execution_failure() -> Nopatch("free_claude_code.providers.http.trace_event") as trace_event,pytest.raises(ExecutionFailure) as exc_info,):- [- event- async for event in provider.stream_response(+ await collect_anthropic(+ provider.stream_response(request,request_id="req_close_failure",)- ]+ )assert stream.close_calls == 1assert exc_info.value.status_code == 502@@ -276,13 +278,12 @@ async def test_completed_stream_close_failure_preserves_success_lifecycle(),patch("free_claude_code.providers.http.trace_event") as trace_event,):- emitted = [- event- async for event in provider.stream_response(+ emitted = await collect_anthropic(+ provider.stream_response(request,request_id="req_successful_close_failure",)- ]+ )events = parse_sse_text("".join(emitted))assert events[-1].event == "message_stop"diff --git a/tests/providers/test_gemini.py b/tests/providers/test_gemini.pyindex 2cc88ea5..0612cddf 100644--- a/tests/providers/test_gemini.py+++ b/tests/providers/test_gemini.py@@ -11,6 +11,7 @@ from free_claude_code.providers.gemini import GeminiProviderfrom free_claude_code.providers.google_openai import (GOOGLE_SKIP_THOUGHT_SIGNATURE_VALIDATOR,)+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -437,12 +438,9 @@ async def test_stream_response_text(gemini_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event- async for event in gemini_provider.stream_response(- req, reasoning=reasoning_for(req)- )- ]+ events = await collect_anthropic(+ gemini_provider.stream_response(req, reasoning=reasoning_for(req))+ )assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -493,7 +491,7 @@ async def test_stream_response_preserves_tool_call_extra_content(gemini_provider) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in gemini_provider.stream_response(req)]+ events = await collect_anthropic(gemini_provider.stream_response(req))tool_starts = [event@@ -533,7 +531,7 @@ async def test_stream_response_reasoning_content(gemini_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in gemini_provider.stream_response(req)]+ events = await collect_anthropic(gemini_provider.stream_response(req))assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_github_models.py b/tests/providers/test_github_models.pyindex 3e22f76d..a1a6ec29 100644--- a/tests/providers/test_github_models.py+++ b/tests/providers/test_github_models.py@@ -16,6 +16,7 @@ from free_claude_code.providers.base import ProviderConfigfrom free_claude_code.providers.github_models import GitHubModelsProviderfrom free_claude_code.providers.github_models.client import GITHUB_MODELS_CATALOG_URLfrom free_claude_code.providers.model_listing import ModelListResponseError+from tests.inference_support import collect_anthropicfrom tests.providers.support import (REASONING_ON,immediate_admission,@@ -216,9 +217,9 @@ async def test_stream_response_text(new_callable=AsyncMock,return_value=_stream(_chunk(delta)),) as mock_create:- events = [- event async for event in github_models_provider.stream_response(_request())- ]+ events = await collect_anthropic(+ github_models_provider.stream_response(_request())+ )parsed = parse_sse_text("".join(events))assert any(@@ -266,9 +267,9 @@ async def test_stream_response_tool_call(new_callable=AsyncMock,return_value=_stream(_chunk(delta, finish_reason="tool_calls")),):- events = [- event async for event in github_models_provider.stream_response(request)- ]+ events = await collect_anthropic(+ github_models_provider.stream_response(request)+ )parsed = parse_sse_text("".join(events))assert any(@@ -300,9 +301,9 @@ async def test_stream_response_reasoning_content(new_callable=AsyncMock,return_value=_stream(_chunk(delta)),):- events = [- event async for event in github_models_provider.stream_response(_request())- ]+ events = await collect_anthropic(+ github_models_provider.stream_response(_request())+ )parsed = parse_sse_text("".join(events))assert any(diff --git a/tests/providers/test_groq.py b/tests/providers/test_groq.pyindex e85ebe2a..984a9e6d 100644--- a/tests/providers/test_groq.py+++ b/tests/providers/test_groq.py@@ -6,6 +6,7 @@ import pytestfrom free_claude_code.config.provider_catalog import GROQ_DEFAULT_BASEfrom free_claude_code.providers.groq import GroqProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -209,7 +210,7 @@ async def test_stream_response_text(groq_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in groq_provider.stream_response(req)]+ events = await collect_anthropic(groq_provider.stream_response(req))assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -242,7 +243,7 @@ async def test_stream_response_reasoning_content(groq_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in groq_provider.stream_response(req)]+ events = await collect_anthropic(groq_provider.stream_response(req))assert any('"thinking_delta"' in event and "Thinking..." in event for event in eventsdiff --git a/tests/providers/test_groq_reasoning.py b/tests/providers/test_groq_reasoning.pyindex 7f4c63c6..f369dbf3 100644--- a/tests/providers/test_groq_reasoning.py+++ b/tests/providers/test_groq_reasoning.py@@ -17,6 +17,7 @@ from free_claude_code.providers.groq.client import (_parse_reasoning_vocabulary,_rewrite_reasoning_effort,)+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (capture_openai_chat_wire_body,@@ -705,13 +706,12 @@ async def test_reasoning_correction_emits_one_downstream_lifecycle() -> None:with patch.object(provider._client.chat.completions, "create", create):raw = "".join(- [- event- async for event in provider.stream_response(+ await collect_anthropic(+ provider.stream_response(request,reasoning=policy,)- ]+ ))events = parse_sse_text(raw)diff --git a/tests/providers/test_huggingface.py b/tests/providers/test_huggingface.pyindex e8724366..ba484fae 100644--- a/tests/providers/test_huggingface.py+++ b/tests/providers/test_huggingface.py@@ -8,6 +8,7 @@ import pytestfrom free_claude_code.config.provider_catalog import HUGGINGFACE_DEFAULT_BASEfrom free_claude_code.core.anthropic import ReasoningReplayModefrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -186,10 +187,9 @@ async def test_stream_response_text(huggingface_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event- async for event in huggingface_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ huggingface_provider.stream_response(make_request())+ )assert any('"text_delta"' in event and "Hello from Hugging Face" in event@@ -220,10 +220,9 @@ async def test_stream_response_reasoning_content(huggingface_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event- async for event in huggingface_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ huggingface_provider.stream_response(make_request())+ )assert any('"thinking_delta"' in event and "Thinking via router" in eventdiff --git a/tests/providers/test_kilo.py b/tests/providers/test_kilo.pyindex f4ea054d..807500f2 100644--- a/tests/providers/test_kilo.py+++ b/tests/providers/test_kilo.py@@ -19,6 +19,7 @@ from free_claude_code.core.reasoning import ReasoningPolicyfrom free_claude_code.providers.kilo import KiloProviderfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.inference_support import collect_anthropicfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -265,7 +266,7 @@ async def test_stream_uses_reasoning_field_without_duplicating_plain_details(return_value=stream,):event_text = "".join(- [event async for event in kilo_provider.stream_response(request)]+ await collect_anthropic(kilo_provider.stream_response(request)))events = parse_sse_text(event_text)@@ -306,7 +307,7 @@ async def test_stream_restarts_reasoning_reconciliation_after_early_retry(side_effect=[abandoned, recovered],) as create:event_text = "".join(- [event async for event in kilo_provider.stream_response(request)]+ await collect_anthropic(kilo_provider.stream_response(request)))events = parse_sse_text(event_text)@@ -346,13 +347,12 @@ async def test_stream_omits_all_reasoning_representations_when_disabled(return_value=stream,):event_text = "".join(- [- event- async for event in kilo_provider.stream_response(+ await collect_anthropic(+ kilo_provider.stream_response(request,reasoning=ReasoningPolicy.off(),)- ]+ ))events = parse_sse_text(event_text)diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.pyindex c432d6b4..58f3ee71 100644--- a/tests/providers/test_llamacpp.py+++ b/tests/providers/test_llamacpp.py@@ -7,6 +7,7 @@ import pytestfrom free_claude_code.config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENSfrom free_claude_code.core.anthropic.stream_contracts import parse_sse_textfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -137,12 +138,9 @@ async def test_stream_response_uses_shared_openai_chat_provider(return_value=stream(),) as create:output = "".join(- [- event- async for event in provider.stream_response(- make_messages_request(LLAMACPP_MODEL)- )- ]+ await collect_anthropic(+ provider.stream_response(make_messages_request(LLAMACPP_MODEL))+ ))assert create.call_args.kwargs["stream"] is Truediff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex c6694d7d..16d78b13 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -10,6 +10,7 @@ from free_claude_code.config.provider_catalog import LMSTUDIO_DEFAULT_BASEfrom free_claude_code.core.failures import ExecutionFailure, FailureKindfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.lmstudio import LMStudioProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -182,7 +183,7 @@ async def test_stream_response_text(lmstudio_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in lmstudio_provider.stream_response(req)]+ events = await collect_anthropic(lmstudio_provider.stream_response(req))assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -216,13 +217,12 @@ async def test_stream_response_passes_exact_reasoning_budget_via_extra_body() as mock_create:mock_create.return_value = mock_stream()- events = [- event- async for event in lmstudio_provider.stream_response(+ events = await collect_anthropic(+ lmstudio_provider.stream_response(req,reasoning=policy,)- ]+ )await_args = mock_create.await_argsassert await_args is not Nonediff --git a/tests/providers/test_minimax.py b/tests/providers/test_minimax.pyindex f2c1b03c..176fef4c 100644--- a/tests/providers/test_minimax.py+++ b/tests/providers/test_minimax.py@@ -15,6 +15,7 @@ from free_claude_code.core.anthropic.stream_contracts import (thinking_content,)from free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.inference_support import collect_anthropicfrom tests.providers.support import (REASONING_OFF,immediate_admission,@@ -156,7 +157,7 @@ async def test_stream_preserves_reasoning_content(minimax_provider):new_callable=AsyncMock,return_value=stream,) as create:- events = [event async for event in minimax_provider.stream_response(request)]+ events = await collect_anthropic(minimax_provider.stream_response(request))parsed = parse_sse_text("".join(events))assert thinking_content(parsed) == "plan"diff --git a/tests/providers/test_mistral.py b/tests/providers/test_mistral.pyindex ba9f6efd..4ba6be3f 100644--- a/tests/providers/test_mistral.py+++ b/tests/providers/test_mistral.py@@ -10,6 +10,7 @@ from httpx2 import Request, Responsefrom free_claude_code.config.provider_catalog import MISTRAL_DEFAULT_BASEfrom free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.mistral import MistralProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -214,7 +215,7 @@ async def test_stream_response_text(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))assert any('"text_delta"' in event and "Hello back!" in event for event in events@@ -247,7 +248,7 @@ async def test_stream_response_reasoning_content(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))assert any('"thinking_delta"' in event and "Thinking..." in event for event in events@@ -284,7 +285,7 @@ async def test_stream_response_native_mistral_thinking_chunk(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))assert any('"thinking_delta"' in event and "Native thought." in event for event in events@@ -316,7 +317,7 @@ async def test_stream_response_native_mistral_text_chunk(mistral_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))assert any('"text_delta"' in event and "Native text." in event for event in events)@@ -350,7 +351,7 @@ async def test_stream_response_preserves_native_thinking_and_string_text() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))event_text = "\n".join(events)assert '"thinking_delta"' in event_text@@ -388,7 +389,7 @@ async def test_stream_response_preserves_native_reasoning_and_string_text() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))event_text = "\n".join(events)assert "Native reasoning." in event_text@@ -428,7 +429,7 @@ async def test_stream_response_preserves_mixed_native_content_array() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))event_text = "\n".join(events)assert "Native thought." in event_text@@ -467,7 +468,7 @@ async def test_stream_response_ignores_unknown_native_content_chunks() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))event_text = "\n".join(events)assert "reference_ids" not in event_text@@ -507,12 +508,9 @@ async def test_stream_response_suppresses_native_mistral_thinking_when_disabled() as mock_create:mock_create.return_value = mock_stream()- events = [- event- async for event in mistral_provider.stream_response(- req, reasoning=REASONING_OFF- )- ]+ events = await collect_anthropic(+ mistral_provider.stream_response(req, reasoning=REASONING_OFF)+ )event_text = "\n".join(events)assert "Hidden." not in event_text@@ -572,12 +570,9 @@ async def test_stream_response_retries_without_mistral_reasoning_on_rejection() as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [- e- async for e in mistral_provider.stream_response(- req, reasoning=reasoning_for(req)- )- ]+ events = await collect_anthropic(+ mistral_provider.stream_response(req, reasoning=reasoning_for(req))+ )assert mock_create.await_count == 2first_call = mock_create.await_args_list[0].kwargs@@ -643,12 +638,9 @@ async def test_stream_response_reasoning_retry_preserves_visible_text_and_tools() as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [- e- async for e in mistral_provider.stream_response(- req, reasoning=reasoning_for(req)- )- ]+ events = await collect_anthropic(+ mistral_provider.stream_response(req, reasoning=reasoning_for(req))+ )second_call = mock_create.await_args_list[1].kwargsassert second_call["messages"][0]["content"] == "Visible history."@@ -685,12 +677,9 @@ async def test_stream_response_retries_on_mistral_422_reasoning_rejection() as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [- e- async for e in mistral_provider.stream_response(- req, reasoning=reasoning_for(req)- )- ]+ events = await collect_anthropic(+ mistral_provider.stream_response(req, reasoning=reasoning_for(req))+ )assert mock_create.await_count == 2assert "reasoning_effort" not in mock_create.await_args_list[1].kwargs@@ -742,7 +731,7 @@ async def test_stream_response_retries_when_model_disables_reasoning_input() as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [e async for e in mistral_provider.stream_response(req)]+ events = await collect_anthropic(mistral_provider.stream_response(req))assert mock_create.await_count == 2second_call = mock_create.await_args_list[1].kwargs@@ -762,7 +751,7 @@ async def test_stream_response_unrelated_bad_request_does_not_retry(mistral_provmock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in mistral_provider.stream_response(req)]+ await collect_anthropic(mistral_provider.stream_response(req))assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@@ -781,7 +770,7 @@ async def test_stream_response_generic_thinking_error_does_not_retry(mock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in mistral_provider.stream_response(req)]+ await collect_anthropic(mistral_provider.stream_response(req))assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.messagediff --git a/tests/providers/test_model_discovery.py b/tests/providers/test_model_discovery.pyindex c5e3444d..888add5e 100644--- a/tests/providers/test_model_discovery.py+++ b/tests/providers/test_model_discovery.py@@ -1,7 +1,6 @@import asynciofrom collections.abc import AsyncIteratorfrom types import SimpleNamespace-from typing import Anyfrom unittest.mock import AsyncMock, patchimport pytest@@ -15,6 +14,8 @@ from free_claude_code.config.provider_catalog import (WAFER_DEFAULT_BASE,)from free_claude_code.config.settings import Settings+from free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedgerfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.base import BaseProviderfrom free_claude_code.providers.deepseek import DeepSeekProvider@@ -356,7 +357,7 @@ class FakeProvider(BaseProvider):def preflight_stream(self,- request: Any,+ request: MessagesRequest,*,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,) -> None:@@ -380,15 +381,15 @@ class FakeProvider(BaseProvider):async def stream_response(self,- request: Any,+ request: MessagesRequest,input_tokens: int = 0,*,request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:if False:- yield ""+ yield InferenceStreamLedger("unused", "unused").start_response()@pytest.mark.asynciodiff --git a/tests/providers/test_nvidia_nim.py b/tests/providers/test_nvidia_nim.pyindex fcd3a7d6..73aab9f7 100644--- a/tests/providers/test_nvidia_nim.py+++ b/tests/providers/test_nvidia_nim.py@@ -15,6 +15,7 @@ from free_claude_code.providers.nvidia_nim.tool_schema import (NIM_TOOL_ARGUMENT_ALIASES_KEY,)from free_claude_code.providers.stream_recovery import RecoveryHoldbackBuffer+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -299,7 +300,7 @@ async def test_stream_response_text(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))assert len(events) > 0assert "event: message_start" in events[0]@@ -347,7 +348,7 @@ async def test_stream_response_thinking_reasoning_content(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))# Check for thinking_deltafound_thinking = False@@ -389,9 +390,9 @@ async def test_stream_response_suppresses_thinking_when_disabled(provider_config) as mock_create:mock_create.return_value = mock_stream()- events = [- e async for e in provider.stream_response(req, reasoning=REASONING_OFF)- ]+ events = await collect_anthropic(+ provider.stream_response(req, reasoning=REASONING_OFF)+ )event_text = "".join(events)assert "thinking_delta" not in event_text@@ -436,9 +437,9 @@ async def test_stream_response_retries_without_chat_template(provider_config):) as mock_create:mock_create.side_effect = [first_error, mock_stream()]- events = [- e async for e in provider.stream_response(req, reasoning=REASONING_ON)- ]+ events = await collect_anthropic(+ provider.stream_response(req, reasoning=REASONING_ON)+ )assert mock_create.await_count == 2@@ -493,9 +494,9 @@ async def test_stream_response_retries_without_chat_template_kwargs_issue_993() as mock_create:mock_create.side_effect = [first_error, mock_stream()]- events = [- e async for e in provider.stream_response(req, reasoning=REASONING_ON)- ]+ events = await collect_anthropic(+ provider.stream_response(req, reasoning=REASONING_ON)+ )assert mock_create.await_count == 2@@ -531,7 +532,7 @@ async def test_stream_response_does_not_retry_unrelated_bad_request(provider_conmock_create.side_effect = _make_bad_request_error("unrelated bad request")with pytest.raises(ExecutionFailure) as exc_info:- [e async for e in provider.stream_response(req)]+ await collect_anthropic(provider.stream_response(req))assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@@ -566,7 +567,7 @@ async def test_tool_call_stream(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))starts = [e for e in events if "event: content_block_start" in e and '"tool_use"' in e@@ -608,7 +609,7 @@ async def test_native_minimax_tool_markup_becomes_anthropic_tool_use(nim_provide) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))event_text = "".join(events)assert namespace not in event_text@@ -656,7 +657,7 @@ async def test_native_minimax_reasoning_markup_becomes_anthropic_tool_use() as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))event_text = "".join(events)assert namespace not in event_text@@ -692,7 +693,7 @@ async def test_native_minimax_markup_without_tools_retries_without_leaking() as mock_create:mock_create.side_effect = attempts- events = [event async for event in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))event_text = "".join(events)assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS@@ -737,7 +738,7 @@ async def test_native_minimax_tool_markup_restores_nim_argument_aliases(nim_prov) as mock_create:mock_create.return_value = mock_stream()- events = [event async for event in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))assert json.loads(_input_json_deltas(events)[0]) == {"pattern": "needle",@@ -788,7 +789,7 @@ async def test_malformed_native_minimax_tool_call_retries_without_leaking() as mock_create:mock_create.side_effect = [malformed_stream(), recovered_stream()]- events = [event async for event in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))assert mock_create.await_count == 2event_text = "".join(events)@@ -854,7 +855,7 @@ async def test_midstream_native_tool_suffix_failure_recovers_without_duplication):mock_create.side_effect = [malformed_stream(), recovered_stream()]- events = [event async for event in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))assert mock_create.await_count == 2event_text = "".join(events)@@ -898,7 +899,7 @@ async def test_stream_response_restores_aliased_tool_arguments(nim_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))await_args = mock_create.await_argsassert await_args is not None@@ -955,7 +956,7 @@ async def test_stream_response_buffers_chunked_aliased_tool_arguments(nim_provid) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1001,7 +1002,7 @@ async def test_stream_response_restores_nested_aliased_tool_arguments(nim_provid) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1047,7 +1048,7 @@ async def test_stream_response_task_tool_still_forces_background_false(nim_provi) as mock_create:mock_create.return_value = mock_stream()- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))deltas = _input_json_deltas(events)assert len(deltas) == 1@@ -1077,13 +1078,12 @@ async def test_stream_response_retries_without_reasoning_budget(nim_provider):) as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [- e- async for e in nim_provider.stream_response(+ events = await collect_anthropic(+ nim_provider.stream_response(req,reasoning=ReasoningPolicy.on(effort=ReasoningEffort.XHIGH),)- ]+ )assert mock_create.await_count == 2first_call = mock_create.await_args_list[0].kwargs@@ -1124,12 +1124,11 @@ async def test_stream_response_retries_without_budget_for_thinking_token_error() as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [- e- async for e in nim_provider.stream_response(+ events = await collect_anthropic(+ nim_provider.stream_response(req, reasoning=ReasoningPolicy.on(budget_tokens=77))- ]+ )assert mock_create.await_count == 2first_call = mock_create.await_args_list[0].kwargs@@ -1192,7 +1191,7 @@ async def test_stream_response_retries_without_reasoning_content(nim_provider):) as mock_create:mock_create.side_effect = [error, mock_stream()]- events = [e async for e in nim_provider.stream_response(req)]+ events = await collect_anthropic(nim_provider.stream_response(req))assert mock_create.await_count == 2first_call = mock_create.await_args_list[0].kwargs@@ -1217,7 +1216,7 @@ async def test_stream_response_bad_request_without_reasoning_budget_does_not_retmock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in nim_provider.stream_response(req)]+ await collect_anthropic(nim_provider.stream_response(req))assert mock_create.await_count == 1assert "Invalid request sent to provider" in exc_info.value.message@@ -1236,7 +1235,7 @@ async def test_stream_response_unrelated_internal_error_does_not_downgrade(mock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in nim_provider.stream_response(req)]+ await collect_anthropic(nim_provider.stream_response(req))assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTSassert all(@@ -1261,7 +1260,7 @@ async def test_stream_response_internal_reasoning_content_error_does_not_downgramock_create.side_effect = errorwith pytest.raises(ExecutionFailure) as exc_info:- [e async for e in nim_provider.stream_response(req)]+ await collect_anthropic(nim_provider.stream_response(req))assert mock_create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTSassert all(diff --git a/tests/providers/test_nvidia_nim_degraded_retry.py b/tests/providers/test_nvidia_nim_degraded_retry.pyindex df64b781..83558cb2 100644--- a/tests/providers/test_nvidia_nim_degraded_retry.py+++ b/tests/providers/test_nvidia_nim_degraded_retry.py@@ -20,6 +20,7 @@ from free_claude_code.providers.failure_policy import ()from free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.open_router import OpenRouterProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import make_provider_config@@ -136,12 +137,11 @@ async def test_degraded_function_retries_unchanged_request_then_succeeds() -> Noside_effect=[_bad_request(), _successful_stream()],) as create,):- events = [- event- async for event in provider.stream_response(+ events = await collect_anthropic(+ provider.stream_response(make_messages_request(), request_id="req_recovered")- ]+ )assert create.await_count == 2assert create.call_args_list[0].kwargs == create.call_args_list[1].kwargs@@ -172,12 +172,9 @@ async def test_degraded_function_exhaustion_is_detailed_redacted_overload() -> Npatch("free_claude_code.providers.openai_chat.provider.trace_event") as trace,pytest.raises(ExecutionFailure) as exc_info,):- [- event- async for event in provider.stream_response(- make_messages_request(), request_id="req_degraded"- )- ]+ await collect_anthropic(+ provider.stream_response(make_messages_request(), request_id="req_degraded")+ )assert create.await_count == UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS@@ -219,12 +216,9 @@ async def test_negative_derived_max_tokens_is_context_window_failure() as create,pytest.raises(ExecutionFailure) as exc_info,):- [- event- async for event in provider.stream_response(- make_messages_request(), request_id="req_context"- )- ]+ await collect_anthropic(+ provider.stream_response(make_messages_request(), request_id="req_context")+ )assert create.await_count == 1failure = exc_info.value@@ -255,12 +249,11 @@ async def test_negative_derived_max_tokens_is_context_window_failure_on_500() as create,pytest.raises(ExecutionFailure) as exc_info,):- [- event- async for event in provider.stream_response(+ await collect_anthropic(+ provider.stream_response(make_messages_request(), request_id="req_context_500")- ]+ )assert create.await_count == 1failure = exc_info.value@@ -299,7 +292,7 @@ async def test_other_nim_max_token_errors_remain_invalid_requests() as create,pytest.raises(ExecutionFailure) as exc_info,):- [event async for event in provider.stream_response(make_messages_request())]+ await collect_anthropic(provider.stream_response(make_messages_request()))assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUEST@@ -330,7 +323,7 @@ async def test_unrelated_nim_bad_request_is_not_retried(detail: str) -> None:) as create,pytest.raises(ExecutionFailure) as exc_info,):- [event async for event in provider.stream_response(make_messages_request())]+ await collect_anthropic(provider.stream_response(make_messages_request()))assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUEST@@ -357,7 +350,7 @@ async def test_degraded_wording_remains_non_retryable_for_other_providers() -> N) as create,pytest.raises(ExecutionFailure) as exc_info,):- [event async for event in provider.stream_response(make_messages_request())]+ await collect_anthropic(provider.stream_response(make_messages_request()))assert create.await_count == 1assert exc_info.value.kind is FailureKind.INVALID_REQUESTdiff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.pyindex 1fa5a0b2..4cde616f 100644--- a/tests/providers/test_ollama.py+++ b/tests/providers/test_ollama.py@@ -13,6 +13,7 @@ from free_claude_code.core.anthropic.stream_contracts import (thinking_content,)from free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -193,12 +194,9 @@ async def test_stream_response_uses_shared_openai_chat_provider() -> None:return_value=stream(),) as create:output = "".join(- [- event- async for event in provider.stream_response(- make_messages_request(OLLAMA_MODEL)- )- ]+ await collect_anthropic(+ provider.stream_response(make_messages_request(OLLAMA_MODEL))+ ))assert create.call_args.kwargs["stream"] is True@@ -233,12 +231,9 @@ async def test_cloud_stream_maps_ollama_reasoning_delta_to_anthropic_thinking()return_value=stream(),):output = "".join(- [- event- async for event in client.stream_response(- make_messages_request(OLLAMA_CLOUD_MODEL)- )- ]+ await collect_anthropic(+ client.stream_response(make_messages_request(OLLAMA_CLOUD_MODEL))+ ))events = parse_sse_text(output)diff --git a/tests/providers/test_open_router.py b/tests/providers/test_open_router.pyindex 1c9c5338..d692a9bf 100644--- a/tests/providers/test_open_router.py+++ b/tests/providers/test_open_router.py@@ -16,6 +16,7 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.providers.open_router import OpenRouterProviderfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (REASONING_OFF,@@ -317,10 +318,9 @@ async def test_stream_maps_reasoning_content_and_details(open_router_provider):new_callable=AsyncMock,return_value=stream,):- events = [- event- async for event in open_router_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ open_router_provider.stream_response(make_request())+ )event_text = "".join(events)parsed = parse_sse_text(event_text)diff --git a/tests/providers/test_openai_chat_usage.py b/tests/providers/test_openai_chat_usage.pyindex d87b5e63..1218ec86 100644--- a/tests/providers/test_openai_chat_usage.py+++ b/tests/providers/test_openai_chat_usage.py@@ -25,6 +25,7 @@ from free_claude_code.providers.openai_chat.usage import (request_stream_usage,usage_int,)+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -182,9 +183,9 @@ async def test_openai_chat_stream_requests_usage_and_uses_provider_prompt_tokens)with patch.object(provider._client.chat.completions, "create", create):- events = [- event async for event in provider.stream_response(request, input_tokens=7)- ]+ events = await collect_anthropic(+ provider.stream_response(request, input_tokens=7)+ )create.assert_awaited_once()await_args = create.await_args@@ -217,13 +218,12 @@ async def test_openai_chat_stream_keeps_response_model_separate_from_upstream_mo)with patch.object(provider._client.chat.completions, "create", create):- events = [- event- async for event in provider.stream_response(+ events = await collect_anthropic(+ provider.stream_response(request,response_model="anthropic/test/upstream/model",)- ]+ )assert create.await_args is not Noneassert create.await_args.kwargs["model"] == "upstream/model"diff --git a/tests/providers/test_openai_codex_provider.py b/tests/providers/test_openai_codex_provider.pyindex bd54e995..b5a6db7b 100644--- a/tests/providers/test_openai_codex_provider.py+++ b/tests/providers/test_openai_codex_provider.py@@ -8,6 +8,7 @@ import httpximport pytestfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.core.anthropic import AnthropicEventPresenterfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import (assert_anthropic_stream_contract,@@ -16,6 +17,7 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.core.diagnostics import ERROR_DETAIL_DISPLAY_CAP_BYTESfrom free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.inference import InferenceEventfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.admission import ProviderAdmissionControllerfrom free_claude_code.providers.base import ProviderConfig@@ -24,6 +26,7 @@ from free_claude_code.providers.openai_codex.auth import (OpenAIAuthManager,)from free_claude_code.providers.openai_codex.provider import OpenAICodexProvider+from tests.inference_support import collect_anthropicfrom tests.providers.support import make_provider_config@@ -158,8 +161,8 @@ def _complete_stream(text: str) -> str:)-async def _collect(stream: AsyncIterator[str]) -> str:- return "".join([chunk async for chunk in stream])+async def _collect(stream: AsyncIterator[InferenceEvent]) -> str:+ return "".join(await collect_anthropic(stream))@pytest.mark.asyncio@@ -726,14 +729,15 @@ async def test_truncated_attempt_after_commit_is_not_retried_or_duplicated() ->_config(), auth=_FakeAuth(), admission=_admission(), client=client)chunks: list[str] = []+ presenter = AnthropicEventPresenter()with pytest.raises(ExecutionFailure):- async for chunk in provider.stream_response(+ async for event in provider.stream_response(_request(),request_id="req_committed",response_model="claude-opus-4",):- chunks.extend((chunk,))+ chunks.extend(presenter.present(event))body = "".join(chunks)assert attempts == 1diff --git a/tests/providers/test_openai_compat_5xx_retry.py b/tests/providers/test_openai_compat_5xx_retry.pyindex 8fa1f323..7db937d7 100644--- a/tests/providers/test_openai_compat_5xx_retry.py+++ b/tests/providers/test_openai_compat_5xx_retry.py@@ -10,6 +10,7 @@ from httpx2 import Request, Responsefrom free_claude_code.config.nim import NimSettingsfrom free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.nvidia_nim import NvidiaNimProvider+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -72,7 +73,7 @@ async def test_nim_stream_retries_on_openai_5xx_then_streams(status_code):) as mock_create,):mock_create.side_effect = [_internal_5xx(status_code), mock_stream()]- events = [e async for e in provider.stream_response(req)]+ events = await collect_anthropic(provider.stream_response(req))assert mock_create.await_count == 2assert any("Hi" in e for e in events)@@ -116,7 +117,7 @@ async def test_nim_stream_retries_on_pre_stream_connection_error_then_streams():) as mock_create,):mock_create.side_effect = [_connection_error(), mock_stream()]- events = [e async for e in provider.stream_response(req)]+ events = await collect_anthropic(provider.stream_response(req))assert mock_create.await_count == 2assert any("Recovered" in e for e in events)@@ -151,7 +152,7 @@ async def test_nim_stream_connection_error_exhausted_emits_cause_chain():patch("free_claude_code.providers.openai_chat.provider.trace_event") as trace,pytest.raises(ExecutionFailure) as exc_info,):- [e async for e in provider.stream_response(req, request_id="req_conn")]+ await collect_anthropic(provider.stream_response(req, request_id="req_conn"))assert mock_create.await_count == 5error_traces = [@@ -204,7 +205,7 @@ async def test_nim_stream_openai_5xx_exhausted_emits_user_message():mock_create.side_effect = _internal_5xx(status_code)with pytest.raises(ExecutionFailure) as exc_info:- [e async for e in provider.stream_response(req)]+ await collect_anthropic(provider.stream_response(req))assert mock_create.await_count == 5assert expect_substr in exc_info.value.message.lower()diff --git a/tests/providers/test_openai_responses_transport.py b/tests/providers/test_openai_responses_transport.pyindex 4ad987dc..364b1bba 100644--- a/tests/providers/test_openai_responses_transport.py+++ b/tests/providers/test_openai_responses_transport.py@@ -9,6 +9,7 @@ import pytestfrom openai import AsyncOpenAIfrom free_claude_code.application.errors import InvalidRequestError+from free_claude_code.core.anthropic import AnthropicEventPresenterfrom free_claude_code.core.anthropic.models import MessagesRequestfrom free_claude_code.core.anthropic.stream_contracts import (assert_anthropic_stream_contract,@@ -18,6 +19,7 @@ from free_claude_code.core.anthropic.stream_contracts import ()from free_claude_code.core.failures import ExecutionFailurefrom free_claude_code.providers.openai_responses import OpenAIResponsesTransport+from tests.inference_support import collect_anthropicfrom tests.providers.support import REASONING_ON, immediate_admission@@ -124,7 +126,6 @@ def _transport(client: AsyncOpenAI, *, max_attempts: int = 5):),provider_name="TEST_RESPONSES",read_timeout_s=120.0,- log_raw_sse_events=False,)@@ -132,16 +133,15 @@ async def _collect(transport: OpenAIResponsesTransport,request: MessagesRequest | None = None,) -> list[str]:- return [- chunk- async for chunk in transport.stream_response(+ return await collect_anthropic(+ transport.stream_response(request or _request(),input_tokens=11,request_id="req_responses",response_model="public-model",reasoning=REASONING_ON,)- ]+ )@pytest.mark.asyncio@@ -367,16 +367,17 @@ async def test_post_commit_truncation_is_not_replayed() -> None:client = _client(handler)chunks: list[str] = []+ presenter = AnthropicEventPresenter()try:with pytest.raises(ExecutionFailure):- async for chunk in _transport(client).stream_response(+ async for event in _transport(client).stream_response(_request(),input_tokens=1,request_id="req_committed",response_model="public-model",reasoning=REASONING_ON,):- chunks.extend((chunk,))+ chunks.extend(presenter.present(event))finally:await client.close()diff --git a/tests/providers/test_opencode.py b/tests/providers/test_opencode.pyindex 23108b31..7d3a9355 100644--- a/tests/providers/test_opencode.py+++ b/tests/providers/test_opencode.py@@ -30,6 +30,7 @@ from free_claude_code.providers.opencode.catalog import (OpenCodeUpstreamTransport,parse_open_code_catalog,)+from tests.inference_support import collect_anthropicfrom tests.providers.support import (capture_openai_chat_wire_body,immediate_admission,@@ -231,14 +232,13 @@ def _provider_with_wire_transports(async def _collect(provider: OpenCodeProvider, model: str, **overrides: object) -> str:return "".join(- [- chunk- async for chunk in provider.stream_response(+ await collect_anthropic(+ provider.stream_response(_request(model, **overrides),input_tokens=2,request_id="req_opencode",)- ]+ ))diff --git a/tests/providers/test_preflight_contract.py b/tests/providers/test_preflight_contract.pyindex cfe4ae68..2dfe97dc 100644--- a/tests/providers/test_preflight_contract.py+++ b/tests/providers/test_preflight_contract.py@@ -6,6 +6,7 @@ import pytestfrom free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.core.anthropic.models import Message, MessagesRequest+from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedgerfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.base import BaseProviderfrom free_claude_code.providers.openai_chat import OpenAIChatProvider@@ -41,9 +42,9 @@ class ProviderWithoutPreflight(BaseProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:if False:- yield ""+ yield InferenceStreamLedger("unused", "unused").start_response()def test_provider_base_requires_an_explicit_preflight_implementation() -> None:diff --git a/tests/providers/test_sambanova.py b/tests/providers/test_sambanova.pyindex 9d9c5ada..494170e8 100644--- a/tests/providers/test_sambanova.py+++ b/tests/providers/test_sambanova.py@@ -7,6 +7,7 @@ import pytestfrom free_claude_code.config.provider_catalog import SAMBANOVA_DEFAULT_BASEfrom free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicy+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -129,9 +130,9 @@ async def test_stream_response_text(sambanova_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in sambanova_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ sambanova_provider.stream_response(make_request())+ )assert any('"text_delta"' in event and "Hello from SambaNova" in event for event in events@@ -164,9 +165,9 @@ async def test_stream_response_tool_call(sambanova_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in sambanova_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ sambanova_provider.stream_response(make_request())+ )assert any('"content_block_start"' in event and '"tool_use"' in event for event in events@@ -200,9 +201,9 @@ async def test_stream_response_reasoning_content(sambanova_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in sambanova_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ sambanova_provider.stream_response(make_request())+ )assert any('"thinking_delta"' in event and "Thinking via SambaNova" in eventdiff --git a/tests/providers/test_stream_recovery.py b/tests/providers/test_stream_recovery.pyindex 959d6ab2..2c493fe6 100644--- a/tests/providers/test_stream_recovery.py+++ b/tests/providers/test_stream_recovery.py@@ -1,5 +1,10 @@"""Provider stream commit-boundary and recovery policy."""+from free_claude_code.core.inference import (+ ResponseStarted,+ TextDelta,+ inference_event_size,+)from free_claude_code.providers.stream_recovery import (RecoveryController,RecoveryFailureAction,@@ -7,10 +12,14 @@ from free_claude_code.providers.stream_recovery import ()+def _event(label: str) -> TextDelta:+ return TextDelta(block_id="test-block", delta=label)++def test_early_retry_discards_uncommitted_holdback() -> None:controller = RecoveryController()- assert controller.push("hidden") == []+ assert controller.push(_event("hidden")) == []decision = controller.advance_failure(retryable=True,stream_opened=True,@@ -29,7 +38,7 @@ def test_early_retry_discards_uncommitted_holdback() -> None:def test_early_retry_requires_remaining_execution_budget() -> None:controller = RecoveryController()- assert controller.push("hidden") == []+ assert controller.push(_event("hidden")) == []decision = controller.advance_failure(retryable=True,@@ -46,7 +55,7 @@ def test_early_retry_requires_remaining_execution_budget() -> None:def test_last_attempt_is_reserved_for_partial_output_recovery() -> None:controller = RecoveryController()- assert controller.push("partial") == []+ assert controller.push(_event("partial")) == []decision = controller.advance_failure(retryable=True,@@ -90,8 +99,9 @@ def test_statusless_transient_api_error_allows_early_retry() -> None:def test_committed_output_allows_midstream_recovery() -> None:controller = RecoveryController()- assert controller.push("event: content_block_delta\n\n") == []- assert controller.flush() == ["event: content_block_delta\n\n"]+ event = _event("committed")+ assert controller.push(event) == []+ assert controller.flush() == [event]decision = controller.advance_failure(retryable=True,stream_opened=True,@@ -109,7 +119,8 @@ def test_committed_output_allows_midstream_recovery() -> None:def test_uncommitted_complete_tool_can_be_salvaged() -> None:controller = RecoveryController()- assert controller.push("event: content_block_delta\n\n") == []+ event = _event("salvageable")+ assert controller.push(event) == []decision = controller.advance_failure(retryable=True,stream_opened=True,@@ -121,7 +132,7 @@ def test_uncommitted_complete_tool_can_be_salvaged() -> None:assert decision.action == RecoveryFailureAction.MIDSTREAM_RECOVERYassert not decision.committedassert decision.has_buffered- assert controller.flush_uncommitted(decision) == ["event: content_block_delta\n\n"]+ assert controller.flush_uncommitted(decision) == [event]assert controller.committedassert not controller.has_buffered@@ -143,33 +154,52 @@ def test_holdback_buffers_until_delay_then_commits() -> None:now = [10.0]holdback = RecoveryHoldbackBuffer(holdback_seconds=0.75, now=lambda: now[0])- assert holdback.push("event: content_block_start\n\n") == []+ started = _event("started")+ delta = _event("delta")+ completed = _event("completed")+ terminal = _event("terminal")++ assert holdback.push(started) == []now[0] += 0.74- assert holdback.push("event: content_block_delta\n\n") == []+ assert holdback.push(delta) == []assert not holdback.committednow[0] += 0.01- assert holdback.push("event: content_block_stop\n\n") == [- "event: content_block_start\n\n",- "event: content_block_delta\n\n",- "event: content_block_stop\n\n",- ]+ assert holdback.push(completed) == [started, delta, completed]assert holdback.committed- assert holdback.push("event: message_stop\n\n") == ["event: message_stop\n\n"]+ assert holdback.push(terminal) == [terminal]+++def test_synthetic_response_start_does_not_age_holdback_before_provider_output() -> (+ None+):+ now = [10.0]+ holdback = RecoveryHoldbackBuffer(holdback_seconds=0.75, now=lambda: now[0])+ started = ResponseStarted("response_test", "test-model")++ assert holdback.push(started) == []+ now[0] += 10.0+ assert holdback.push(_event("first-provider-output")) == []+ assert not holdback.committeddef test_holdback_flushes_at_internal_buffer_cap() -> None:- holdback = RecoveryHoldbackBuffer(max_bytes=5, now=lambda: 1.0)+ first = _event("ab")+ second = _event("cde")+ holdback = RecoveryHoldbackBuffer(+ max_bytes=inference_event_size(first) + inference_event_size(second),+ now=lambda: 1.0,+ )- assert holdback.push("ab") == []- assert holdback.push("cde") == ["ab", "cde"]+ assert holdback.push(first) == []+ assert holdback.push(second) == [first, second]assert holdback.committeddef test_holdback_discard_drops_uncommitted_events() -> None:holdback = RecoveryHoldbackBuffer(now=lambda: 1.0)- assert holdback.push("hidden") == []+ assert holdback.push(_event("hidden")) == []holdback.discard()assert holdback.flush() == []diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 13a33cdb..46c944e3 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -2,6 +2,7 @@import asyncioimport json+from collections.abc import Iterablefrom types import SimpleNamespacefrom unittest.mock import AsyncMock, MagicMock, patch@@ -11,16 +12,20 @@ import openaiimport pytestfrom free_claude_code.config.nim import NimSettings-from free_claude_code.core.anthropic import OpenAIToolNameCodec+from free_claude_code.core.anthropic import AnthropicEventPresenter, OpenAIToolNameCodecfrom free_claude_code.core.anthropic.stream_contracts import (parse_sse_text,)from free_claude_code.core.anthropic.streaming import (- AnthropicStreamLedger,make_response_recovery_body,make_text_recovery_body,)from free_claude_code.core.failures import ExecutionFailure+from free_claude_code.core.inference import (+ InferenceEvent,+ InferenceStreamLedger,+ ResponseStarted,+)from free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.providers.admission import (UPSTREAM_TRANSIENT_TOTAL_ATTEMPTS,@@ -33,8 +38,8 @@ from free_claude_code.providers.openai_chat.provider import (from free_claude_code.providers.openai_chat.tool_calls import (OpenAIToolCallAssembler,OpenAIToolCallCollector,- has_committed_sse_output,- iter_heuristic_tool_use_sse,+ has_generated_output,+ iter_heuristic_tool_use_events,)from free_claude_code.providers.stream_recovery import TruncatedProviderStreamErrorfrom tests.providers.request_factory import make_messages_request@@ -210,7 +215,11 @@ async def _collect_stream(reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,):"""Collect all SSE events from a stream."""- return [e async for e in provider.stream_response(request, reasoning=reasoning)]+ presenter = AnthropicEventPresenter()+ output: list[str] = []+ async for event in provider.stream_response(request, reasoning=reasoning):+ output.extend(presenter.present(event))+ return outputasync def _collect_stream_error(provider, request, **kwargs) -> ExecutionFailure:@@ -223,12 +232,27 @@ async def _collect_stream_and_error(provider, request, **kwargs) -> tuple[list[str], ExecutionFailure]:events: list[str] = []+ presenter = AnthropicEventPresenter()with pytest.raises(ExecutionFailure) as exc_info:async for event in provider.stream_response(request, **kwargs):- events.extend((event,))+ events.extend(presenter.present(event))return events, exc_info.value+def _test_ledger() -> InferenceStreamLedger:+ ledger = InferenceStreamLedger("response_test", "test-model")+ ledger.start_response()+ return ledger+++def _wire(events: Iterable[InferenceEvent]) -> str:+ presenter = AnthropicEventPresenter()+ chunks = presenter.present(ResponseStarted("response_test", "test-model"))+ for event in events:+ chunks.extend(presenter.present(event))+ return "".join(chunks)++def _assert_no_content_deltas_after_error_text(events: list[str], error_substr: str) -> None:@@ -1660,9 +1684,9 @@ class TestStreamingExceptionHandling:runner = _make_stream_runner(_make_provider(), request=_make_request(), request_id="req_recovery")- ledger = AnthropicStreamLedger("msg_recovery", "model")- ledger.start_thinking_block()- ledger.emit_thinking_delta("hidden reasoning")+ ledger = _test_ledger()+ ledger.start_reasoning_block()+ ledger.emit_reasoning_delta("hidden reasoning")list(ledger.ensure_text_block())ledger.emit_text_delta("visible answer")@@ -1844,11 +1868,9 @@ class TestProcessToolCall:def test_heuristic_tool_use_sse_marks_committed_tool_output(self):"""Heuristic tool blocks are emitted content, even without OpenAI tool state."""- from free_claude_code.core.anthropic import AnthropicStreamLedger-- ledger = AnthropicStreamLedger("msg_test", "test-model")+ ledger = _test_ledger()events = list(- iter_heuristic_tool_use_sse(+ iter_heuristic_tool_use_events(ledger,{"id": "toolu_heuristic",@@ -1858,24 +1880,22 @@ class TestProcessToolCall:))- event_text = "".join(events)+ event_text = _wire(events)assert "tool_use" in event_textassert ledger.has_emitted_tool_block()- assert has_committed_sse_output(ledger)+ assert has_generated_output(ledger)def test_tool_call_with_id(self):"""Tool call with id starts a tool block."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc = {"index": 0,"id": "call_123","function": {"name": "search", "arguments": '{"q": "test"}'},}events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))- event_text = "".join(events)+ event_text = _wire(events)assert "tool_use" in event_textassert "search" in event_textassert "call_123" in event_text@@ -1889,7 +1909,7 @@ class TestProcessToolCall:)codec = OpenAIToolNameCodec.from_request(request)alias = codec.encode(original)- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()events = list(_make_tool_assembler(provider).process_tool_call(@@ -1904,7 +1924,7 @@ class TestProcessToolCall:))- event_text = "".join(events)+ event_text = _wire(events)assert original in event_textassert alias not in event_textassert (@@ -1932,7 +1952,7 @@ class TestProcessToolCall:])codec = OpenAIToolNameCodec.from_request(request)- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()events = list(_make_tool_assembler(provider).process_tool_call(@@ -1952,7 +1972,7 @@ class TestProcessToolCall:))- parsed = parse_sse_text("".join(events))+ parsed = parse_sse_text(_wire(events))start = next(event.data["content_block"]for event in parsed@@ -1977,7 +1997,7 @@ class TestProcessToolCall:alias = codec.encode(original)split = len(alias) // 2buffers: dict[int, str] = {}- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()assembler = _make_tool_assembler(provider)first = list(@@ -2006,7 +2026,7 @@ class TestProcessToolCall:)assert first == []- event_text = "".join(second)+ event_text = _wire(second)assert original in event_textassert alias not in event_textassert (@@ -2032,7 +2052,7 @@ class TestProcessToolCall:codec = OpenAIToolNameCodec.from_request(request)assert codec.is_alias_prefix(original)buffers: dict[int, str] = {}- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()assembler = _make_tool_assembler(provider)initial = list(@@ -2058,7 +2078,7 @@ class TestProcessToolCall:)assert initial == []- assert original in "".join(flushed)+ assert original in _wire(flushed)assert buffers == {}def test_buffered_collector_decodes_before_schema_validation(self):@@ -2089,10 +2109,10 @@ class TestProcessToolCall:tools=[{"name": original, "input_schema": {"type": "object"}}])codec = OpenAIToolNameCodec.from_request(request)- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()events = list(- iter_heuristic_tool_use_sse(+ iter_heuristic_tool_use_events(sse,{"id": "call_heuristic",@@ -2103,16 +2123,14 @@ class TestProcessToolCall:))- event_text = "".join(events)+ event_text = _wire(events)assert original in event_textassert codec.encode(original) not in event_textdef test_tool_call_id_arrives_before_name_still_emits_id_and_name(self):"""Split-stream tool: id (no name) then name then args; id preserved on start."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()t1 = {"index": 0,"id": "call_split",@@ -2128,20 +2146,18 @@ class TestProcessToolCall:"id": "call_split","function": {"name": None, "arguments": "{}"},}- b1 = "".join(_make_tool_assembler(provider).process_tool_call(t1, sse))- b2 = "".join(_make_tool_assembler(provider).process_tool_call(t2, sse))- b3 = "".join(_make_tool_assembler(provider).process_tool_call(t3, sse))- combined = b1 + b2 + b3+ events1 = list(_make_tool_assembler(provider).process_tool_call(t1, sse))+ events2 = list(_make_tool_assembler(provider).process_tool_call(t2, sse))+ events3 = list(_make_tool_assembler(provider).process_tool_call(t3, sse))+ combined = _wire(events1 + events2 + events3)assert "call_split" in combinedassert "Grep" in combined- assert b1 == ""+ assert events1 == []def test_tool_call_arguments_buffered_until_name(self):"""Argument deltas before tool name are emitted after the block starts."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()t1 = {"index": 0,"id": "call_buf",@@ -2152,10 +2168,10 @@ class TestProcessToolCall:"id": "call_buf","function": {"name": "Read", "arguments": "1}"},}- b1 = "".join(_make_tool_assembler(provider).process_tool_call(t1, sse))- b2 = "".join(_make_tool_assembler(provider).process_tool_call(t2, sse))- assert b1 == ""- combined = b2+ events1 = list(_make_tool_assembler(provider).process_tool_call(t1, sse))+ events2 = list(_make_tool_assembler(provider).process_tool_call(t2, sse))+ assert events1 == []+ combined = _wire(events1 + events2)assert "Read" in combinedassert "call_buf" in combinedassert '{"x":' in combined or "partial_json" in combined@@ -2163,24 +2179,20 @@ class TestProcessToolCall:def test_tool_call_without_id_generates_uuid(self):"""Tool call without id generates a uuid-based id."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc = {"index": 0,"id": None,"function": {"name": "test", "arguments": "{}"},}events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))- event_text = "".join(events)+ event_text = _wire(events)assert "tool_" in event_textdef test_task_tool_forces_background_false(self):"""Task tool with run_in_background=true is forced to false."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()args = json.dumps({"run_in_background": True, "prompt": "test"})tc = {"index": 0,@@ -2188,16 +2200,14 @@ class TestProcessToolCall:"function": {"name": "Task", "arguments": args},}events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))- event_text = "".join(events)+ event_text = _wire(events)# The intercepted args should have run_in_background=falseassert "false" in event_text.lower()def test_task_tool_chunked_args_forces_background_false(self):"""Chunked Task args are buffered until valid JSON, then forced to false."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc1 = {"index": 0,"id": "call_task_chunked",@@ -2211,18 +2221,16 @@ class TestProcessToolCall:events1 = list(_make_tool_assembler(provider).process_tool_call(tc1, sse))assert len(events1) > 0- assert "false" not in "".join(events1).lower()+ assert "false" not in _wire(events1).lower()events2 = list(_make_tool_assembler(provider).process_tool_call(tc2, sse))- event_text = "".join(events1 + events2)+ event_text = _wire(events1 + events2)assert "false" in event_text.lower()def test_task_tool_invalid_json_logs_warning_on_flush(self, caplog):"""Invalid JSON args for Task tool emits {} on flush and logs a warning."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc = {"index": 0,"id": "call_task2",@@ -2234,15 +2242,13 @@ class TestProcessToolCall:with caplog.at_level("WARNING"):flushed = list(_make_tool_assembler(provider).flush_task_arg_buffers(sse))assert len(flushed) > 0- assert "{}" in "".join(flushed)+ assert "{}" in _wire(events + flushed)assert any("Task args invalid JSON" in r.message for r in caplog.records)def test_negative_tool_index_fallback(self):"""tc_index < 0 uses len(tool_indices) as fallback."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc = {"index": -1,"id": "call_neg",@@ -2255,16 +2261,14 @@ class TestProcessToolCall:def test_none_tool_index_defaults_to_zero(self):"""Gemini may stream tool_call deltas with a null index."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc = {"index": None,"id": "call_none","function": {"name": "test", "arguments": "{}"},}events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))- event_text = "".join(events)+ event_text = _wire(events)assert "tool_use" in event_textassert "call_none" in event_text@@ -2272,16 +2276,14 @@ class TestProcessToolCall:def test_tool_args_emitted_as_delta(self):"""Arguments are emitted as input_json_delta events."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc = {"index": 0,"id": "call_args","function": {"name": "grep", "arguments": '{"pattern": "test"}'},}events = list(_make_tool_assembler(provider).process_tool_call(tc, sse))- event_text = "".join(events)+ event_text = _wire(events)assert "input_json_delta" in event_text@@ -2371,9 +2373,7 @@ class TestStreamChunkEdgeCases:def test_stream_malformed_tool_args_chunked(self):"""Chunked tool args that never form valid JSON are flushed with {}."""provider = _make_provider()- from free_claude_code.core.anthropic import AnthropicStreamLedger-- sse = AnthropicStreamLedger("msg_test", "test-model")+ sse = _test_ledger()tc1 = {"index": 0,"id": "call_malformed",@@ -2389,7 +2389,7 @@ class TestStreamChunkEdgeCases:events2 = list(_make_tool_assembler(provider).process_tool_call(tc2, sse))flushed = list(_make_tool_assembler(provider).flush_task_arg_buffers(sse))- event_text = "".join(events1 + events2 + flushed)+ event_text = _wire(events1 + events2 + flushed)assert "tool_use" in event_textassert "{}" in event_textdiff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.pyindex ab1af632..bb49fbce 100644--- a/tests/providers/test_subagent_interception.py+++ b/tests/providers/test_subagent_interception.py@@ -5,7 +5,7 @@ import pytestfrom free_claude_code.config.nim import NimSettingsfrom free_claude_code.config.provider_catalog import NVIDIA_NIM_DEFAULT_BASE-from free_claude_code.core.anthropic import StreamBlockLedger+from free_claude_code.core.inference import InferenceBlockLedgerfrom free_claude_code.providers.nvidia_nim import NvidiaNimProviderfrom free_claude_code.providers.openai_chat.tool_calls import (OpenAIToolCallAssembler,@@ -26,12 +26,12 @@ async def test_task_tool_interception():admission=immediate_admission(),)- # Mock request and stream ledger with real StreamBlockLedger+ # Mock request and stream ledger with the real canonical block ledger.request = MagicMock()request.model = "test-model"sse = MagicMock()- sse.blocks = StreamBlockLedger()+ sse.blocks = InferenceBlockLedger()# Tool call data (Task tool)tc = {diff --git a/tests/providers/test_vercel.py b/tests/providers/test_vercel.pyindex 48b1370c..6f6ffd27 100644--- a/tests/providers/test_vercel.py+++ b/tests/providers/test_vercel.py@@ -6,6 +6,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport pytestfrom free_claude_code.config.provider_catalog import VERCEL_AI_GATEWAY_DEFAULT_BASE+from tests.inference_support import collect_anthropicfrom tests.providers.request_factory import make_messages_requestfrom tests.providers.support import (immediate_admission,@@ -117,9 +118,9 @@ async def test_stream_response_text(vercel_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in vercel_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ vercel_provider.stream_response(make_request())+ )assert any('"text_delta"' in event and "Hello from Vercel" in event for event in events@@ -149,9 +150,9 @@ async def test_stream_response_reasoning_content(vercel_provider):) as mock_create:mock_create.return_value = mock_stream()- events = [- event async for event in vercel_provider.stream_response(make_request())- ]+ events = await collect_anthropic(+ vercel_provider.stream_response(make_request())+ )assert any('"thinking_delta"' in event and "Thinking via gateway" in eventdiff --git a/tests/providers/test_zenmux.py b/tests/providers/test_zenmux.pyindex 4db5abd3..ccbd42ab 100644--- a/tests/providers/test_zenmux.py+++ b/tests/providers/test_zenmux.py@@ -21,6 +21,7 @@ from free_claude_code.core.anthropic.stream_contracts import (from free_claude_code.core.reasoning import ReasoningEffort, ReasoningPolicyfrom free_claude_code.providers.model_listing import ModelListResponseErrorfrom free_claude_code.providers.openai_chat import OpenAIChatProvider+from tests.inference_support import collect_anthropicfrom tests.providers.support import (immediate_admission,make_provider_config,@@ -333,7 +334,7 @@ async def test_stream_preserves_signed_details_without_duplicating_reasoning(return_value=stream,):event_text = "".join(- [event async for event in zenmux_provider.stream_response(_request())]+ await collect_anthropic(zenmux_provider.stream_response(_request())))events = parse_sse_text(event_text)diff --git a/tests/runtime/test_application_runtime.py b/tests/runtime/test_application_runtime.pyindex be5e19c4..e493e50e 100644--- a/tests/runtime/test_application_runtime.py+++ b/tests/runtime/test_application_runtime.py@@ -16,6 +16,7 @@ from free_claude_code.application.model_metadata import ProviderModelInfofrom free_claude_code.config.admin.persistence import PreparedAdminUpdatefrom free_claude_code.config.settings import Settingsfrom free_claude_code.core.anthropic.models import MessagesRequest+from free_claude_code.core.inference import InferenceEvent, InferenceStreamLedgerfrom free_claude_code.core.reasoning import DEFAULT_REASONING_POLICY, ReasoningPolicyfrom free_claude_code.messaging.command_context import StopOutcomefrom free_claude_code.messaging.platforms.ports import (@@ -82,9 +83,9 @@ class AdminModelProvider(BaseProvider):request_id: str | None = None,response_model: str | None = None,reasoning: ReasoningPolicy = DEFAULT_REASONING_POLICY,- ) -> AsyncIterator[str]:+ ) -> AsyncIterator[InferenceEvent]:if False:- yield ""+ yield InferenceStreamLedger("unused", "unused").start_response()class TrackingFactory:diff --git a/uv.lock b/uv.lockindex 529189fc..10c2eeec 100644--- a/uv.lock+++ b/uv.lock@@ -607,7 +607,7 @@ wheels = [[[package]]name = "free-claude-code"-version = "5.14.1"+version = "5.14.2"source = { editable = "." }dependencies = [{ name = "aiohttp" },