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
Refactor provider stream engine (#883)
Ali Khokhar60e5797ce426
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.mdindex 0b258012..9fe57418 100644--- a/ARCHITECTURE.md+++ b/ARCHITECTURE.md@@ -348,23 +348,22 @@ where supported, and returning Anthropic SSE strings to the service layer.- content and message conversion for OpenAI-compatible upstreams;- tool schema and tool-result handling;- thinking block handling;-- SSE event formatting through `SSEBuilder`;+- stream lifecycle through `core/anthropic/streaming`, including the neutral+ stream ledger, Anthropic SSE emitter, native event normalization, retry+ holdback, continuation, and tool repair;- native Anthropic stream policy;-- stream recovery policy, holdback, continuation, and repair helpers;- token counting and user-facing error formatting.-Shared stream recovery policy lives in-[core/anthropic/stream_recovery_session.py](core/anthropic/stream_recovery_session.py)-and [core/anthropic/stream_recovery.py](core/anthropic/stream_recovery.py). The-shared layer owns early retry classification, holdback buffering, retry attempt-counting, and common flush/discard behavior. Provider transports still own-upstream request construction, stream semantic parsing, transport-specific state-tracking, and the actual recovery SSE events emitted for OpenAI-chat or native-Anthropic streams. Per-request stream runners in-[providers/transports/openai_chat/](providers/transports/openai_chat/) and-[providers/transports/anthropic_messages/](providers/transports/anthropic_messages/)-own mutable stream state so transport base classes stay focused on provider-hooks, client setup, and model listing.+Shared stream behavior lives under+[core/anthropic/streaming/](core/anthropic/streaming/). The shared layer owns the+Anthropic content-block ledger, SSE serialization, early retry classification,+holdback buffering, retry attempt counting, common flush/discard behavior,+midstream continuation, tool JSON repair, and final success/error tails. Provider+transport packages are upstream adapters: OpenAI-chat providers convert chat+chunks into ledger operations, and native Anthropic providers parse upstream SSE,+apply native block policy, and re-emit normalized Anthropic SSE from the shared+ledger. Transport bases stay focused on provider hooks, client setup, request+construction, rate limiting, and model listing.[core/openai_responses/](core/openai_responses/) owns OpenAI Responses support:diff --git a/api/request_pipeline.py b/api/request_pipeline.pyindex 7f56d931..eb0cacd4 100644--- a/api/request_pipeline.py+++ b/api/request_pipeline.py@@ -15,7 +15,7 @@ from loguru import loggerfrom config.provider_catalog import PROVIDER_CATALOGfrom config.settings import Settingsfrom core.anthropic import get_token_count, get_user_facing_error_message-from core.anthropic.sse import ANTHROPIC_SSE_RESPONSE_HEADERS+from core.anthropic.streaming import ANTHROPIC_SSE_RESPONSE_HEADERSfrom core.openai_responses import OpenAIResponsesAdapterfrom core.trace import api_messages_request_snapshot, trace_event, traced_async_streamfrom providers.base import BaseProviderdiff --git a/api/web_tools/streaming.py b/api/web_tools/streaming.pyindex eb9b4148..db5e9b8e 100644--- a/api/web_tools/streaming.py+++ b/api/web_tools/streaming.py@@ -15,7 +15,7 @@ from core.anthropic.server_tool_sse import (WEB_SEARCH_TOOL_RESULT,WEB_SEARCH_TOOL_RESULT_ERROR,)-from core.anthropic.sse import format_sse_event+from core.anthropic.streaming import format_sse_eventfrom . import outboundfrom .constants import _MAX_FETCH_CHARSdiff --git a/core/anthropic/__init__.py b/core/anthropic/__init__.pyindex c4bf7af2..9df06a0a 100644--- a/core/anthropic/__init__.py+++ b/core/anthropic/__init__.py@@ -14,22 +14,29 @@ from .errors import ()from .native_messages_request import sanitize_native_messages_thinking_policyfrom .provider_stream_error import iter_provider_stream_error_sse_events-from .sse import ContentBlockManager, SSEBuilder, format_sse_event, map_stop_reason+from .streaming import (+ AnthropicStreamLedger,+ StreamBlockLedger,+ ToolBlockState,+ format_sse_event,+ map_stop_reason,+)from .thinking import ContentChunk, ContentType, ThinkTagParserfrom .tokens import get_token_countfrom .tools import HeuristicToolParserfrom .utils import set_if_not_none__all__ = [+ "AnthropicStreamLedger","AnthropicToOpenAIConverter",- "ContentBlockManager","ContentChunk","ContentType","HeuristicToolParser","OpenAIConversionError","ReasoningReplayMode",- "SSEBuilder",+ "StreamBlockLedger","ThinkTagParser",+ "ToolBlockState","append_request_id","build_base_request_body","extract_text_from_content",diff --git a/core/anthropic/emitted_sse_tracker.py b/core/anthropic/emitted_sse_tracker.pydeleted file mode 100644index f55c899b..00000000--- a/core/anthropic/emitted_sse_tracker.py+++ /dev/null@@ -1,346 +0,0 @@-"""Track content-block state for native Anthropic SSE strings we emit to clients."""--from __future__ import annotations--import uuid-from collections.abc import Iterator-from contextlib import suppress-from dataclasses import dataclass, field-from typing import Any--from core.anthropic.sse import SSEBuilder, format_sse_event-from core.anthropic.stream_contracts import SSEEvent, parse_sse_lines-from core.anthropic.stream_recovery import (- ToolSchema,- accept_tool_json_repair,- continuation_suffix,- parse_complete_tool_input,-)---@dataclass-class EmittedBlockState:- """Tracked downstream block payload emitted to the client."""-- index: int- block_type: str- open: bool = True- tool_id: str = ""- name: str = ""- parts: list[str] = field(default_factory=list)-- @property- def content(self) -> str:- return "".join(self.parts)---class EmittedNativeSseTracker:- """Parse emitted SSE frames so mid-stream errors can close blocks and pick a fresh index."""-- def __init__(self) -> None:- self._buf = ""- self._open_stack: list[int] = []- self._max_index = -1- self._blocks: dict[int, EmittedBlockState] = {}- self.message_id: str | None = None- self.model: str = ""- self.stop_reason: str | None = None- self.message_stopped = False-- def feed(self, chunk: str) -> None:- """Record SSE frames completed by ``chunk`` (handles splitting across reads)."""- self._buf += chunk- while True:- sep = self._buf.find("\n\n")- if sep < 0:- break- frame = self._buf[:sep]- self._buf = self._buf[sep + 2 :]- if not frame.strip():- continue- for event in parse_sse_lines(frame.splitlines()):- self._observe(event)-- def _observe(self, event: SSEEvent) -> None:- if event.event == "message_start":- message = event.data.get("message")- if isinstance(message, dict):- mid = message.get("id")- if isinstance(mid, str) and mid:- self.message_id = mid- model = message.get("model")- if isinstance(model, str) and model:- self.model = model- return-- if event.event == "content_block_start":- raw_index = event.data.get("index")- if not isinstance(raw_index, int):- return- idx = raw_index- self._max_index = max(self._max_index, idx)- self._open_stack.append(idx)- block = event.data.get("content_block")- if isinstance(block, dict):- block_type = str(block.get("type", ""))- state = EmittedBlockState(index=idx, 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 ""- elif block_type == "text":- text = block.get("text")- if isinstance(text, str) and text:- state.parts.append(text)- elif block_type == "thinking":- thinking = block.get("thinking")- if isinstance(thinking, str) and thinking:- state.parts.append(thinking)- self._blocks[idx] = state- return-- if event.event == "content_block_delta":- raw_index = event.data.get("index")- if not isinstance(raw_index, int):- return- idx = raw_index- state = self._blocks.get(idx)- delta = event.data.get("delta")- if state is not None and isinstance(delta, dict):- if state.block_type == "text":- text = delta.get("text")- if isinstance(text, str):- state.parts.append(text)- elif state.block_type == "thinking":- thinking = delta.get("thinking")- if isinstance(thinking, str):- state.parts.append(thinking)- elif state.block_type == "tool_use":- partial = delta.get("partial_json")- if isinstance(partial, str):- state.parts.append(partial)- return-- if event.event == "content_block_stop":- raw_index = event.data.get("index")- if not isinstance(raw_index, int):- return- idx = raw_index- if self._open_stack and self._open_stack[-1] == idx:- self._open_stack.pop()- else:- with suppress(ValueError):- self._open_stack.remove(idx)- state = self._blocks.get(idx)- if state is not None:- state.open = False- return-- if event.event == "message_delta":- delta = event.data.get("delta")- if isinstance(delta, dict):- stop_reason = delta.get("stop_reason")- if isinstance(stop_reason, str):- self.stop_reason = stop_reason- return-- if event.event == "message_stop":- self.message_stopped = True-- def next_content_index(self) -> int:- """Next unused content block index based on emitted starts."""- return self._max_index + 1-- def iter_close_unclosed_blocks(self) -> Iterator[str]:- """Yield ``content_block_stop`` events for blocks that were started but not stopped."""- while self._open_stack:- idx = self._open_stack.pop()- state = self._blocks.get(idx)- if state is not None:- state.open = False- yield format_sse_event(- "content_block_stop",- {"type": "content_block_stop", "index": idx},- )-- def emitted_text(self) -> str:- return "".join(- block.content- for block in self._blocks.values()- if block.block_type == "text"- )-- def emitted_thinking(self) -> str:- return "".join(- block.content- for block in self._blocks.values()- if block.block_type == "thinking"- )-- def has_tool_block(self) -> bool:- return any(block.block_type == "tool_use" for block in self._blocks.values())-- def has_content_block(self) -> bool:- return bool(self._blocks)-- def has_terminal_message(self) -> bool:- return self.message_stopped-- def tool_blocks(self) -> list[EmittedBlockState]:- return [- block for block in self._blocks.values() if block.block_type == "tool_use"- ]-- 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 append_text_suffix(self, suffix: str) -> Iterator[str]:- if not suffix:- return- active = self._last_open_block("text")- if active is None:- index = self.next_content_index()- self._max_index = max(self._max_index, index)- active = EmittedBlockState(index=index, block_type="text")- self._blocks[index] = active- self._open_stack.append(index)- yield format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": index,- "content_block": {"type": "text", "text": ""},- },- )- active.parts.append(suffix)- yield format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": active.index,- "delta": {"type": "text_delta", "text": suffix},- },- )-- def append_thinking_suffix(self, suffix: str) -> Iterator[str]:- if not suffix:- return- active = self._last_open_block("thinking")- if active is None:- index = self.next_content_index()- self._max_index = max(self._max_index, index)- active = EmittedBlockState(index=index, block_type="thinking")- self._blocks[index] = active- self._open_stack.append(index)- yield format_sse_event(- "content_block_start",- {- "type": "content_block_start",- "index": index,- "content_block": {"type": "thinking", "thinking": ""},- },- )- active.parts.append(suffix)- yield format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": active.index,- "delta": {"type": "thinking_delta", "thinking": suffix},- },- )-- def append_tool_repair_suffix(- self,- tool_index: int,- suffix: str,- ) -> Iterator[str]:- tool_blocks = self.tool_blocks()- if tool_index >= len(tool_blocks) or not suffix:- return- block = tool_blocks[tool_index]- block.parts.append(suffix)- yield format_sse_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": block.index,- "delta": {"type": "input_json_delta", "partial_json": suffix},- },- )-- def iter_success_tail(self, stop_reason: str) -> Iterator[str]:- yield from self.iter_close_unclosed_blocks()- if self.stop_reason is None:- yield format_sse_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": stop_reason, "stop_sequence": None},- "usage": {"input_tokens": 0, "output_tokens": 1},- },- )- if not self.message_stopped:- yield format_sse_event("message_stop", {"type": "message_stop"})-- def accept_tool_repair(- self,- tool_index: int,- candidate: str,- schemas: dict[str, ToolSchema],- ) -> str | None:- tool_blocks = self.tool_blocks()- if tool_index >= len(tool_blocks):- return None- block = tool_blocks[tool_index]- repair = accept_tool_json_repair(- block.content,- candidate,- tool_name=block.name,- schemas=schemas,- )- return repair.suffix if repair is not None else None-- def continuation_text_suffix(self, candidate: str) -> str | None:- return continuation_suffix(self.emitted_text(), candidate)-- def continuation_thinking_suffix(self, candidate: str) -> str | None:- return continuation_suffix(self.emitted_thinking(), candidate)-- def iter_midstream_error_tail(- self,- error_message: str,- *,- request: Any,- input_tokens: int,- log_raw_sse_events: bool,- ) -> Iterator[str]:- """Close dangling blocks, emit a text error block at a fresh index, then message tail."""- mid = self.message_id or f"msg_{uuid.uuid4()}"- model = self.model or (getattr(request, "model", "") or "")- sse = SSEBuilder(- mid,- model,- input_tokens,- log_raw_events=log_raw_sse_events,- )- sse.blocks.next_index = self.next_content_index()- yield from sse.emit_error(error_message)- yield sse.message_delta("end_turn", 1)- yield sse.message_stop()-- def _last_open_block(self, block_type: str) -> EmittedBlockState | None:- for index in reversed(self._open_stack):- block = self._blocks.get(index)- if block is not None and block.block_type == block_type and block.open:- return block- return Nonediff --git a/core/anthropic/provider_stream_error.py b/core/anthropic/provider_stream_error.pyindex 5534c501..76f2f8b7 100644--- a/core/anthropic/provider_stream_error.py+++ b/core/anthropic/provider_stream_error.py@@ -6,7 +6,7 @@ import uuidfrom collections.abc import Iteratorfrom typing import Any-from core.anthropic.sse import SSEBuilder+from core.anthropic.streaming import AnthropicStreamLedgerdef iter_provider_stream_error_sse_events(@@ -21,14 +21,14 @@ def iter_provider_stream_error_sse_events("""Yield message_start (if needed), a text block with the error, then message_delta/stop."""mid = message_id or f"msg_{uuid.uuid4()}"model = getattr(request, "model", "") or ""- sse = SSEBuilder(+ ledger = AnthropicStreamLedger(mid,model,input_tokens,log_raw_events=log_raw_sse_events,)if not sent_any_event:- yield sse.message_start()- yield from sse.emit_error(error_message)- yield sse.message_delta("end_turn", 1)- yield sse.message_stop()+ yield ledger.message_start()+ yield from ledger.emit_error(error_message)+ yield ledger.message_delta("end_turn", 1)+ yield ledger.message_stop()diff --git a/core/anthropic/sse.py b/core/anthropic/sse.pydeleted file mode 100644index c543f5e0..00000000--- a/core/anthropic/sse.py+++ /dev/null@@ -1,440 +0,0 @@-"""SSE event builder for Anthropic-format streaming responses."""--import hashlib-import json-from collections.abc import Iterator-from dataclasses import dataclass, field-from typing import Any--from loguru import logger--try:- import tiktoken-- ENCODER = tiktoken.get_encoding("cl100k_base")-except Exception:- ENCODER = None---# Standard headers for Anthropic-style ``text/event-stream`` responses from this proxy.-ANTHROPIC_SSE_RESPONSE_HEADERS: dict[str, str] = {- "X-Accel-Buffering": "no",- "Cache-Control": "no-cache",- "Connection": "keep-alive",-}--STOP_REASON_MAP = {- "stop": "end_turn",- "length": "max_tokens",- "tool_calls": "tool_use",- "content_filter": "end_turn",-}---def map_stop_reason(openai_reason: str | None) -> str:- """Map OpenAI finish_reason to Anthropic stop_reason."""- return (- STOP_REASON_MAP.get(openai_reason, "end_turn") if openai_reason else "end_turn"- )---def _safe_usage_int(value: object) -> int:- """Coerce streamed usage counters to int; non-integers become 0."""- return value if isinstance(value, int) else 0---def format_sse_event(event_type: str, data: dict) -> str:- """Format one Anthropic-style SSE event (no logging)."""- return f"event: {event_type}\ndata: {json.dumps(data)}\n\n"---@dataclass-class ToolCallState:- """State for a single streaming tool call."""-- block_index: int- tool_id: str- name: str- extra_content: dict[str, Any] | None = None- contents: list[str] = field(default_factory=list)- started: bool = False- task_arg_buffer: str = ""- task_args_emitted: bool = False- pre_start_args: str = ""---@dataclass-class ContentBlockManager:- """Manage content block indices and state."""-- next_index: int = 0- thinking_index: int = -1- text_index: int = -1- thinking_started: bool = False- text_started: bool = False- tool_states: dict[int, ToolCallState] = field(default_factory=dict)-- def allocate_index(self) -> int:- idx = self.next_index- self.next_index += 1- return idx-- def ensure_tool_state(self, index: int) -> ToolCallState:- """Create tool stream state for ``index`` when the first tool delta arrives."""- if index not in self.tool_states:- self.tool_states[index] = ToolCallState(block_index=-1, tool_id="", name="")- return self.tool_states[index]-- def set_stream_tool_id(self, index: int, tool_id: str | None) -> None:- """Record OpenAI tool call id before ``content_block_start`` (split-stream providers)."""- if not tool_id:- return- state = self.ensure_tool_state(index)- state.tool_id = str(tool_id)-- def set_tool_extra_content(- self, index: int, extra_content: dict[str, Any] | None- ) -> None:- """Record provider-specific OpenAI tool-call metadata before block start."""- if not extra_content:- return- state = self.ensure_tool_state(index)- state.extra_content = extra_content-- def register_tool_name(self, index: int, name: str) -> None:- """Record tool name fragments as they arrive from chunked OpenAI streams.-- Names may be split across deltas; later chunks can extend (``ab`` + ``c``)- or repeat prefixes, so we merge conservatively.- """- if index not in self.tool_states:- self.tool_states[index] = ToolCallState(- 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 | 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-- _normalize_task_run_in_background(args_json)-- state.task_args_emitted = True- state.task_arg_buffer = ""- return args_json-- def has_emitted_tool_block(self) -> bool:- """True when native OpenAI tool streaming has started a ``tool_use`` block."""- return any(s.started for s in self.tool_states.values())-- 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)- _normalize_task_run_in_background(args_json)- out = json.dumps(args_json)- except (json.JSONDecodeError, TypeError, ValueError) as e:- 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,- e,- )-- state.task_args_emitted = True- state.task_arg_buffer = ""- results.append((tool_index, out))- return results---def _normalize_task_run_in_background(args_json: dict) -> None:- """Force Claude Code Task subagents to run in foreground (single shared rule)."""- if args_json.get("run_in_background") is not False:- args_json["run_in_background"] = False---class SSEBuilder:- """Builder for Anthropic SSE streaming events."""-- def __init__(- self,- message_id: str,- model: str,- input_tokens: int = 0,- *,- log_raw_events: bool = False,- ):- self.message_id = message_id- self.model = model- self.input_tokens = input_tokens- self._log_raw_events = log_raw_events- self.blocks = ContentBlockManager()- self._accumulated_text_parts: list[str] = []- self._accumulated_reasoning_parts: list[str] = []-- def _format_event(self, event_type: str, data: dict) -> str:- event_str = format_sse_event(event_type, data)- if self._log_raw_events:- logger.debug("SSE_EVENT: {} - {}", event_type, event_str.strip())- return event_str-- def message_start(self) -> str:- safe_input = _safe_usage_int(self.input_tokens)- usage = {"input_tokens": safe_input, "output_tokens": 1}- return self._format_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": usage,- },- },- )-- def message_delta(self, stop_reason: str, output_tokens: int | None) -> str:- safe_in = _safe_usage_int(self.input_tokens)- safe_out = output_tokens if isinstance(output_tokens, int) else 0- return self._format_event(- "message_delta",- {- "type": "message_delta",- "delta": {"stop_reason": stop_reason, "stop_sequence": None},- "usage": {- "input_tokens": safe_in,- "output_tokens": safe_out,- },- },- )-- def message_stop(self) -> str:- return self._format_event("message_stop", {"type": "message_stop"})-- def content_block_start(self, index: int, block_type: str, **kwargs) -> str:- content_block: dict = {"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-- return self._format_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 = {"type": delta_type}- if delta_type == "thinking_delta":- delta["thinking"] = content- elif delta_type == "text_delta":- delta["text"] = content- elif delta_type == "input_json_delta":- delta["partial_json"] = content-- return self._format_event(- "content_block_delta",- {- "type": "content_block_delta",- "index": index,- "delta": delta,- },- )-- def content_block_stop(self, index: int) -> str:- return self._format_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:- self._accumulated_reasoning_parts.append(content)- 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:- self._accumulated_text_parts.append(content)- 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- if extra_content:- state.extra_content = extra_content- state.started = True- else:- self.blocks.tool_states[tool_index] = ToolCallState(- 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]- state.contents.append(partial_json)- return self.content_block_delta(- state.block_index, "input_json_delta", partial_json- )-- def stop_tool_block(self, tool_index: int) -> str:- block_idx = self.blocks.tool_states[tool_index].block_index- return self.content_block_stop(block_idx)-- 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 emit_error(self, error_message: str) -> Iterator[str]:- error_index = self.blocks.allocate_index()- yield self.content_block_start(error_index, "text")- yield self.content_block_delta(error_index, "text_delta", error_message)- yield self.content_block_stop(error_index)-- def emit_top_level_error(self, error_message: str) -> str:- """Emit a top-level ``event: error`` (not assistant text) for transport failures."""- return self._format_event(- "error",- {- "type": "error",- "error": {- "type": "api_error",- "message": error_message,- },- },- )-- @property- def accumulated_text(self) -> str:- return "".join(self._accumulated_text_parts)-- @property- def accumulated_reasoning(self) -> str:- return "".join(self._accumulated_reasoning_parts)-- def estimate_output_tokens(self) -> int:- accumulated_text = self.accumulated_text- accumulated_reasoning = self.accumulated_reasoning- if ENCODER:- text_tokens = len(ENCODER.encode(accumulated_text))- reasoning_tokens = len(ENCODER.encode(accumulated_reasoning))- tool_tokens = 0- started_tool_count = 0- for state in self.blocks.tool_states.values():- tool_tokens += len(ENCODER.encode(state.name))- tool_tokens += len(ENCODER.encode("".join(state.contents)))- tool_tokens += 15- if state.started:- started_tool_count += 1-- block_count = (- (1 if accumulated_reasoning else 0)- + (1 if accumulated_text else 0)- + started_tool_count- )- return text_tokens + reasoning_tokens + tool_tokens + (block_count * 4)-- text_tokens = len(accumulated_text) // 4- reasoning_tokens = len(accumulated_reasoning) // 4- tool_tokens = (- sum(1 for state in self.blocks.tool_states.values() if state.started) * 50- )- return text_tokens + reasoning_tokens + tool_tokensdiff --git a/core/anthropic/stream_recovery_session.py b/core/anthropic/stream_recovery_session.pydeleted file mode 100644index 7cbf2dcc..00000000--- a/core/anthropic/stream_recovery_session.py+++ /dev/null@@ -1,133 +0,0 @@-"""Shared stream recovery policy for provider transports."""--from __future__ import annotations--from dataclasses import dataclass-from enum import StrEnum--from core.anthropic.stream_recovery import (- EARLY_TRANSPARENT_MAX_RETRIES,- EARLY_TRANSPARENT_TOTAL_ATTEMPTS,- RecoveryHoldbackBuffer,- is_retryable_stream_error,-)-from core.trace import trace_event---class StreamFailureAction(StrEnum):- """Transport action selected after a provider stream failure."""-- EARLY_RETRY = "early_retry"- MIDSTREAM_RECOVERY = "midstream_recovery"- FINAL_ERROR = "final_error"---@dataclass(frozen=True, slots=True)-class StreamFailureDecision:- """Failure-state snapshot for the current provider stream transition."""-- action: StreamFailureAction- retryable: bool- committed: bool- has_buffered: bool- early_retry_attempt: int | None = None---class StreamRecoverySession:- """Own holdback and retry policy shared by provider stream transports."""-- def __init__(self, *, provider_name: str, request_id: str | None) -> None:- self._provider_name = provider_name- self._request_id = request_id- self._holdback = RecoveryHoldbackBuffer()- self._early_retries = 0-- @property- def committed(self) -> bool:- return self._holdback.committed-- @property- def has_buffered(self) -> bool:- return self._holdback.has_buffered-- @property- def early_retries(self) -> int:- return self._early_retries-- def push(self, event: str) -> list[str]:- """Buffer one downstream event through the early retry holdback."""- return self._holdback.push(event)-- def flush(self) -> list[str]:- """Commit and return held events."""- return self._holdback.flush()-- def flush_uncommitted(self, decision: StreamFailureDecision) -> list[str]:- """Commit held events when the decision snapshot is still uncommitted."""- if decision.committed:- return []- return self.flush()-- def discard(self) -> None:- """Drop held events without committing them."""- self._holdback.discard()-- def advance_failure(- self,- error: BaseException,- *,- stream_opened: bool,- generated_output: bool,- complete_tool_salvageable: bool,- ) -> StreamFailureDecision:- """Consume a stream failure and apply shared recovery state changes."""- committed = self.committed- has_buffered = self.has_buffered- retryable = is_retryable_stream_error(error)-- if (- not committed- and stream_opened- and retryable- and not complete_tool_salvageable- and self._early_retries < EARLY_TRANSPARENT_MAX_RETRIES- ):- self._early_retries += 1- attempt = self._early_retries- self._reset_holdback()- trace_event(- stage="provider",- event="provider.recovery.early_retry",- source="provider",- provider=self._provider_name,- request_id=self._request_id,- attempt=attempt,- max_attempts=EARLY_TRANSPARENT_TOTAL_ATTEMPTS,- exc_type=type(error).__name__,- )- return StreamFailureDecision(- action=StreamFailureAction.EARLY_RETRY,- retryable=retryable,- committed=committed,- has_buffered=has_buffered,- early_retry_attempt=attempt,- )-- if generated_output and retryable:- return StreamFailureDecision(- action=StreamFailureAction.MIDSTREAM_RECOVERY,- retryable=retryable,- committed=committed,- has_buffered=has_buffered,- )-- return StreamFailureDecision(- action=StreamFailureAction.FINAL_ERROR,- retryable=retryable,- committed=committed,- has_buffered=has_buffered,- )-- def _reset_holdback(self) -> None:- self._holdback.discard()- self._holdback = RecoveryHoldbackBuffer()diff --git a/core/anthropic/streaming/__init__.py b/core/anthropic/streaming/__init__.pynew file mode 100644index 00000000..8584e710--- /dev/null+++ b/core/anthropic/streaming/__init__.py@@ -0,0 +1,53 @@+"""Shared Anthropic streaming engine."""++from .emitter import (+ ANTHROPIC_SSE_RESPONSE_HEADERS,+ AnthropicSseEmitter,+ format_sse_event,+ map_stop_reason,+)+from .ledger import AnthropicStreamLedger, StreamBlockLedger, ToolBlockState+from .recovery import (+ EARLY_TRANSPARENT_MAX_RETRIES,+ EARLY_TRANSPARENT_TOTAL_ATTEMPTS,+ MIDSTREAM_RECOVERY_ATTEMPTS,+ RECOVERY_BUFFER_MAX_BYTES,+ RecoveryController,+ RecoveryFailureAction,+ RecoveryHoldbackBuffer,+ ToolSchema,+ TruncatedProviderStreamError,+ accept_tool_json_repair,+ continuation_suffix,+ is_retryable_stream_error,+ make_text_recovery_body,+ make_tool_repair_body,+ parse_complete_tool_input,+ tool_schemas_by_name,+)++__all__ = [+ "ANTHROPIC_SSE_RESPONSE_HEADERS",+ "EARLY_TRANSPARENT_MAX_RETRIES",+ "EARLY_TRANSPARENT_TOTAL_ATTEMPTS",+ "MIDSTREAM_RECOVERY_ATTEMPTS",+ "RECOVERY_BUFFER_MAX_BYTES",+ "AnthropicSseEmitter",+ "AnthropicStreamLedger",+ "RecoveryController",+ "RecoveryFailureAction",+ "RecoveryHoldbackBuffer",+ "StreamBlockLedger",+ "ToolBlockState",+ "ToolSchema",+ "TruncatedProviderStreamError",+ "accept_tool_json_repair",+ "continuation_suffix",+ "format_sse_event",+ "is_retryable_stream_error",+ "make_text_recovery_body",+ "make_tool_repair_body",+ "map_stop_reason",+ "parse_complete_tool_input",+ "tool_schemas_by_name",+]diff --git a/core/anthropic/streaming/emitter.py b/core/anthropic/streaming/emitter.pynew file mode 100644index 00000000..de97e7ac--- /dev/null+++ b/core/anthropic/streaming/emitter.py@@ -0,0 +1,46 @@+"""Anthropic SSE serialization helpers."""++from __future__ import annotations++import json+from typing import Any++from loguru import logger++ANTHROPIC_SSE_RESPONSE_HEADERS: dict[str, str] = {+ "X-Accel-Buffering": "no",+ "Cache-Control": "no-cache",+ "Connection": "keep-alive",+}++STOP_REASON_MAP = {+ "stop": "end_turn",+ "length": "max_tokens",+ "tool_calls": "tool_use",+ "content_filter": "end_turn",+}+++def map_stop_reason(openai_reason: str | None) -> str:+ """Map OpenAI ``finish_reason`` values to Anthropic ``stop_reason`` values."""+ return (+ STOP_REASON_MAP.get(openai_reason, "end_turn") if openai_reason else "end_turn"+ )+++def format_sse_event(event_type: str, data: dict[str, Any]) -> str:+ """Format one Anthropic-style SSE event."""+ return f"event: {event_type}\ndata: {json.dumps(data)}\n\n"+++class AnthropicSseEmitter:+ """Serialize Anthropic SSE events and optionally log raw event bodies."""++ 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:+ event = format_sse_event(event_type, data)+ if self._log_raw_events:+ logger.debug("SSE_EVENT: {} - {}", event_type, event.strip())+ return eventdiff --git a/core/anthropic/streaming/ledger.py b/core/anthropic/streaming/ledger.pynew file mode 100644index 00000000..886487b9--- /dev/null+++ b/core/anthropic/streaming/ledger.py@@ -0,0 +1,680 @@+"""Anthropic stream state ledger."""++from __future__ import annotations++import hashlib+import json+import uuid+from collections.abc import Iterator+from contextlib import suppress+from dataclasses import dataclass, field+from typing import Any++from loguru import logger++from core.anthropic.stream_contracts import SSEEvent++from .emitter import AnthropicSseEmitter+from .recovery import (+ ToolSchema,+ accept_tool_json_repair,+ continuation_suffix,+ parse_complete_tool_input,+)++try:+ import tiktoken++ ENCODER = tiktoken.get_encoding("cl100k_base")+except Exception:+ ENCODER = None+++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) -> str:+ self.stop_reason = stop_reason+ safe_in = _safe_usage_int(self.input_tokens)+ safe_out = output_tokens if isinstance(output_tokens, int) else 0+ return self._emitter.event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": stop_reason, "stop_sequence": None},+ "usage": {"input_tokens": safe_in, "output_tokens": safe_out},+ },+ )++ 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 emit_error(self, error_message: str) -> Iterator[str]:+ error_index = self.blocks.allocate_index()+ yield self.content_block_start(error_index, "text")+ yield self.content_block_delta(error_index, "text_delta", error_message)+ yield self.content_block_stop(error_index)++ def emit_top_level_error(self, error_message: str) -> str:+ return self._emitter.event(+ "error",+ {+ "type": "error",+ "error": {"type": "api_error", "message": error_message},+ },+ )++ def ingest_native_event(self, event: SSEEvent) -> str | None:+ """Record a native Anthropic SSE event and re-emit its normalized shape."""+ if event.event == "message_start":+ message = event.data.get("message")+ if isinstance(message, dict):+ mid = message.get("id")+ if isinstance(mid, str) and mid:+ self.message_id = mid+ model = message.get("model")+ if isinstance(model, str) and model:+ self.model = model+ self.message_started = True+ return self._emitter.event(event.event, event.data)++ if event.event == "content_block_start":+ raw_index = event.data.get("index")+ block = event.data.get("content_block")+ if isinstance(raw_index, int) and isinstance(block, dict):+ self._record_block_start(raw_index, block)+ return self._emitter.event(event.event, event.data)++ if event.event == "content_block_delta":+ raw_index = event.data.get("index")+ delta = event.data.get("delta")+ if isinstance(raw_index, int) and isinstance(delta, dict):+ self._record_block_delta(raw_index, delta)+ return self._emitter.event(event.event, event.data)++ if event.event == "content_block_stop":+ raw_index = event.data.get("index")+ if isinstance(raw_index, int):+ self._record_block_stop(raw_index)+ return self._emitter.event(event.event, event.data)++ if event.event == "message_delta":+ delta = event.data.get("delta")+ if isinstance(delta, dict):+ stop_reason = delta.get("stop_reason")+ if isinstance(stop_reason, str):+ self.stop_reason = stop_reason+ return self._emitter.event(event.event, event.data)++ if event.event == "message_stop":+ self.message_stopped = True+ return self._emitter.event(event.event, event.data)++ if event.event == "error":+ return self._emitter.event(event.event, event.data)++ return self._emitter.event(event.event, event.data)++ 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 append_text_suffix(self, suffix: str) -> Iterator[str]:+ if not suffix or not self.can_append_content():+ return+ yield from self.ensure_text_block()+ active = self._last_open_block("text")+ if active is None:+ return+ yield self.content_block_delta(active.index, "text_delta", suffix)++ def append_thinking_suffix(self, suffix: str) -> Iterator[str]:+ if not suffix or not self.can_append_content():+ return+ yield from self.ensure_thinking_block()+ active = self._last_open_block("thinking")+ if active is None:+ return+ yield self.content_block_delta(active.index, "thinking_delta", suffix)++ def append_tool_repair_suffix(self, tool_index: int, suffix: str) -> Iterator[str]:+ tool_blocks = self.tool_blocks()+ if (+ tool_index >= len(tool_blocks)+ or not suffix+ or not self.can_append_content()+ ):+ return+ block = tool_blocks[tool_index]+ yield self.content_block_delta(block.index, "input_json_delta", suffix)++ def success_tail(self, stop_reason: str) -> Iterator[str]:+ yield from self.close_unclosed_blocks()+ if self.stop_reason is None:+ yield self.message_delta(+ self.final_stop_reason(stop_reason), self.estimate_output_tokens()+ )+ if not self.message_stopped:+ yield self.message_stop()++ def midstream_error_tail(self, error_message: str) -> Iterator[str]:+ yield from self.close_unclosed_blocks()+ if self.stop_reason is None and not self.message_stopped:+ yield from self.emit_error(error_message)+ yield self.message_delta("end_turn", 1)+ else:+ yield self.emit_top_level_error(error_message)+ if not self.message_stopped:+ yield self.message_stop()++ 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 accept_tool_repair(+ self, tool_index: int, candidate: str, schemas: dict[str, ToolSchema]+ ) -> str | None:+ tool_blocks = self.tool_blocks()+ if tool_index >= len(tool_blocks):+ return None+ block = tool_blocks[tool_index]+ repair = accept_tool_json_repair(+ block.content,+ candidate,+ tool_name=block.name,+ schemas=schemas,+ )+ return repair.suffix if repair is not None else None++ def continuation_text_suffix(self, candidate: str) -> str | None:+ return continuation_suffix(self.accumulated_text, candidate)++ def continuation_thinking_suffix(self, candidate: str) -> str | None:+ return continuation_suffix(self.accumulated_reasoning, candidate)++ 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 can_append_content(self) -> bool:+ return self.stop_reason is None and not self.message_stopped++ 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:+ if ENCODER:+ text_tokens = len(ENCODER.encode(self.accumulated_text))+ reasoning_tokens = len(ENCODER.encode(self.accumulated_reasoning))+ tool_tokens = 0+ tool_count = 0+ for name, content in self._iter_tool_token_payloads():+ tool_tokens += len(ENCODER.encode(name))+ tool_tokens += len(ENCODER.encode(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)++ text_tokens = len(self.accumulated_text) // 4+ reasoning_tokens = len(self.accumulated_reasoning) // 4+ tool_tokens = sum(1 for _ in self._iter_tool_token_payloads()) * 50+ return text_tokens + reasoning_tokens + tool_tokens++ 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/core/anthropic/streaming/lifecycle.py b/core/anthropic/streaming/lifecycle.pynew file mode 100644index 00000000..3d51a00c--- /dev/null+++ b/core/anthropic/streaming/lifecycle.py@@ -0,0 +1,13 @@+"""Shared stream lifecycle types."""++from .recovery import (+ RecoveryController,+ RecoveryDecision,+ RecoveryFailureAction,+)++__all__ = [+ "RecoveryController",+ "RecoveryDecision",+ "RecoveryFailureAction",+]diff --git a/core/anthropic/stream_recovery.py b/core/anthropic/streaming/recovery.pysimilarity index 65%rename from core/anthropic/stream_recovery.pyrename to core/anthropic/streaming/recovery.pyindex 54d7c088..debb7ce0 100644--- a/core/anthropic/stream_recovery.py+++ b/core/anthropic/streaming/recovery.py@@ -1,4 +1,4 @@-"""Always-on recovery helpers for truncated provider streams."""+"""Shared retry and recovery policy for Anthropic streams."""from __future__ import annotations@@ -7,6 +7,7 @@ import timefrom collections.abc import Callablefrom copy import deepcopyfrom dataclasses import dataclass+from enum import StrEnumfrom typing import Anyimport httpx@@ -14,6 +15,8 @@ import jsonschemaimport openaifrom loguru import logger+from core.trace import trace_event+EARLY_TRANSPARENT_TOTAL_ATTEMPTS = 5EARLY_TRANSPARENT_MAX_RETRIES = EARLY_TRANSPARENT_TOTAL_ATTEMPTS - 1MIDSTREAM_RECOVERY_ATTEMPTS = 5@@ -24,12 +27,35 @@ _RECOVERY_USER_PREFIX = ("The previous provider stream was interrupted. Continue the assistant response ""exactly where it stopped. Do not repeat text already written.")+_RECOVERY_THINKING_PREFIX = (+ "The assistant had already emitted this hidden thinking before the interruption:\n"+)class TruncatedProviderStreamError(RuntimeError):"""Raised internally when an upstream stream ends without a terminal marker."""+class RecoveryFailureAction(StrEnum):+ """How the stream lifecycle should respond to an upstream failure."""++ EARLY_RETRY = "early_retry"+ MIDSTREAM_RECOVERY = "midstream_recovery"+ FINAL_ERROR = "final_error"+++@dataclass(frozen=True, slots=True)+class RecoveryDecision:+ """Failure classification result for one stream exception."""++ action: RecoveryFailureAction+ retryable: bool+ committed: bool+ has_buffered: bool+ early_retry_attempt: int | None = None+ midstream_recovery_attempt: int | None = None++@dataclass(frozen=True, slots=True)class ToolSchema:"""Tool schema resolved from the original Anthropic request."""@@ -65,7 +91,6 @@ class RecoveryHoldbackBuffer:self.committed = Falsedef push(self, event: str) -> list[str]:- """Buffer ``event`` until holdback expires or cap is reached."""if self.committed:return [event]if self._started_at is None:@@ -80,7 +105,6 @@ class RecoveryHoldbackBuffer:return []def flush(self) -> list[str]:- """Commit and return all held events."""if self.committed:return []self.committed = True@@ -91,7 +115,6 @@ class RecoveryHoldbackBuffer:return eventsdef discard(self) -> None:- """Drop held events without committing them downstream."""self._events = []self._bytes = 0self._started_at = None@@ -101,6 +124,107 @@ class RecoveryHoldbackBuffer:return bool(self._events)+class RecoveryController:+ """Own holdback and failure classification for one provider stream lifecycle."""++ def __init__(self, *, provider_name: str, request_id: str | None) -> None:+ self._provider_name = provider_name+ self._request_id = request_id+ self._holdback = RecoveryHoldbackBuffer()+ self._early_retry_count = 0+ self._midstream_recovery_count = 0++ @property+ def committed(self) -> bool:+ return self._holdback.committed++ @property+ def has_buffered(self) -> bool:+ return self._holdback.has_buffered++ @property+ def early_retries(self) -> int:+ return self._early_retry_count++ @property+ def midstream_recoveries(self) -> int:+ return self._midstream_recovery_count++ def push(self, event: str) -> list[str]:+ return self._holdback.push(event)++ def flush(self) -> list[str]:+ return self._holdback.flush()++ def discard(self) -> None:+ self._holdback.discard()++ def flush_uncommitted(self, decision: RecoveryDecision) -> list[str]:+ if not decision.committed and decision.has_buffered:+ return self.flush()+ return []++ def advance_failure(+ self,+ error: BaseException,+ *,+ stream_opened: bool,+ generated_output: bool,+ complete_tool_salvageable: bool,+ ) -> RecoveryDecision:+ retryable = is_retryable_stream_error(error)+ committed = self._holdback.committed+ has_buffered = self._holdback.has_buffered++ if (+ retryable+ and stream_opened+ and not committed+ and not complete_tool_salvageable+ and self._early_retry_count < EARLY_TRANSPARENT_MAX_RETRIES+ ):+ self._early_retry_count += 1+ self._holdback.discard()+ self._holdback = RecoveryHoldbackBuffer()+ trace_event(+ stage="provider",+ event="provider.recovery.early_retry",+ source="provider",+ provider=self._provider_name,+ request_id=self._request_id,+ retry_attempt=self._early_retry_count,+ retryable=True,+ )+ return RecoveryDecision(+ action=RecoveryFailureAction.EARLY_RETRY,+ retryable=True,+ committed=False,+ has_buffered=has_buffered,+ early_retry_attempt=self._early_retry_count,+ )++ if (+ retryable+ and generated_output+ and self._midstream_recovery_count < MIDSTREAM_RECOVERY_ATTEMPTS+ ):+ self._midstream_recovery_count += 1+ return RecoveryDecision(+ action=RecoveryFailureAction.MIDSTREAM_RECOVERY,+ retryable=True,+ committed=committed,+ has_buffered=has_buffered,+ midstream_recovery_attempt=self._midstream_recovery_count,+ )++ return RecoveryDecision(+ action=RecoveryFailureAction.FINAL_ERROR,+ retryable=retryable,+ committed=committed,+ has_buffered=has_buffered,+ )++def is_retryable_stream_error(exc: BaseException) -> bool:"""Return whether a provider stream error can be retried/recovered."""if isinstance(exc, TruncatedProviderStreamError):@@ -151,7 +275,6 @@ def tool_schemas_by_name(request: Any) -> dict[str, ToolSchema]:def validate_tool_input(tool_name: str, parsed_input: dict[str, Any], schemas: dict[str, ToolSchema]) -> bool:- """Validate tool input against its JSON schema; unknown tools accept any object."""tool_schema = schemas.get(tool_name)if tool_schema is None:return True@@ -170,7 +293,6 @@ def validate_tool_input(def parse_complete_tool_input(raw_json: str, tool_name: str, schemas: dict[str, ToolSchema]) -> dict[str, Any] | None:- """Return parsed input when raw JSON is complete and schema-valid."""try:parsed = json.loads(raw_json)except json.JSONDecodeError:@@ -189,9 +311,7 @@ def accept_tool_json_repair(tool_name: str,schemas: dict[str, ToolSchema],) -> ToolRepair | None:- """Accept only append-only JSON repairs that make ``prefix`` valid."""- suffix_candidates = _repair_suffix_candidates(prefix, candidate)- for suffix in suffix_candidates:+ for suffix in _repair_suffix_candidates(prefix, candidate):combined = prefix + suffixparsed = parse_complete_tool_input(combined, tool_name, schemas)if parsed is not None:@@ -200,7 +320,6 @@ def accept_tool_json_repair(def continuation_suffix(existing: str, candidate: str) -> str | None:- """Return only the new suffix from a text/thinking continuation candidate."""existing = existing or ""candidate = candidate or ""if not candidate:@@ -215,77 +334,40 @@ def continuation_suffix(existing: str, candidate: str) -> str | None:if existing.endswith(candidate[:size]):return candidate[size:]- # Accept short standalone continuations, but reject full unrelated rewrites.if len(candidate) < max(200, len(existing) // 2):return candidatereturn None-def make_openai_text_recovery_body(- body: dict[str, Any], partial: str-) -> dict[str, Any]:- """Build a text-only OpenAI-chat continuation request."""- recovery = deepcopy(body)- recovery.pop("tools", None)- recovery.pop("tool_choice", None)- recovery["stream"] = True- messages = _copied_messages(recovery)- if partial:- messages.append({"role": "assistant", "content": partial})- messages.append({"role": "user", "content": _RECOVERY_USER_PREFIX})- recovery["messages"] = messages- return recovery---def make_openai_tool_repair_body(+def make_text_recovery_body(body: dict[str, Any],- *,- tool_name: str,- prefix: str,- input_schema: dict[str, Any] | None,-) -> dict[str, Any]:- """Build a text-only OpenAI-chat request asking for a JSON suffix."""- recovery = deepcopy(body)- recovery.pop("tools", None)- recovery.pop("tool_choice", None)- recovery["stream"] = True- messages = _copied_messages(recovery)- messages.append(- {- "role": "user",- "content": _tool_repair_prompt(- tool_name=tool_name, prefix=prefix, input_schema=input_schema- ),- }- )- recovery["messages"] = messages- return recovery---def make_native_text_recovery_body(- body: dict[str, Any], partial: str+ partial_text: str,+ partial_thinking: str = "",) -> dict[str, Any]:- """Build a text-only native Anthropic continuation request."""+ """Build a text-only continuation request for either transport family."""recovery = deepcopy(body)recovery.pop("tools", None)recovery.pop("tool_choice", None)recovery["stream"] = Truemessages = _copied_messages(recovery)- if partial:- messages.append({"role": "assistant", "content": partial})- messages.append({"role": "user", "content": _RECOVERY_USER_PREFIX})+ if partial_text:+ messages.append({"role": "assistant", "content": partial_text})+ prompt = _RECOVERY_USER_PREFIX+ if partial_thinking:+ prompt = f"{_RECOVERY_THINKING_PREFIX}{partial_thinking}\n\n{prompt}"+ messages.append({"role": "user", "content": prompt})recovery["messages"] = messagesreturn recovery-def make_native_tool_repair_body(+def make_tool_repair_body(body: dict[str, Any],*,tool_name: str,prefix: str,input_schema: dict[str, Any] | None,) -> dict[str, Any]:- """Build a text-only native Anthropic request asking for a JSON suffix."""+ """Build a text-only request asking for a JSON suffix."""recovery = deepcopy(body)recovery.pop("tools", None)recovery.pop("tool_choice", None)diff --git a/providers/transports/anthropic_messages/http.py b/providers/transports/anthropic_messages/http.pyindex c1a5515d..c4571d38 100644--- a/providers/transports/anthropic_messages/http.py+++ b/providers/transports/anthropic_messages/http.py@@ -2,7 +2,6 @@from __future__ import annotations-import inspectfrom typing import Anyimport httpx@@ -16,16 +15,6 @@ from providers.error_mapping import attach_provider_error_bodyfrom providers.exceptions import ModelListResponseError-async def maybe_await_aclose(response: Any) -> None:- """Call ``aclose`` on httpx-like responses; ignore sync test doubles."""- close = getattr(response, "aclose", None)- if not callable(close):- return- result = close()- if inspect.isawaitable(result):- await result--def model_list_json(response: httpx.Response, *, provider_name: str) -> Any:"""Parse model-list JSON with a provider-specific malformed-body error."""response.raise_for_status()diff --git a/providers/transports/anthropic_messages/recovery.py b/providers/transports/anthropic_messages/recovery.pyindex 610ee1a2..1e2a139a 100644--- a/providers/transports/anthropic_messages/recovery.py+++ b/providers/transports/anthropic_messages/recovery.py@@ -7,21 +7,21 @@ from typing import Anyimport httpx-from core.anthropic.emitted_sse_tracker import EmittedNativeSseTrackerfrom core.anthropic.stream_contracts import parse_sse_text-from core.anthropic.stream_recovery import (+from core.anthropic.streaming import (MIDSTREAM_RECOVERY_ATTEMPTS,+ AnthropicStreamLedger,+ TruncatedProviderStreamError,accept_tool_json_repair,continuation_suffix,is_retryable_stream_error,- make_native_text_recovery_body,- make_native_tool_repair_body,+ make_text_recovery_body,+ make_tool_repair_body,parse_complete_tool_input,tool_schemas_by_name,)from core.trace import trace_event--from .http import maybe_await_aclose+from providers.transports.http import maybe_await_acloseIterStreamChunks = Callable[..., AsyncIterator[str]]@@ -68,7 +68,18 @@ class AnthropicMessagesRecovery:]text_parts: list[str] = []thinking_parts: list[str] = []+ terminal_seen = Falsefor event in parse_sse_text("".join(chunks)):+ if event.event == "message_stop":+ terminal_seen = True+ content_block = event.data.get("content_block")+ if isinstance(content_block, dict):+ text = content_block.get("text")+ if isinstance(text, str):+ text_parts.append(text)+ thinking = content_block.get("thinking")+ if isinstance(thinking, str):+ thinking_parts.append(thinking)delta = event.data.get("delta")if not isinstance(delta, dict):continue@@ -78,6 +89,10 @@ class AnthropicMessagesRecovery:thinking = delta.get("thinking")if isinstance(thinking, str):thinking_parts.append(thinking)+ if not terminal_seen:+ raise TruncatedProviderStreamError(+ "Recovery stream ended without message_stop."+ )return "".join(text_parts), "".join(thinking_parts)except Exception as error:last_error = error@@ -105,7 +120,7 @@ class AnthropicMessagesRecovery:*,body: dict[str, Any],request: Any,- tracker: EmittedNativeSseTracker,+ ledger: AnthropicStreamLedger,error: Exception,request_id: str | None,req_tag: str,@@ -116,9 +131,9 @@ class AnthropicMessagesRecovery:return Noneschemas = tool_schemas_by_name(request)- if tracker.has_tool_block():+ if ledger.tool_blocks():repair_events: list[str] = []- for index, block in enumerate(tracker.tool_blocks()):+ for index, block in enumerate(ledger.tool_blocks()):if (block.tool_idand block.name@@ -127,7 +142,7 @@ class AnthropicMessagesRecovery:):continueschema = schemas.get(block.name)- recovery_body = make_native_tool_repair_body(+ recovery_body = make_tool_repair_body(body,tool_name=block.name,prefix=block.content,@@ -160,13 +175,13 @@ class AnthropicMessagesRecovery:if accepted_suffix is None:return Nonerepair_events.extend(- tracker.append_tool_repair_suffix(index, accepted_suffix)+ ledger.append_tool_repair_suffix(index, accepted_suffix))- if not tracker.can_salvage_tool_use(schemas):+ if not ledger.can_salvage_tool_use(schemas):return Noneevents = list(repair_events)- events.extend(tracker.iter_success_tail("tool_use"))+ events.extend(ledger.success_tail("end_turn"))trace_event(stage="provider",event="provider.recovery.tool_salvaged",@@ -176,11 +191,13 @@ class AnthropicMessagesRecovery:)return events- partial_text = tracker.emitted_text()- partial_thinking = tracker.emitted_thinking()+ partial_text = ledger.accumulated_text+ partial_thinking = ledger.accumulated_reasoningif not partial_text and not partial_thinking:return None- recovery_body = make_native_text_recovery_body(body, partial_text)+ if not ledger.can_append_content():+ return None+ recovery_body = make_text_recovery_body(body, partial_text, partial_thinking)text, thinking = await self.collect_text(recovery_body,req_tag=req_tag,@@ -190,12 +207,12 @@ class AnthropicMessagesRecovery:thinking_suffix = continuation_suffix(partial_thinking, thinking)events: list[str] = []if thinking_suffix:- events.extend(tracker.append_thinking_suffix(thinking_suffix))+ events.extend(ledger.append_thinking_suffix(thinking_suffix))if text_suffix:- events.extend(tracker.append_text_suffix(text_suffix))+ events.extend(ledger.append_text_suffix(text_suffix))if not events:return None- events.extend(tracker.iter_success_tail("end_turn"))+ events.extend(ledger.success_tail("end_turn"))trace_event(stage="provider",event="provider.recovery.continued",diff --git a/providers/transports/anthropic_messages/stream.py b/providers/transports/anthropic_messages/stream.pyindex 8ee98168..7f14f8d8 100644--- a/providers/transports/anthropic_messages/stream.py+++ b/providers/transports/anthropic_messages/stream.py@@ -1,4 +1,4 @@-"""Per-request native Anthropic Messages stream runner."""+"""Native Anthropic Messages upstream adapter."""from __future__ import annotations@@ -7,31 +7,20 @@ from typing import Anyimport httpx-from core.anthropic.emitted_sse_tracker import EmittedNativeSseTracker-from core.anthropic.native_sse_block_policy import NativeSseBlockPolicyState-from core.anthropic.stream_recovery import (+from core.anthropic.stream_contracts import parse_sse_text+from core.anthropic.streaming import (+ AnthropicStreamLedger,+ RecoveryController,+ RecoveryFailureAction,TruncatedProviderStreamError,tool_schemas_by_name,)-from core.anthropic.stream_recovery_session import (- StreamFailureAction,- StreamRecoverySession,-)from core.trace import provider_native_messages_body_snapshot, trace_event+from providers.transports.http import maybe_await_aclose-from .http import maybe_await_aclosefrom .recovery import AnthropicMessagesRecovery-async def iter_sse_lines(response: httpx.Response) -> AsyncIterator[str]:- """Yield raw SSE line chunks preserving local provider behavior."""- async for line in response.aiter_lines():- if line:- yield f"{line}\n"- else:- yield "\n"--async def iter_sse_events(response: httpx.Response) -> AsyncIterator[str]:"""Group line-delimited SSE responses into full SSE events."""event_lines: list[str] = []@@ -46,8 +35,8 @@ async def iter_sse_events(response: httpx.Response) -> AsyncIterator[str]:yield "\n".join(event_lines) + "\n\n"-class AnthropicMessagesStreamRunner:- """Own mutable state for one native Anthropic provider stream."""+class AnthropicMessagesStreamAdapter:+ """Convert one native Anthropic upstream stream into normalized Anthropic SSE."""def __init__(self,@@ -96,11 +85,8 @@ class AnthropicMessagesStreamRunner:state = self._transport._new_stream_state(self._request, thinking_enabled=thinking_enabled)- emitted_tracker = EmittedNativeSseTracker()- recovery_session = StreamRecoverySession(- provider_name=tag,- request_id=self._request_id,- )+ ledger = self._new_ledger()+ recovery = RecoveryController(provider_name=tag, request_id=self._request_id)async with self._transport._global_rate_limiter.concurrency_slot():while True:@@ -114,7 +100,6 @@ class AnthropicMessagesStreamRunner:))stream_opened = True-chunk_count = 0chunk_bytes = 0@@ -125,12 +110,15 @@ class AnthropicMessagesStreamRunner:):chunk_count += 1chunk_bytes += len(chunk.encode("utf-8", errors="replace"))- emitted_tracker.feed(chunk)- for event in recovery_session.push(chunk):- sent_any_event = True- yield event+ for parsed in parse_sse_text(chunk):+ emitted = ledger.ingest_native_event(parsed)+ if emitted is None:+ continue+ for event in recovery.push(emitted):+ sent_any_event = True+ yield event- if not emitted_tracker.has_terminal_message():+ if not ledger.has_terminal_message():raise TruncatedProviderStreamError("Provider stream ended without message_stop.")@@ -144,42 +132,39 @@ class AnthropicMessagesStreamRunner:sse_chunks_out=chunk_count,sse_bytes_out=chunk_bytes,)- for event in recovery_session.flush():+ for event in recovery.flush():sent_any_event = Trueyield eventreturnexcept Exception as error:- generated_output = emitted_tracker.has_content_block()- complete_tool_salvageable = (- generated_output- and emitted_tracker.can_salvage_tool_use(- tool_schemas_by_name(self._request)- )+ generated_output = ledger.has_content_block()+ complete_tool_salvageable = generated_output and (+ ledger.can_salvage_tool_use(tool_schemas_by_name(self._request)))- decision = recovery_session.advance_failure(+ decision = recovery.advance_failure(error,stream_opened=stream_opened,generated_output=generated_output,complete_tool_salvageable=complete_tool_salvageable,)- if decision.action == StreamFailureAction.EARLY_RETRY:+ if decision.action == RecoveryFailureAction.EARLY_RETRY:if response is not None and not response.is_closed:await maybe_await_aclose(response)response = Nonestate = self._transport._new_stream_state(self._request, thinking_enabled=thinking_enabled)- emitted_tracker = EmittedNativeSseTracker()+ ledger = self._new_ledger()sent_any_event = Falsecontinue- if decision.action == StreamFailureAction.MIDSTREAM_RECOVERY:+ if decision.action == RecoveryFailureAction.MIDSTREAM_RECOVERY:try:recovery_events = await self._recovery.events(body=body,request=self._request,- tracker=emitted_tracker,+ ledger=ledger,error=error,request_id=self._request_id,req_tag=req_tag,@@ -196,7 +181,7 @@ class AnthropicMessagesStreamRunner:)recovery_events = Noneif recovery_events is not None:- for event in recovery_session.flush_uncommitted(decision):+ for event in recovery.flush_uncommitted(decision):sent_any_event = Trueyield eventfor event in recovery_events:@@ -229,22 +214,13 @@ class AnthropicMessagesStreamRunner:)if decision.committed or decision.has_buffered:if not decision.committed:- for event in recovery_session.flush():+ for event in recovery.flush():sent_any_event = Trueyield event- for event in emitted_tracker.iter_close_unclosed_blocks():- yield event- for event in emitted_tracker.iter_midstream_error_tail(- error_message,- request=self._request,- input_tokens=self._input_tokens,- log_raw_sse_events=(- self._transport._config.log_raw_sse_events- ),- ):+ for event in ledger.midstream_error_tail(error_message):yield eventelse:- recovery_session.discard()+ recovery.discard()for event in self._transport._emit_error_events(request=self._request,input_tokens=self._input_tokens,@@ -264,27 +240,7 @@ class AnthropicMessagesStreamRunner:state: Any,thinking_enabled: bool,) -> AsyncIterator[str]:- """Yield chunks according to the provider's observable stream shape."""- if self._transport.stream_chunk_mode == "line" and isinstance(- state, NativeSseBlockPolicyState- ):- async for event in iter_sse_events(response):- output_event = self._transport._transform_stream_event(- event,- state,- thinking_enabled=thinking_enabled,- )- if output_event is None:- continue- for line in output_event.splitlines(keepends=True):- yield line- return-- if self._transport.stream_chunk_mode == "line":- async for chunk in iter_sse_lines(response):- yield chunk- return-+ """Yield normalized grouped SSE events from the provider stream."""async for event in iter_sse_events(response):output_event = self._transport._transform_stream_event(event,@@ -293,3 +249,11 @@ class AnthropicMessagesStreamRunner:)if output_event is not None:yield output_event++ def _new_ledger(self) -> AnthropicStreamLedger:+ return AnthropicStreamLedger(+ None,+ self._request.model,+ self._input_tokens,+ log_raw_events=self._transport._config.log_raw_sse_events,+ )diff --git a/providers/transports/anthropic_messages/transport.py b/providers/transports/anthropic_messages/transport.pyindex b1ebb1a7..149b5324 100644--- a/providers/transports/anthropic_messages/transport.py+++ b/providers/transports/anthropic_messages/transport.py@@ -28,9 +28,10 @@ from providers.model_listing import (model_infos_from_ids,)from providers.rate_limit import GlobalRateLimiter+from providers.transports.http import maybe_await_aclose-from .http import maybe_await_aclose, model_list_json, raise_for_status_with_body-from .stream import AnthropicMessagesStreamRunner+from .http import model_list_json, raise_for_status_with_body+from .stream import AnthropicMessagesStreamAdapterStreamChunkMode = Literal["line", "event"]@@ -225,12 +226,12 @@ class AnthropicMessagesTransport(BaseProvider):thinking_enabled: bool | None = None,) -> AsyncIterator[str]:"""Stream response via a native Anthropic-compatible messages endpoint."""- runner = AnthropicMessagesStreamRunner(+ adapter = AnthropicMessagesStreamAdapter(self,request=request,input_tokens=input_tokens,request_id=request_id,thinking_enabled=thinking_enabled,)- async for event in runner.run():+ async for event in adapter.run():yield eventdiff --git a/providers/transports/http.py b/providers/transports/http.pynew file mode 100644index 00000000..0a59586d--- /dev/null+++ b/providers/transports/http.py@@ -0,0 +1,16 @@+"""Shared HTTP helpers for provider transports."""++from __future__ import annotations++import inspect+from typing import Any+++async def maybe_await_aclose(response: Any) -> None:+ """Call ``aclose`` on httpx-like responses; ignore sync test doubles."""+ close = getattr(response, "aclose", None)+ if not callable(close):+ return+ result = close()+ if inspect.isawaitable(result):+ await resultdiff --git a/providers/transports/openai_chat/recovery.py b/providers/transports/openai_chat/recovery.pyindex 8f7ec47b..90987277 100644--- a/providers/transports/openai_chat/recovery.py+++ b/providers/transports/openai_chat/recovery.py@@ -5,20 +5,22 @@ from __future__ import annotationsfrom collections.abc import Awaitable, Callable, Iteratorfrom typing import Any-from core.anthropic import SSEBuilder-from core.anthropic.stream_recovery import (+from core.anthropic.streaming import (MIDSTREAM_RECOVERY_ATTEMPTS,+ AnthropicStreamLedger,+ TruncatedProviderStreamError,accept_tool_json_repair,continuation_suffix,is_retryable_stream_error,- make_openai_text_recovery_body,- make_openai_tool_repair_body,+ make_text_recovery_body,+ make_tool_repair_body,parse_complete_tool_input,tool_schemas_by_name,)from core.trace import trace_event+from providers.transports.http import maybe_await_aclose-from .tool_calls import all_started_tools_complete, started_tool_states+from .tool_calls import all_emitted_tools_complete, started_tool_statesCreateStream = Callable[[dict[str, Any]], Awaitable[tuple[Any, dict[str, Any]]]]@@ -34,14 +36,18 @@ class OpenAIChatRecovery:"""Collect text/reasoning from an internal recovery request."""last_error: Exception | None = Nonefor attempt in range(MIDSTREAM_RECOVERY_ATTEMPTS):+ stream: Any | None = Nonetry:stream, _ = await self._create_stream(body)text_parts: list[str] = []thinking_parts: list[str] = []+ terminal_seen = Falseasync for chunk in stream:if not getattr(chunk, "choices", None):continuechoice = chunk.choices[0]+ if choice.finish_reason is not None:+ terminal_seen = Truedelta = choice.deltaif delta is None:continue@@ -51,6 +57,10 @@ class OpenAIChatRecovery:content = getattr(delta, "content", None)if isinstance(content, str) and content:text_parts.append(content)+ if not terminal_seen:+ raise TruncatedProviderStreamError(+ "Recovery stream ended without finish_reason."+ )return "".join(text_parts), "".join(thinking_parts)except Exception as error:last_error = error@@ -66,6 +76,9 @@ class OpenAIChatRecovery:max_attempts=MIDSTREAM_RECOVERY_ATTEMPTS,exc_type=type(error).__name__,)+ finally:+ if stream is not None:+ await maybe_await_aclose(stream)if last_error is not None:raise last_errorreturn "", ""@@ -74,7 +87,7 @@ class OpenAIChatRecovery:self,*,body: dict[str, Any],- sse: SSEBuilder,+ ledger: AnthropicStreamLedger,request: Any,request_id: str | None,error: Exception,@@ -84,11 +97,11 @@ class OpenAIChatRecovery:if not is_retryable_stream_error(error):return None- if sse.blocks.has_emitted_tool_block():- if not all_started_tools_complete(sse, request):+ if ledger.has_emitted_tool_block():+ if not all_emitted_tools_complete(ledger, request):repair_events = await self._repair_tool_args(body=body,- sse=sse,+ ledger=ledger,request=request,tool_argument_alias_buffers=tool_argument_alias_buffers,)@@ -97,9 +110,14 @@ class OpenAIChatRecovery:else:repair_events = []events = list(repair_events)- events.extend(sse.close_all_blocks())- events.append(sse.message_delta("tool_use", sse.estimate_output_tokens()))- events.append(sse.message_stop())+ events.extend(ledger.close_all_blocks())+ events.append(+ ledger.message_delta(+ ledger.final_stop_reason("end_turn"),+ ledger.estimate_output_tokens(),+ )+ )+ events.append(ledger.message_stop())trace_event(stage="provider",event="provider.recovery.tool_salvaged",@@ -109,29 +127,33 @@ class OpenAIChatRecovery:)return events- partial_text = sse.accumulated_text- partial_thinking = sse.accumulated_reasoning+ partial_text = ledger.accumulated_text+ partial_thinking = ledger.accumulated_reasoningif not partial_text and not partial_thinking:return None- recovery_body = make_openai_text_recovery_body(body, partial_text)+ recovery_body = make_text_recovery_body(body, partial_text, partial_thinking)text, thinking = await self.collect_text(recovery_body)text_suffix = continuation_suffix(partial_text, text)thinking_suffix = continuation_suffix(partial_thinking, thinking)events: list[str] = []if thinking_suffix:- for event in sse.ensure_thinking_block():+ for event in ledger.ensure_thinking_block():events.append(event)- events.append(sse.emit_thinking_delta(thinking_suffix))+ events.append(ledger.emit_thinking_delta(thinking_suffix))if text_suffix:- for event in sse.ensure_text_block():+ for event in ledger.ensure_text_block():events.append(event)- events.append(sse.emit_text_delta(text_suffix))+ events.append(ledger.emit_text_delta(text_suffix))if not events:return None- events.extend(sse.close_all_blocks())- events.append(sse.message_delta("end_turn", sse.estimate_output_tokens()))- events.append(sse.message_stop())+ events.extend(ledger.close_all_blocks())+ events.append(+ ledger.message_delta(+ ledger.final_stop_reason("end_turn"), ledger.estimate_output_tokens()+ )+ )+ events.append(ledger.message_stop())trace_event(stage="provider",event="provider.recovery.continued",@@ -141,28 +163,31 @@ class OpenAIChatRecovery:)return events- def emit_error_tail(self, sse: SSEBuilder, error_message: str) -> Iterator[str]:+ def emit_error_tail(+ self, ledger: AnthropicStreamLedger, error_message: str+ ) -> Iterator[str]:"""Emit the canonical OpenAI-chat final error tail."""- yield from sse.close_all_blocks()- if sse.blocks.has_emitted_tool_block():- yield sse.emit_top_level_error(error_message)+ yield from ledger.close_all_blocks()+ if ledger.has_emitted_tool_block():+ yield ledger.emit_top_level_error(error_message)else:- yield from sse.emit_error(error_message)- yield sse.message_delta("end_turn", 1)- yield sse.message_stop()+ yield from ledger.emit_error(error_message)+ yield ledger.message_delta("end_turn", 1)+ yield ledger.message_stop()async def _repair_tool_args(self,*,body: dict[str, Any],- sse: SSEBuilder,+ ledger: AnthropicStreamLedger,request: Any,tool_argument_alias_buffers: dict[int, str],) -> list[str] | None:schemas = tool_schemas_by_name(request)events: list[str] = []- for tool_index, state in started_tool_states(sse):- emitted_prefix = "".join(state.contents)+ 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 ""repair_prefix = emitted_prefixif not repair_prefix and state.name == "Task" and state.task_arg_buffer:repair_prefix = state.task_arg_buffer@@ -175,11 +200,11 @@ class OpenAIChatRecovery:if not emitted_prefix:yield_text = repair_prefixif yield_text:- events.append(sse.emit_tool_delta(tool_index, yield_text))+ events.append(ledger.emit_tool_delta(tool_index, yield_text))continueschema = schemas.get(state.name)- recovery_body = make_openai_tool_repair_body(+ recovery_body = make_tool_repair_body(body,tool_name=state.name,prefix=repair_prefix,@@ -211,7 +236,7 @@ class OpenAIChatRecovery:accepted_suffix if emitted_prefix else repair_prefix + accepted_suffix)if to_emit:- events.append(sse.emit_tool_delta(tool_index, to_emit))- if not all_started_tools_complete(sse, request):+ events.append(ledger.emit_tool_delta(tool_index, to_emit))+ if not all_emitted_tools_complete(ledger, request):return Nonereturn eventsdiff --git a/providers/transports/openai_chat/stream.py b/providers/transports/openai_chat/stream.pyindex a07649f7..cd9ca49b 100644--- a/providers/transports/openai_chat/stream.py+++ b/providers/transports/openai_chat/stream.py@@ -1,4 +1,4 @@-"""Per-request OpenAI-chat stream runner."""+"""OpenAI-chat upstream adapter."""from __future__ import annotations@@ -12,30 +12,31 @@ from loguru import loggerfrom core.anthropic import (ContentType,HeuristicToolParser,- SSEBuilder,ThinkTagParser,- map_stop_reason,)-from core.anthropic.stream_recovery import TruncatedProviderStreamError-from core.anthropic.stream_recovery_session import (- StreamFailureAction,- StreamRecoverySession,+from core.anthropic.streaming import (+ AnthropicStreamLedger,+ RecoveryController,+ RecoveryFailureAction,+ TruncatedProviderStreamError,+ map_stop_reason,)from core.trace import provider_chat_body_snapshot, trace_eventfrom providers.error_mapping import map_error+from providers.transports.http import maybe_await_aclosefrom .recovery import OpenAIChatRecoveryfrom .tool_calls import (OpenAIToolCallAssembler,- all_started_tools_complete,+ all_emitted_tools_complete,has_committed_sse_output,iter_heuristic_tool_use_sse,tool_call_extra_content,)-class OpenAIChatStreamRunner:- """Own mutable state for one OpenAI-chat provider stream."""+class OpenAIChatStreamAdapter:+ """Convert one OpenAI-chat upstream stream into Anthropic SSE."""def __init__(self,@@ -64,14 +65,14 @@ class OpenAIChatStreamRunner:"""Stream response in Anthropic SSE format."""tag = self._transport._provider_namereq_tag = f" request_id={self._request_id}" if self._request_id else ""- sse = self._new_sse_builder()- recovery_session = StreamRecoverySession(+ ledger = self._new_ledger()+ recovery = RecoveryController(provider_name=tag,request_id=self._request_id,)def hold_event(event: str) -> Iterator[str]:- yield from recovery_session.push(event)+ yield from recovery.push(event)def hold_events(events: Iterator[str]) -> Iterator[str]:for event in events:@@ -95,8 +96,6 @@ class OpenAIChatStreamRunner:body=provider_chat_body_snapshot(body),)- yield sse.message_start()-think_parser = ThinkTagParser()heuristic_parser = HeuristicToolParser()finish_reason = None@@ -106,6 +105,10 @@ class OpenAIChatStreamRunner:async with self._transport._global_rate_limiter.concurrency_slot():while True:+ if not ledger.message_started:+ for event in hold_event(ledger.message_start()):+ yield event+ stream: Any | None = Nonestream_opened = Falsetry:stream, body = await self._transport._create_stream(body)@@ -129,14 +132,16 @@ class OpenAIChatStreamRunner:reasoning = getattr(delta, "reasoning_content", None)if thinking_enabled and reasoning:- for event in hold_events(sse.ensure_thinking_block()):+ for event in hold_events(ledger.ensure_thinking_block()):yield event- for event in hold_event(sse.emit_thinking_delta(reasoning)):+ for event in hold_event(+ ledger.emit_thinking_delta(reasoning)+ ):yield eventfor event in self._transport._handle_extra_reasoning(delta,- sse,+ ledger,thinking_enabled=thinking_enabled,):for out_event in hold_event(event):@@ -148,11 +153,11 @@ class OpenAIChatStreamRunner:if not thinking_enabled:continuefor event in hold_events(- sse.ensure_thinking_block()+ ledger.ensure_thinking_block()):yield eventfor event in hold_event(- sse.emit_thinking_delta(part.content)+ ledger.emit_thinking_delta(part.content)):yield eventelse:@@ -163,23 +168,23 @@ class OpenAIChatStreamRunner:if filtered_text:for event in hold_events(- sse.ensure_text_block()+ ledger.ensure_text_block()):yield eventfor event in hold_event(- sse.emit_text_delta(filtered_text)+ ledger.emit_text_delta(filtered_text)):yield eventfor tool_use in detected_tools:for event in iter_heuristic_tool_use_sse(- sse, tool_use+ ledger, tool_use):for out_event in hold_event(event):yield out_eventif delta.tool_calls:- for event in hold_events(sse.close_content_blocks()):+ for event in hold_events(ledger.close_content_blocks()):yield eventfor tc in delta.tool_calls:extra_content = tool_call_extra_content(tc)@@ -195,7 +200,7 @@ class OpenAIChatStreamRunner:tc_info["extra_content"] = extra_contentfor event in self._tool_calls.process_tool_call(tc_info,- sse,+ ledger,tool_argument_aliases=tool_argument_aliases,tool_argument_alias_buffers=tool_argument_alias_buffers,):@@ -211,20 +216,20 @@ class OpenAIChatStreamRunner:except asyncio.CancelledError, GeneratorExit:raiseexcept Exception as error:- generated_output = has_committed_sse_output(sse)+ generated_output = has_committed_sse_output(ledger)complete_tool_salvageable = (generated_output- and sse.blocks.has_emitted_tool_block()- and all_started_tools_complete(sse, self._request)+ and ledger.has_emitted_tool_block()+ and all_emitted_tools_complete(ledger, self._request))- decision = recovery_session.advance_failure(+ decision = recovery.advance_failure(error,stream_opened=stream_opened,generated_output=generated_output,complete_tool_salvageable=complete_tool_salvageable,)- if decision.action == StreamFailureAction.EARLY_RETRY:- sse = self._new_sse_builder()+ if decision.action == RecoveryFailureAction.EARLY_RETRY:+ ledger = self._new_ledger()think_parser = ThinkTagParser()heuristic_parser = HeuristicToolParser()finish_reason = None@@ -233,11 +238,11 @@ class OpenAIChatStreamRunner:tool_argument_alias_buffers = {}continue- if decision.action == StreamFailureAction.MIDSTREAM_RECOVERY:+ if decision.action == RecoveryFailureAction.MIDSTREAM_RECOVERY:try:recovery_events = await self._recovery.events(body=body,- sse=sse,+ ledger=ledger,request=self._request,request_id=self._request_id,error=error,@@ -254,7 +259,7 @@ class OpenAIChatStreamRunner:)recovery_events = Noneif recovery_events is not None:- for event in recovery_session.flush_uncommitted(decision):+ for event in recovery.flush_uncommitted(decision):yield eventfor event in recovery_events:yield event@@ -280,14 +285,17 @@ class OpenAIChatStreamRunner:).__name__,)if not decision.committed and decision.has_buffered:- for event in recovery_session.flush():+ for event in recovery.flush():yield eventelif not decision.committed:- recovery_session.discard()- sse = self._new_sse_builder()- for event in self._recovery.emit_error_tail(sse, error_message):+ recovery.discard()+ ledger = self._new_ledger()+ for event in self._recovery.emit_error_tail(ledger, error_message):yield eventreturn+ finally:+ if stream is not None:+ await maybe_await_aclose(stream)remaining = think_parser.flush()if remaining:@@ -295,48 +303,50 @@ class OpenAIChatStreamRunner:if not thinking_enabled:remaining = Noneelse:- for event in hold_events(sse.ensure_thinking_block()):+ for event in hold_events(ledger.ensure_thinking_block()):yield event- for event in hold_event(sse.emit_thinking_delta(remaining.content)):+ for event in hold_event(+ ledger.emit_thinking_delta(remaining.content)+ ):yield eventif remaining and remaining.type == ContentType.TEXT:- for event in hold_events(sse.ensure_text_block()):+ for event in hold_events(ledger.ensure_text_block()):yield event- for event in hold_event(sse.emit_text_delta(remaining.content)):+ for event in hold_event(ledger.emit_text_delta(remaining.content)):yield eventfor tool_use in heuristic_parser.flush():- for event in iter_heuristic_tool_use_sse(sse, tool_use):+ for event in iter_heuristic_tool_use_sse(ledger, tool_use):for out_event in hold_event(event):yield out_event- has_started_tool = any(s.started for s in sse.blocks.tool_states.values())+ has_emitted_tool = ledger.has_emitted_tool_block()has_content_blocks = (- sse.blocks.text_index != -1- or sse.blocks.thinking_index != -1- or has_started_tool+ ledger.blocks.text_index != -1+ or ledger.blocks.thinking_index != -1+ or has_emitted_tool)if not has_content_blocks or (- not has_started_tool- and not sse.accumulated_text.strip()- and sse.accumulated_reasoning.strip()+ not has_emitted_tool+ and not ledger.accumulated_text.strip()+ and ledger.accumulated_reasoning.strip()):- for event in hold_events(sse.ensure_text_block()):+ for event in hold_events(ledger.ensure_text_block()):yield event- for event in hold_event(sse.emit_text_delta(" ")):+ for event in hold_event(ledger.emit_text_delta(" ")):yield eventfor event in self._tool_calls.flush_tool_argument_alias_buffers(- sse, tool_argument_aliases, tool_argument_alias_buffers+ ledger, tool_argument_aliases, tool_argument_alias_buffers):for out_event in hold_event(event):yield out_event- for event in self._tool_calls.flush_task_arg_buffers(sse):+ for event in self._tool_calls.flush_task_arg_buffers(ledger):for out_event in hold_event(event):yield out_event- for event in hold_events(sse.close_all_blocks()):+ for event in hold_events(ledger.close_all_blocks()):yield eventcompletion = (@@ -347,7 +357,7 @@ class OpenAIChatStreamRunner:if isinstance(completion, int):output_tokens = completionelse:- output_tokens = sse.estimate_output_tokens()+ output_tokens = ledger.estimate_output_tokens()if usage_info and hasattr(usage_info, "prompt_tokens"):provider_input = usage_info.prompt_tokensif isinstance(provider_input, int):@@ -367,16 +377,19 @@ class OpenAIChatStreamRunner:prompt_tokens_estimate=self._input_tokens,)for event in hold_event(- sse.message_delta(map_stop_reason(finish_reason), output_tokens)+ ledger.message_delta(+ ledger.final_stop_reason(map_stop_reason(finish_reason)),+ output_tokens,+ )):yield event- for event in hold_event(sse.message_stop()):+ for event in hold_event(ledger.message_stop()):yield event- for event in recovery_session.flush():+ for event in recovery.flush():yield event- def _new_sse_builder(self) -> SSEBuilder:- return SSEBuilder(+ def _new_ledger(self) -> AnthropicStreamLedger:+ return AnthropicStreamLedger(self._message_id,self._request.model,self._input_tokens,diff --git a/providers/transports/openai_chat/tool_calls.py b/providers/transports/openai_chat/tool_calls.pyindex 53dbb721..e31aae9c 100644--- a/providers/transports/openai_chat/tool_calls.py+++ b/providers/transports/openai_chat/tool_calls.py@@ -7,9 +7,8 @@ import uuidfrom collections.abc import Callable, Iteratorfrom typing import Any-from core.anthropic import SSEBuilder-from core.anthropic.stream_recovery import (- parse_complete_tool_input,+from core.anthropic.streaming import (+ AnthropicStreamLedger,tool_schemas_by_name,)@@ -17,27 +16,27 @@ RecordToolExtraContent = Callable[[str, dict[str, Any]], None]def iter_heuristic_tool_use_sse(- sse: SSEBuilder, tool_use: dict[str, Any]+ ledger: AnthropicStreamLedger, tool_use: dict[str, Any]) -> Iterator[str]:"""Emit SSE for one heuristic tool_use block."""if tool_use.get("name") == "Task" and isinstance(tool_use.get("input"), dict):task_input = tool_use["input"]if task_input.get("run_in_background") is not False:task_input["run_in_background"] = False- yield from sse.close_content_blocks()- block_idx = sse.blocks.allocate_index()- yield sse.content_block_start(+ yield 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 sse.content_block_delta(+ yield ledger.content_block_delta(block_idx,"input_json_delta",json.dumps(tool_use["input"]),)- yield sse.content_block_stop(block_idx)+ yield ledger.content_block_stop(block_idx)def tool_call_extra_content(tool_call: Any) -> dict[str, Any] | None:@@ -65,35 +64,27 @@ def tool_call_extra_content(tool_call: Any) -> dict[str, Any] | None:return None-def has_committed_sse_output(sse: SSEBuilder) -> bool:+def has_committed_sse_output(ledger: AnthropicStreamLedger) -> bool:"""Return whether any assistant content escaped the builder."""return (- sse.blocks.text_index != -1- or sse.blocks.thinking_index != -1- or sse.blocks.has_emitted_tool_block()+ ledger.blocks.text_index != -1+ or ledger.blocks.thinking_index != -1+ or ledger.has_emitted_tool_block())-def started_tool_states(sse: SSEBuilder) -> list[tuple[int, Any]]:+def started_tool_states(ledger: AnthropicStreamLedger) -> list[tuple[int, Any]]:"""Return started tool states in stream order."""return [(tool_index, state)- for tool_index, state in sse.blocks.tool_states.items()+ for tool_index, state in ledger.blocks.tool_states.items()if state.started]-def all_started_tools_complete(sse: SSEBuilder, request: Any) -> bool:+def all_emitted_tools_complete(ledger: AnthropicStreamLedger, request: Any) -> bool:"""Return whether every emitted tool block has schema-valid input."""- schemas = tool_schemas_by_name(request)- started = started_tool_states(sse)- if not started:- return False- for _, state in started:- raw = "".join(state.contents)- if parse_complete_tool_input(raw, state.name, schemas) is None:- return False- return True+ return ledger.can_salvage_tool_use(tool_schemas_by_name(request))class OpenAIToolCallAssembler:@@ -107,7 +98,7 @@ class OpenAIToolCallAssembler:def process_tool_call(self,tc: dict[str, Any],- sse: SSEBuilder,+ ledger: AnthropicStreamLedger,*,tool_argument_aliases: dict[str, dict[str, str]] | None = None,tool_argument_alias_buffers: dict[int, str] | None = None,@@ -116,14 +107,14 @@ class OpenAIToolCallAssembler:raw_index = tc.get("index", 0)tc_index = raw_index if isinstance(raw_index, int) else 0if tc_index < 0:- tc_index = len(sse.blocks.tool_states)+ tc_index = len(ledger.blocks.tool_states)fn_delta = tc.get("function", {})incoming_name = fn_delta.get("name")arguments = fn_delta.get("arguments", "") or ""if tc.get("id") is not None:- sse.blocks.set_stream_tool_id(tc_index, tc.get("id"))+ ledger.blocks.set_stream_tool_id(tc_index, tc.get("id"))raw_extra_content = tc.get("extra_content")extra_content = (@@ -132,12 +123,12 @@ class OpenAIToolCallAssembler:else None)if extra_content:- sse.blocks.set_tool_extra_content(tc_index, extra_content)+ ledger.blocks.set_tool_extra_content(tc_index, extra_content)if incoming_name is not None:- sse.blocks.register_tool_name(tc_index, incoming_name)+ ledger.blocks.register_tool_name(tc_index, incoming_name)- state = sse.blocks.tool_states.get(tc_index)+ state = ledger.blocks.tool_states.get(tc_index)resolved_id = (state.tool_id if state and state.tool_id else None) or tc.get("id")@@ -151,51 +142,51 @@ class OpenAIToolCallAssembler:start_extra_content = state.extra_content if state else extra_contentif start_extra_content:self._record_tool_call_extra_content(tool_id, start_extra_content)- yield sse.start_tool_block(+ yield ledger.start_tool_block(tc_index,tool_id,display_name,extra_content=start_extra_content,)- state = sse.blocks.tool_states[tc_index]+ state = ledger.blocks.tool_states[tc_index]if state.pre_start_args:pre = state.pre_start_argsstate.pre_start_args = ""yield from self._emit_tool_arg_delta(- sse,+ ledger,tc_index,pre,tool_argument_aliases=tool_argument_aliases,tool_argument_alias_buffers=tool_argument_alias_buffers,)- state = sse.blocks.tool_states.get(tc_index)+ 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 not arguments:returnif state is None or not state.started:- state = sse.blocks.ensure_tool_state(tc_index)+ state = ledger.blocks.ensure_tool_state(tc_index)if not (resolved_name or "").strip():state.pre_start_args += argumentsreturnyield from self._emit_tool_arg_delta(- sse,+ ledger,tc_index,arguments,tool_argument_aliases=tool_argument_aliases,tool_argument_alias_buffers=tool_argument_alias_buffers,)- def flush_task_arg_buffers(self, sse: SSEBuilder) -> Iterator[str]:+ def flush_task_arg_buffers(self, ledger: AnthropicStreamLedger) -> Iterator[str]:"""Emit buffered Task args as a single JSON delta."""- for tool_index, out in sse.blocks.flush_task_arg_buffers():- yield sse.emit_tool_delta(tool_index, out)+ for tool_index, out in ledger.blocks.flush_task_arg_buffers():+ yield ledger.emit_tool_delta(tool_index, out)def flush_tool_argument_alias_buffers(self,- sse: SSEBuilder,+ ledger: AnthropicStreamLedger,tool_argument_aliases: dict[str, dict[str, str]],tool_argument_alias_buffers: dict[int, str],) -> Iterator[str]:@@ -204,14 +195,14 @@ class OpenAIToolCallAssembler:if not buffered_args:tool_argument_alias_buffers.pop(tool_index, None)continue- state = sse.blocks.tool_states.get(tool_index)+ state = ledger.blocks.tool_states.get(tool_index)if state is None or state.name == "Task":continuealiases = tool_argument_aliases.get(state.name, {})if not aliases:continuerestored = self._restore_aliased_tool_arguments(buffered_args, aliases)- yield sse.emit_tool_delta(+ yield ledger.emit_tool_delta(tool_index,restored if restored is not None else buffered_args,)@@ -219,7 +210,7 @@ class OpenAIToolCallAssembler:def _emit_tool_arg_delta(self,- sse: SSEBuilder,+ ledger: AnthropicStreamLedger,tc_index: int,args: str,*,@@ -229,13 +220,13 @@ class OpenAIToolCallAssembler:"""Emit one argument fragment for a started tool block."""if not args:return- state = sse.blocks.tool_states.get(tc_index)+ state = ledger.blocks.tool_states.get(tc_index)if state is None:returnif state.name == "Task":- parsed = sse.blocks.buffer_task_args(tc_index, args)+ parsed = ledger.blocks.buffer_task_args(tc_index, args)if parsed is not None:- yield sse.emit_tool_delta(tc_index, json.dumps(parsed))+ yield ledger.emit_tool_delta(tc_index, json.dumps(parsed))returnaliases = (tool_argument_aliases.get(state.name, {}) if tool_argument_aliases else {}@@ -244,7 +235,7 @@ class OpenAIToolCallAssembler:if tool_argument_alias_buffers is None:restored = self._restore_aliased_tool_arguments(args, aliases)if restored is not None:- yield sse.emit_tool_delta(tc_index, restored)+ yield ledger.emit_tool_delta(tc_index, restored)returnbuffered_args = tool_argument_alias_buffers.get(tc_index, "") + args@@ -253,9 +244,9 @@ class OpenAIToolCallAssembler:tool_argument_alias_buffers[tc_index] = buffered_argsreturntool_argument_alias_buffers.pop(tc_index, None)- yield sse.emit_tool_delta(tc_index, restored)+ yield ledger.emit_tool_delta(tc_index, restored)return- yield sse.emit_tool_delta(tc_index, args)+ yield ledger.emit_tool_delta(tc_index, args)def _restore_aliased_tool_arguments(self, argument_json: str, aliases: dict[str, str]diff --git a/providers/transports/openai_chat/transport.py b/providers/transports/openai_chat/transport.pyindex 978586dc..e7cba810 100644--- a/providers/transports/openai_chat/transport.py+++ b/providers/transports/openai_chat/transport.py@@ -9,7 +9,7 @@ from typing import Anyimport httpxfrom openai import AsyncOpenAI-from core.anthropic import SSEBuilder+from core.anthropic.streaming import AnthropicStreamLedgerfrom providers.base import BaseProvider, ProviderConfigfrom providers.error_mapping import (extract_provider_error_detail,@@ -19,7 +19,7 @@ from providers.error_mapping import (from providers.model_listing import extract_openai_model_idsfrom providers.rate_limit import GlobalRateLimiter-from .stream import OpenAIChatStreamRunner+from .stream import OpenAIChatStreamAdapterclass OpenAIChatTransport(BaseProvider):@@ -85,7 +85,7 @@ class OpenAIChatTransport(BaseProvider):"""Build request body. Must be implemented by subclasses."""def _handle_extra_reasoning(- self, delta: Any, sse: SSEBuilder, *, thinking_enabled: bool+ self, delta: Any, ledger: AnthropicStreamLedger, *, thinking_enabled: bool) -> Iterator[str]:"""Hook for provider-specific reasoning."""return iter(())@@ -145,12 +145,12 @@ class OpenAIChatTransport(BaseProvider):thinking_enabled: bool | None = None,) -> AsyncIterator[str]:"""Stream response in Anthropic SSE format."""- runner = OpenAIChatStreamRunner(+ adapter = OpenAIChatStreamAdapter(self,request=request,input_tokens=input_tokens,request_id=request_id,thinking_enabled=thinking_enabled,)- async for event in runner.run():+ async for event in adapter.run():yield eventdiff --git a/smoke/capabilities.py b/smoke/capabilities.pyindex 5f0149a6..2c5d080d 100644--- a/smoke/capabilities.py+++ b/smoke/capabilities.py@@ -171,7 +171,7 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = ("streaming_conversion","anthropic_sse_lifecycle","streaming_error_mapping",- "core.anthropic.SSEBuilder",+ "core.anthropic.streaming.AnthropicStreamLedger","provider stream chunks or native SSE events","Anthropic message/content/error SSE lifecycle","Anthropic-compatible error event",@@ -218,7 +218,7 @@ CAPABILITY_CONTRACTS: tuple[CapabilityContract, ...] = ("streaming_conversion","subagent_task_control","subagent_control",- "core.anthropic.SSEBuilder",+ "core.anthropic.streaming.AnthropicStreamLedger","Task tool call arguments","run_in_background=false","invalid JSON flushed as safe object",diff --git a/tests/api/test_openai_responses.py b/tests/api/test_openai_responses.pyindex 741cb224..b69e3b49 100644--- a/tests/api/test_openai_responses.py+++ b/tests/api/test_openai_responses.py@@ -7,8 +7,8 @@ import pytestfrom fastapi.testclient import TestClientfrom api.app import create_app-from core.anthropic.sse import format_sse_eventfrom core.anthropic.stream_contracts import parse_sse_text+from core.anthropic.streaming import format_sse_eventclass FakeProvider:diff --git a/tests/api/test_safe_logging.py b/tests/api/test_safe_logging.pyindex 1b3edde8..f45bbcb6 100644--- a/tests/api/test_safe_logging.py+++ b/tests/api/test_safe_logging.py@@ -11,7 +11,7 @@ from api import request_pipeline as pipeline_modfrom api.models.anthropic import Message, MessagesRequestfrom api.request_pipeline import ApiRequestPipelinefrom config.settings import Settings-from core.anthropic.sse import SSEBuilder+from core.anthropic import AnthropicStreamLedgerdef test_create_message_skips_full_payload_debug_log_by_default():@@ -65,18 +65,18 @@ def test_create_message_logs_full_payload_when_opt_in():assert any(k == "FULL_PAYLOAD [{}]: {}" for k in keys)-def test_sse_builder_default_debug_has_no_serialized_json_content():- with patch("core.anthropic.sse.logger.debug") as mock_debug:- sse = SSEBuilder("msg_x", "m", 1, log_raw_events=False)- sse.message_start()+def test_stream_ledger_default_debug_has_no_serialized_json_content():+ with patch("core.anthropic.streaming.emitter.logger.debug") as mock_debug:+ ledger = AnthropicStreamLedger("msg_x", "m", 1, log_raw_events=False)+ ledger.message_start()assert mock_debug.call_count == 0-def test_sse_builder_raw_logging_includes_event_body_when_enabled():- with patch("core.anthropic.sse.logger.debug") as mock_debug:- sse = SSEBuilder("msg_x", "m", 1, log_raw_events=True)- sse.message_start()+def test_stream_ledger_raw_logging_includes_event_body_when_enabled():+ with patch("core.anthropic.streaming.emitter.logger.debug") as mock_debug:+ ledger = AnthropicStreamLedger("msg_x", "m", 1, log_raw_events=True)+ ledger.message_start()assert mock_debug.call_count == 1message = str(mock_debug.call_args)diff --git a/tests/contracts/test_import_boundaries.py b/tests/contracts/test_import_boundaries.pyindex 7ae60b29..109a9555 100644--- a/tests/contracts/test_import_boundaries.py+++ b/tests/contracts/test_import_boundaries.py@@ -155,6 +155,51 @@ def test_provider_transports_live_under_transport_family_packages() -> None:assert offenders == []+def test_anthropic_stream_engine_owns_provider_stream_state() -> None:+ repo_root = Path(__file__).resolve().parents[2]+ anthropic_root = repo_root / "core" / "anthropic"+ streaming_root = anthropic_root / "streaming"++ for removed in {+ "sse.py",+ "emitted_sse_tracker.py",+ "stream_recovery.py",+ "stream_recovery_session.py",+ }:+ assert not (anthropic_root / removed).exists()++ for filename in {+ "__init__.py",+ "emitter.py",+ "ledger.py",+ "lifecycle.py",+ "recovery.py",+ }:+ assert (streaming_root / filename).exists()++ forbidden = (+ "SSEBuilder",+ "ContentBlockManager",+ "ToolCallState",+ "EmittedNativeSseTracker",+ "StreamRecoverySession",+ "OpenAIChatStreamRunner",+ "AnthropicMessagesStreamRunner",+ )+ offenders: list[str] = []+ for path in [+ *anthropic_root.rglob("*.py"),+ *(repo_root / "providers" / "transports").rglob("*.py"),+ ]:+ text = path.read_text(encoding="utf-8")+ offenders.extend(+ f"{path.relative_to(repo_root)}: {name}"+ for name in forbidden+ if name in text+ )+ assert sorted(offenders) == []++def test_openai_responses_uses_adapter_boundary() -> None:repo_root = Path(__file__).resolve().parents[2]responses_root = repo_root / "core" / "openai_responses"diff --git a/tests/contracts/test_stream_contracts.py b/tests/contracts/test_stream_contracts.pyindex 6898cc3a..009a3219 100644--- a/tests/contracts/test_stream_contracts.py+++ b/tests/contracts/test_stream_contracts.py@@ -1,5 +1,5 @@"""Stream/SSE contract tests. Strict transcript *ordering* is covered here for-``SSEBuilder`` output; for transport-integrated ordering, add messaging or API+``AnthropicStreamLedger`` output; for transport-integrated ordering, add messaging or APIintegration tests."""@@ -7,8 +7,12 @@ from __future__ import annotationsfrom collections.abc import Iterable-from core.anthropic import ContentType, HeuristicToolParser, SSEBuilder, ThinkTagParser-from core.anthropic.sse import format_sse_event+from core.anthropic import (+ AnthropicStreamLedger,+ ContentType,+ HeuristicToolParser,+ ThinkTagParser,+)from core.anthropic.stream_contracts import (assert_anthropic_stream_contract,event_names,@@ -16,6 +20,7 @@ from core.anthropic.stream_contracts import (text_content,thinking_content,)+from core.anthropic.streaming import format_sse_eventdef test_interleaved_thinking_text_blocks_are_valid() -> None:@@ -40,7 +45,7 @@ def test_split_think_tags_preserve_text_and_thinking() -> None:def test_mixed_reasoning_content_and_think_tags_keep_order() -> None:- builder = SSEBuilder("msg_contract", "contract-model")+ builder = AnthropicStreamLedger("msg_contract", "contract-model")chunks = [builder.message_start()]chunks.extend(builder.ensure_thinking_block())chunks.append(builder.emit_thinking_delta("reasoning field"))@@ -131,7 +136,7 @@ def test_task_tool_arguments_force_foreground_execution() -> None:def _interleaved_thinking_text_events(parts: tuple[str, str, str, str],) -> Iterable[str]:- builder = SSEBuilder("msg_contract", "contract-model")+ builder = AnthropicStreamLedger("msg_contract", "contract-model")yield builder.message_start()yield from builder.ensure_thinking_block()yield builder.emit_thinking_delta(parts[0])@@ -148,11 +153,11 @@ def _interleaved_thinking_text_events(def _events_from_text_chunks(chunks: list[str],- builder: SSEBuilder | None = None,+ builder: AnthropicStreamLedger | None = None,*,enable_thinking: bool = True,) -> list[str]:- sse = builder or SSEBuilder("msg_contract", "contract-model")+ sse = builder or AnthropicStreamLedger("msg_contract", "contract-model")out: list[str] = [] if builder else [sse.message_start()]parser = ThinkTagParser()@@ -171,7 +176,7 @@ def _events_from_text_chunks(def _emit_parser_parts(- builder: SSEBuilder,+ builder: AnthropicStreamLedger,parts: Iterable,enable_thinking: bool,) -> list[str]:diff --git a/tests/core/anthropic/test_stream_recovery.py b/tests/core/anthropic/test_stream_recovery.pyindex 49dbe968..5e16988b 100644--- a/tests/core/anthropic/test_stream_recovery.py+++ b/tests/core/anthropic/test_stream_recovery.py@@ -2,20 +2,18 @@import httpx-from core.anthropic.stream_recovery import (+from core.anthropic.streaming import (EARLY_TRANSPARENT_MAX_RETRIES,EARLY_TRANSPARENT_TOTAL_ATTEMPTS,MIDSTREAM_RECOVERY_ATTEMPTS,+ RecoveryController,+ RecoveryFailureAction,RecoveryHoldbackBuffer,ToolSchema,accept_tool_json_repair,continuation_suffix,is_retryable_stream_error,)-from core.anthropic.stream_recovery_session import (- StreamFailureAction,- StreamRecoverySession,-)def test_early_transparent_retry_total_attempts_is_five() -> None:@@ -44,7 +42,7 @@ def test_retryable_stream_error_classifies_transport_and_http_status() -> None:def test_stream_recovery_session_advances_early_retry_and_discards_holdback() -> None:- session = StreamRecoverySession(provider_name="TEST", request_id="REQ")+ session = RecoveryController(provider_name="TEST", request_id="REQ")assert session.push("hidden") == []decision = session.advance_failure(@@ -54,7 +52,7 @@ def test_stream_recovery_session_advances_early_retry_and_discards_holdback() ->complete_tool_salvageable=False,)- assert decision.action == StreamFailureAction.EARLY_RETRY+ assert decision.action == RecoveryFailureAction.EARLY_RETRYassert decision.early_retry_attempt == 1assert session.early_retries == 1assert not session.committed@@ -63,7 +61,7 @@ def test_stream_recovery_session_advances_early_retry_and_discards_holdback() ->def test_stream_recovery_session_respects_early_retry_limit() -> None:- session = StreamRecoverySession(provider_name="TEST", request_id=None)+ session = RecoveryController(provider_name="TEST", request_id=None)for attempt in range(1, EARLY_TRANSPARENT_MAX_RETRIES + 1):decision = session.advance_failure(@@ -72,7 +70,7 @@ def test_stream_recovery_session_respects_early_retry_limit() -> None:generated_output=False,complete_tool_salvageable=False,)- assert decision.action == StreamFailureAction.EARLY_RETRY+ assert decision.action == RecoveryFailureAction.EARLY_RETRYassert decision.early_retry_attempt == attemptdecision = session.advance_failure(@@ -82,12 +80,12 @@ def test_stream_recovery_session_respects_early_retry_limit() -> None:complete_tool_salvageable=False,)- assert decision.action == StreamFailureAction.FINAL_ERROR+ assert decision.action == RecoveryFailureAction.FINAL_ERRORassert session.early_retries == EARLY_TRANSPARENT_MAX_RETRIESdef test_stream_recovery_session_classifies_midstream_recovery_after_commit() -> None:- session = StreamRecoverySession(provider_name="TEST", request_id=None)+ session = RecoveryController(provider_name="TEST", request_id=None)assert session.push("event: content_block_delta\n\n") == []assert session.flush() == ["event: content_block_delta\n\n"]@@ -98,14 +96,14 @@ def test_stream_recovery_session_classifies_midstream_recovery_after_commit() ->complete_tool_salvageable=False,)- assert decision.action == StreamFailureAction.MIDSTREAM_RECOVERY+ assert decision.action == RecoveryFailureAction.MIDSTREAM_RECOVERYassert decision.retryableassert decision.committedassert session.flush_uncommitted(decision) == []def test_stream_recovery_session_flushes_uncommitted_midstream_decision() -> None:- session = StreamRecoverySession(provider_name="TEST", request_id=None)+ session = RecoveryController(provider_name="TEST", request_id=None)assert session.push("event: content_block_delta\n\n") == []decision = session.advance_failure(@@ -115,7 +113,7 @@ def test_stream_recovery_session_flushes_uncommitted_midstream_decision() -> Noncomplete_tool_salvageable=True,)- assert decision.action == StreamFailureAction.MIDSTREAM_RECOVERY+ assert decision.action == RecoveryFailureAction.MIDSTREAM_RECOVERYassert not decision.committedassert decision.has_bufferedassert not session.committed@@ -135,7 +133,7 @@ def test_stream_recovery_session_non_retryable_error_is_final() -> None:request=request,response=httpx.Response(400, request=request),)- session = StreamRecoverySession(provider_name="TEST", request_id=None)+ session = RecoveryController(provider_name="TEST", request_id=None)decision = session.advance_failure(error,@@ -144,7 +142,7 @@ def test_stream_recovery_session_non_retryable_error_is_final() -> None:complete_tool_salvageable=False,)- assert decision.action == StreamFailureAction.FINAL_ERROR+ assert decision.action == RecoveryFailureAction.FINAL_ERRORassert not decision.retryableassert session.early_retries == 0diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.pyindex f3c265be..37ae53c3 100644--- a/tests/core/openai_responses/test_sse.py+++ b/tests/core/openai_responses/test_sse.py@@ -5,8 +5,8 @@ from typing import Anyimport pytest-from core.anthropic.sse import format_sse_eventfrom core.anthropic.stream_contracts import parse_sse_text+from core.anthropic.streaming import format_sse_eventfrom core.openai_responses import OpenAIResponsesAdapter_ADAPTER = OpenAIResponsesAdapter()diff --git a/tests/messaging/test_stream_transcript_contract.py b/tests/messaging/test_stream_transcript_contract.pyindex 2ef2b609..db214e03 100644--- a/tests/messaging/test_stream_transcript_contract.py+++ b/tests/messaging/test_stream_transcript_contract.py@@ -2,7 +2,7 @@from __future__ import annotations-from core.anthropic import SSEBuilder+from core.anthropic import AnthropicStreamLedgerfrom core.anthropic.stream_contracts import (assert_anthropic_stream_contract,has_tool_use,@@ -13,7 +13,7 @@ from messaging.transcript import RenderCtx, TranscriptBufferdef test_thinking_tool_text_and_transcript_order_contract() -> None:- builder = SSEBuilder("msg_contract", "contract-model")+ builder = AnthropicStreamLedger("msg_contract", "contract-model")chunks = [builder.message_start()]chunks.extend(builder.ensure_thinking_block())chunks.append(builder.emit_thinking_delta("inspect first"))diff --git a/tests/providers/test_anthropic_messages.py b/tests/providers/test_anthropic_messages.pyindex d279a946..28ba76ef 100644--- a/tests/providers/test_anthropic_messages.py+++ b/tests/providers/test_anthropic_messages.py@@ -7,8 +7,13 @@ import httpximport pytestfrom config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS-from core.anthropic.sse import format_sse_eventfrom core.anthropic.stream_contracts import event_index, parse_sse_text+from core.anthropic.streaming import (+ MIDSTREAM_RECOVERY_ATTEMPTS,+ AnthropicStreamLedger,+ TruncatedProviderStreamError,+ format_sse_event,+)from providers.base import ProviderConfigfrom providers.transports.anthropic_messages import AnthropicMessagesTransportfrom providers.transports.anthropic_messages.recovery import AnthropicMessagesRecovery@@ -206,13 +211,9 @@ async def test_stream_uses_retry_builds_request_and_closes_response():events = [event async for event in provider.stream_response(req)]- assert events == [- "event: message_start\n",- 'data: {"type":"message_start"}\n',- "\n",- "event: message_stop\n",- 'data: {"type":"message_stop"}\n',- "\n",+ assert [event.event for event in parse_sse_text("".join(events))] == [+ "message_start",+ "message_stop",]assert response.is_closedassert mock_build.call_args.args[:2] == ("POST", "/messages")@@ -313,6 +314,145 @@ async def test_midstream_error_closes_open_block_and_uses_fresh_content_index(assert {event_index(e) for e in parsed if e.event == "content_block_stop"} == {0, 1}+async def test_midstream_error_after_native_message_delta_does_not_duplicate_terminal(+ provider_config,+):+ """If native upstream emitted message_delta before cutoff, recovery cannot append content."""+ provider = NativeProvider(provider_config)+ req = MockRequest()+ msg_start = format_sse_event(+ "message_start",+ {+ "type": "message_start",+ "message": {+ "id": "msg_terminal_cutoff",+ "type": "message",+ "role": "assistant",+ "content": [],+ "model": "test-model",+ "stop_reason": None,+ "stop_sequence": None,+ "usage": {"input_tokens": 1, "output_tokens": 1},+ },+ },+ )+ block_start = format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "text", "text": ""},+ },+ )+ text_delta = format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": "hello" + ("x" * 70_000)},+ },+ )+ block_stop = format_sse_event(+ "content_block_stop",+ {"type": "content_block_stop", "index": 0},+ )+ message_delta = format_sse_event(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "end_turn", "stop_sequence": None},+ "usage": {"input_tokens": 1, "output_tokens": 2},+ },+ )+ response = FakeResponse(+ lines=_lines_from_events(+ msg_start, block_start, text_delta, block_stop, message_delta+ )+ )++ with (+ patch.object(provider._client, "build_request", return_value=MagicMock()),+ patch.object(+ provider._client,+ "send",+ new_callable=AsyncMock,+ return_value=response,+ ),+ patch.object(+ AnthropicMessagesRecovery,+ "collect_text",+ new_callable=AsyncMock,+ return_value=("hello recovered", ""),+ ) as mock_collect,+ ):+ events = [e async for e in provider.stream_response(req)]++ parsed = parse_sse_text("".join(events))+ assert mock_collect.await_count == 0+ assert sum(event.event == "message_delta" for event in parsed) == 1+ assert sum(event.event == "message_stop" for event in parsed) == 1+ assert sum(event.event == "error" for event in parsed) == 1+ message_delta_index = next(+ index for index, event in enumerate(parsed) if event.event == "message_delta"+ )+ assert all(+ event.event+ not in {"content_block_start", "content_block_delta", "content_block_stop"}+ for event in parsed[message_delta_index + 1 :]+ )+++async def test_native_text_recovery_closes_thinking_before_text_suffix():+ """Recovery suffixes preserve Anthropic block ordering when switching types."""+ transport = MagicMock()+ transport._provider_name = "TEST_NATIVE"+ recovery = AnthropicMessagesRecovery(+ transport,+ iter_stream_chunks=MagicMock(),+ )+ ledger = AnthropicStreamLedger("msg_recovery", "test-model")+ ledger.start_thinking_block()+ ledger.emit_thinking_delta("thinking")++ with patch.object(+ recovery,+ "collect_text",+ new_callable=AsyncMock,+ return_value=("answer", "thinking more"),+ ) as mock_collect:+ events = await recovery.events(+ body={"messages": []},+ request=MockRequest(),+ ledger=ledger,+ error=TimeoutError("cutoff"),+ request_id="req_native_recovery",+ req_tag="",+ thinking_enabled=True,+ )++ assert events is not None+ assert mock_collect.await_args is not None+ recovery_body = mock_collect.await_args.args[0]+ assert "thinking" in recovery_body["messages"][-1]["content"]+ parsed = parse_sse_text("".join(events))+ assert [event.event for event in parsed] == [+ "content_block_delta",+ "content_block_stop",+ "content_block_start",+ "content_block_delta",+ "content_block_stop",+ "message_delta",+ "message_stop",+ ]+ assert parsed[0].data["index"] == 0+ assert parsed[1].data["index"] == 0+ assert parsed[2].data["index"] == 1+ assert parsed[2].data["content_block"]["type"] == "text"+ assert parsed[3].data["index"] == 1++@pytest.mark.asyncioasync def test_clean_eof_after_complete_native_tool_call_salvages_tool_use(provider_config,@@ -460,6 +600,210 @@ async def test_clean_eof_after_native_text_continues_with_overlap_trim(assert not any(event.event == "error" for event in parsed)+async def test_native_recovery_collect_text_requires_message_stop(provider_config):+ """Native recovery collectors reject truncated continuation streams."""+ provider = NativeProvider(provider_config)+ text_delta = format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": "world"},+ },+ )++ async def _iter_chunks(_response, *, state, thinking_enabled):+ yield text_delta++ recovery = AnthropicMessagesRecovery(provider, iter_stream_chunks=_iter_chunks)++ with (+ patch.object(+ provider,+ "_validated_stream_send",+ new_callable=AsyncMock,+ return_value=FakeResponse(),+ ) as mock_send,+ pytest.raises(TruncatedProviderStreamError),+ ):+ await recovery.collect_text({"messages": []}, req_tag="", thinking_enabled=True)++ assert mock_send.await_count == MIDSTREAM_RECOVERY_ATTEMPTS+++async def test_native_recovery_collect_text_accepts_message_stop(provider_config):+ """Native recovery collectors return text only after message_stop."""+ provider = NativeProvider(provider_config)+ text_delta = format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": "world"},+ },+ )+ message_stop = format_sse_event("message_stop", {"type": "message_stop"})++ async def _iter_chunks(_response, *, state, thinking_enabled):+ yield text_delta+ yield message_stop++ recovery = AnthropicMessagesRecovery(provider, iter_stream_chunks=_iter_chunks)++ with patch.object(+ provider,+ "_validated_stream_send",+ new_callable=AsyncMock,+ return_value=FakeResponse(),+ ):+ result = await recovery.collect_text(+ {"messages": []}, req_tag="", thinking_enabled=True+ )++ assert result == ("world", "")+++async def test_native_recovery_collect_text_reads_eager_start_content(provider_config):+ """Native recovery reads text/thinking carried on content_block_start."""+ provider = NativeProvider(provider_config)+ text_start = format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "text", "text": "hello"},+ },+ )+ thinking_start = format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 1,+ "content_block": {"type": "thinking", "thinking": "step"},+ },+ )+ text_delta = format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": " world"},+ },+ )+ thinking_delta = format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 1,+ "delta": {"type": "thinking_delta", "thinking": " two"},+ },+ )+ message_stop = format_sse_event("message_stop", {"type": "message_stop"})++ async def _iter_chunks(_response, *, state, thinking_enabled):+ yield text_start+ yield thinking_start+ yield text_delta+ yield thinking_delta+ yield message_stop++ recovery = AnthropicMessagesRecovery(provider, iter_stream_chunks=_iter_chunks)++ with patch.object(+ provider,+ "_validated_stream_send",+ new_callable=AsyncMock,+ return_value=FakeResponse(),+ ):+ result = await recovery.collect_text(+ {"messages": []}, req_tag="", thinking_enabled=True+ )++ assert result == ("hello world", "step two")+++async def test_truncated_native_recovery_stream_falls_back_to_error_tail(+ provider_config,+):+ """Partial native recovery bytes are not converted into a success tail."""+ provider = NativeProvider(provider_config)+ req = MockRequest()+ msg_start = format_sse_event(+ "message_start",+ {+ "type": "message_start",+ "message": {+ "id": "msg_text_eof",+ "type": "message",+ "role": "assistant",+ "content": [],+ "model": "test-model",+ "stop_reason": None,+ "stop_sequence": None,+ "usage": {"input_tokens": 1, "output_tokens": 1},+ },+ },+ )+ block_start = format_sse_event(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "text", "text": ""},+ },+ )+ original_text = "hello wor" + ("x" * 70_000)+ original_delta = format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": original_text},+ },+ )+ recovery_delta = format_sse_event(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": "world"},+ },+ )+ original = FakeResponse(+ lines=_lines_from_events(msg_start, block_start, original_delta)+ )+ recovery_responses = [+ FakeResponse(lines=_lines_from_events(recovery_delta))+ for _ in range(MIDSTREAM_RECOVERY_ATTEMPTS)+ ]++ with (+ patch.object(provider._client, "build_request", return_value=MagicMock()),+ patch.object(+ provider._client,+ "send",+ new_callable=AsyncMock,+ side_effect=[original, *recovery_responses],+ ) as mock_send,+ ):+ events = [e async for e in provider.stream_response(req)]++ event_text = "".join(events)+ assert mock_send.await_count == 1 + MIDSTREAM_RECOVERY_ATTEMPTS+ assert original_text in event_text+ assert "world" not in event_text+ assert "Provider stream ended without message_stop." in event_text+ assert not any(+ event.event == "content_block_delta"+ and event.data.get("delta", {}).get("text") == "ld"+ for event in parse_sse_text(event_text)+ )++@pytest.mark.asyncioasync def test_precommit_native_holdback_retries_without_leaking_partial(provider_config,diff --git a/tests/providers/test_anthropic_messages_429_retry.py b/tests/providers/test_anthropic_messages_429_retry.pyindex 12a3ea31..d1753dd9 100644--- a/tests/providers/test_anthropic_messages_429_retry.py+++ b/tests/providers/test_anthropic_messages_429_retry.py@@ -6,6 +6,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport httpximport pytest+from core.anthropic.stream_contracts import event_names, parse_sse_textfrom providers.base import ProviderConfigfrom providers.rate_limit import GlobalRateLimiterfrom tests.providers.test_anthropic_messages import (@@ -16,6 +17,13 @@ from tests.providers.test_anthropic_messages import (from tests.stream_contract import assert_canonical_stream_error_envelope+def _assert_minimal_success_stream(events: list[str]) -> None:+ assert event_names(parse_sse_text("".join(events))) == [+ "message_start",+ "message_stop",+ ]++@pytest.fixturedef provider_config():return ProviderConfig(@@ -74,14 +82,7 @@ async def test_native_stream_retries_on_http_429_then_streams(provider_config):assert send_calls["n"] == 2assert too_many.is_closedassert ok_response.is_closed- assert events == [- "event: message_start\n",- 'data: {"type":"message_start"}\n',- "\n",- "event: message_stop\n",- 'data: {"type":"message_stop"}\n',- "\n",- ]+ _assert_minimal_success_stream(events)finally:GlobalRateLimiter.reset_instance()@@ -134,14 +135,7 @@ async def test_native_stream_retries_on_http_5xx_then_streams(assert send_calls["n"] == 2assert bad.is_closedassert ok_response.is_closed- assert events == [- "event: message_start\n",- 'data: {"type":"message_start"}\n',- "\n",- "event: message_stop\n",- 'data: {"type":"message_stop"}\n',- "\n",- ]+ _assert_minimal_success_stream(events)finally:GlobalRateLimiter.reset_instance()diff --git a/tests/providers/test_llamacpp.py b/tests/providers/test_llamacpp.pyindex 1fe8db69..a2d8e7b2 100644--- a/tests/providers/test_llamacpp.py+++ b/tests/providers/test_llamacpp.py@@ -6,6 +6,7 @@ import httpximport pytestfrom config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+from core.anthropic.stream_contracts import parse_sse_textfrom providers.base import ProviderConfigfrom providers.llamacpp import LlamaCppProviderfrom tests.stream_contract import assert_canonical_stream_error_envelope@@ -192,10 +193,12 @@ async def test_stream_response(llamacpp_provider):# Verify internal ThinkingConfig is mapped to Anthropic API formatassert kwargs["json"]["thinking"] == {"type": "enabled"}- # Verify events yielded correctly- assert len(events) == 9- assert events[0] == "event: message_start\n"- assert events[1] == 'data: {"type":"message_start","message":{}}\n'+ assert [event.event for event in parse_sse_text("".join(events))] == [+ "message_start",+ "content_block_delta",+ "message_stop",+ ]+ assert "Hello World" in "".join(events)@pytest.mark.asynciodiff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.pyindex 7c2d2535..6749bb16 100644--- a/tests/providers/test_lmstudio.py+++ b/tests/providers/test_lmstudio.py@@ -6,6 +6,7 @@ import httpximport pytestfrom config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+from core.anthropic.stream_contracts import parse_sse_textfrom providers.base import ProviderConfigfrom providers.lmstudio import LMStudioProviderfrom tests.stream_contract import assert_canonical_stream_error_envelope@@ -223,10 +224,12 @@ async def test_stream_response(lmstudio_provider):# Verify internal ThinkingConfig is mapped to Anthropic API formatassert kwargs["json"]["thinking"] == {"type": "enabled"}- # Verify events yielded correctly- assert len(events) == 9- assert events[0] == "event: message_start\n"- assert events[1] == 'data: {"type":"message_start","message":{}}\n'+ assert [event.event for event in parse_sse_text("".join(events))] == [+ "message_start",+ "content_block_delta",+ "message_stop",+ ]+ assert "Hello World" in "".join(events)@pytest.mark.asynciodiff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.pyindex 661981f8..611049b3 100644--- a/tests/providers/test_ollama.py+++ b/tests/providers/test_ollama.py@@ -5,6 +5,7 @@ from unittest.mock import AsyncMock, MagicMock, patchimport httpximport pytest+from core.anthropic.stream_contracts import parse_sse_textfrom providers.base import ProviderConfigfrom providers.ollama import OLLAMA_DEFAULT_BASE, OllamaProviderfrom tests.stream_contract import assert_canonical_stream_error_envelope@@ -184,8 +185,12 @@ async def test_stream_response(ollama_provider):assert kwargs["json"]["stream"] is Trueassert "extra_body" not in kwargs["json"]assert kwargs["json"]["thinking"] == {"type": "enabled"}- assert len(events) == 9- assert events[0] == "event: message_start\n"+ assert [event.event for event in parse_sse_text("".join(events))] == [+ "message_start",+ "content_block_delta",+ "message_stop",+ ]+ assert "Hello World" in "".join(events)@pytest.mark.asynciodiff --git a/tests/providers/test_sse_builder.py b/tests/providers/test_sse_builder.pydeleted file mode 100644index 6ea66f8c..00000000--- a/tests/providers/test_sse_builder.py+++ /dev/null@@ -1,435 +0,0 @@-"""Tests for core.anthropic.sse."""--from typing import Any, cast-from unittest.mock import patch--import pytest--from core.anthropic import ContentBlockManager, SSEBuilder, map_stop_reason-from core.anthropic.sse import ToolCallState-from core.anthropic.stream_contracts import parse_sse_text---def _parse_sse(sse_str: str) -> dict:- """Parse an SSE event string into its data payload."""- events = parse_sse_text(sse_str)- if len(events) != 1:- raise ValueError(f"expected 1 SSE event, got {len(events)} in {sse_str!r}")- return events[0].data---class TestMapStopReason:- """Tests for map_stop_reason function."""-- @pytest.mark.parametrize(- "openai_reason,expected",- [- ("stop", "end_turn"),- ("length", "max_tokens"),- ("tool_calls", "tool_use"),- ("content_filter", "end_turn"),- (None, "end_turn"),- ("unknown_value", "end_turn"),- ("", "end_turn"),- ],- ids=[- "stop",- "length",- "tool_calls",- "content_filter",- "none",- "unknown",- "empty_string",- ],- )- def test_map_stop_reason(self, openai_reason, expected):- assert map_stop_reason(openai_reason) == expected---class TestContentBlockManager:- """Tests for ContentBlockManager."""-- def test_allocate_index_increments(self):- mgr = ContentBlockManager()- assert mgr.allocate_index() == 0- assert mgr.allocate_index() == 1- assert mgr.allocate_index() == 2-- def test_initial_state(self):- mgr = ContentBlockManager()- assert mgr.thinking_index == -1- assert mgr.text_index == -1- assert mgr.thinking_started is False- assert mgr.text_started is False- assert mgr.tool_states == {}-- def test_flush_task_arg_buffers_logs_digest_not_secret(self, caplog):- """Invalid Task JSON warnings must not echo argument prefixes (secrets)."""- mgr = ContentBlockManager()- mgr.tool_states[0] = ToolCallState(- block_index=0, tool_id="call_x", name="Task", started=True- )- mgr.tool_states[- 0- ].task_arg_buffer = (- '{"api_key": "sk-live-super-secret-do-not-log"}not_valid_json'- )- with caplog.at_level("WARNING"):- out = mgr.flush_task_arg_buffers()- assert out == [(0, "{}")]- text = " | ".join(r.message for r in caplog.records)- assert "sk-live-super-secret" not in text- assert "buffer_sha256_prefix=" in text---class TestSSEBuilderMessageLifecycle:- """Tests for message_start, message_delta, message_stop."""-- def test_message_start(self):- builder = SSEBuilder("msg_123", "test-model", input_tokens=50)- sse = builder.message_start()-- assert "event: message_start" in sse- data = _parse_sse(sse)- assert data["type"] == "message_start"- msg = data["message"]- assert msg["id"] == "msg_123"- assert msg["model"] == "test-model"- assert msg["role"] == "assistant"- assert msg["content"] == []- assert msg["usage"]["input_tokens"] == 50- assert msg["usage"]["output_tokens"] == 1-- def test_message_delta(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.message_delta("end_turn", 42)-- assert "event: message_delta" in sse- data = _parse_sse(sse)- assert data["type"] == "message_delta"- assert data["delta"]["stop_reason"] == "end_turn"- assert data["usage"]["output_tokens"] == 42-- def test_message_start_coerces_non_int_input_tokens(self):- builder = SSEBuilder("msg_1", "model", input_tokens=0)- builder.input_tokens = cast(Any, "not_an_int")- sse = builder.message_start()- data = _parse_sse(sse)- assert data["message"]["usage"]["input_tokens"] == 0- assert data["message"]["usage"]["output_tokens"] == 1-- def test_message_delta_coerces_none_output_tokens(self):- builder = SSEBuilder("msg_1", "model", input_tokens=3)- sse = builder.message_delta("end_turn", None)- data = _parse_sse(sse)- assert data["usage"]["input_tokens"] == 3- assert data["usage"]["output_tokens"] == 0-- def test_message_delta_preserves_zero_output_tokens(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.message_delta("end_turn", 0)- data = _parse_sse(sse)- assert data["usage"]["output_tokens"] == 0-- def test_message_stop(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.message_stop()-- assert "event: message_stop" in sse- data = _parse_sse(sse)- assert data["type"] == "message_stop"---class TestSSEBuilderContentBlocks:- """Tests for content block start/delta/stop events."""-- def test_content_block_start_text(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_start(0, "text", text="hello")-- data = _parse_sse(sse)- assert data["type"] == "content_block_start"- assert data["index"] == 0- assert data["content_block"]["type"] == "text"- assert data["content_block"]["text"] == "hello"-- def test_content_block_start_thinking(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_start(1, "thinking")-- data = _parse_sse(sse)- assert data["content_block"]["type"] == "thinking"- assert data["content_block"]["thinking"] == ""-- def test_content_block_start_tool_use(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_start(- 2, "tool_use", id="tool_123", name="Read", input={}- )-- data = _parse_sse(sse)- assert data["content_block"]["type"] == "tool_use"- assert data["content_block"]["id"] == "tool_123"- assert data["content_block"]["name"] == "Read"- assert data["content_block"]["input"] == {}-- def test_content_block_start_tool_use_extra_content(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_start(- 2,- "tool_use",- id="tool_123",- name="Read",- input={},- extra_content={"google": {"thought_signature": "sig"}},- )-- data = _parse_sse(sse)- assert data["content_block"]["extra_content"] == {- "google": {"thought_signature": "sig"}- }-- def test_content_block_delta_text(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_delta(0, "text_delta", "hello world")-- data = _parse_sse(sse)- assert data["type"] == "content_block_delta"- assert data["index"] == 0- assert data["delta"]["type"] == "text_delta"- assert data["delta"]["text"] == "hello world"-- def test_content_block_delta_thinking(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_delta(1, "thinking_delta", "reasoning...")-- data = _parse_sse(sse)- assert data["delta"]["type"] == "thinking_delta"- assert data["delta"]["thinking"] == "reasoning..."-- def test_content_block_delta_input_json(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_delta(2, "input_json_delta", '{"key": "val"}')-- data = _parse_sse(sse)- assert data["delta"]["type"] == "input_json_delta"- assert data["delta"]["partial_json"] == '{"key": "val"}'-- def test_content_block_stop(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.content_block_stop(0)-- data = _parse_sse(sse)- assert data["type"] == "content_block_stop"- assert data["index"] == 0---class TestSSEBuilderHighLevelHelpers:- """Tests for high-level thinking/text/tool block helpers."""-- def test_start_and_stop_thinking_block(self):- builder = SSEBuilder("msg_1", "model")-- start_sse = builder.start_thinking_block()- data = _parse_sse(start_sse)- assert data["content_block"]["type"] == "thinking"- assert builder.blocks.thinking_started is True- assert builder.blocks.thinking_index == 0-- stop_sse = builder.stop_thinking_block()- data = _parse_sse(stop_sse)- assert data["type"] == "content_block_stop"- assert builder.blocks.thinking_started is False-- def test_emit_thinking_delta_accumulates(self):- builder = SSEBuilder("msg_1", "model")- builder.start_thinking_block()-- builder.emit_thinking_delta("part1 ")- builder.emit_thinking_delta("part2")-- assert builder.accumulated_reasoning == "part1 part2"-- def test_start_and_stop_text_block(self):- builder = SSEBuilder("msg_1", "model")-- start_sse = builder.start_text_block()- data = _parse_sse(start_sse)- assert data["content_block"]["type"] == "text"- assert builder.blocks.text_started is True- assert builder.blocks.text_index == 0-- builder.stop_text_block()- assert builder.blocks.text_started is False-- def test_emit_text_delta_accumulates(self):- builder = SSEBuilder("msg_1", "model")- builder.start_text_block()-- builder.emit_text_delta("hello ")- builder.emit_text_delta("world")-- assert builder.accumulated_text == "hello world"-- def test_start_tool_block(self):- builder = SSEBuilder("msg_1", "model")- sse = builder.start_tool_block(0, "tool_abc", "Grep")-- data = _parse_sse(sse)- assert data["content_block"]["type"] == "tool_use"- assert data["content_block"]["id"] == "tool_abc"- assert data["content_block"]["name"] == "Grep"- assert 0 in builder.blocks.tool_states-- def test_emit_tool_delta(self):- builder = SSEBuilder("msg_1", "model")- builder.start_tool_block(0, "tool_abc", "Grep")-- sse = builder.emit_tool_delta(0, '{"pattern":')- data = _parse_sse(sse)- assert data["delta"]["partial_json"] == '{"pattern":'- assert "".join(builder.blocks.tool_states[0].contents) == '{"pattern":'-- def test_stop_tool_block(self):- builder = SSEBuilder("msg_1", "model")- builder.start_tool_block(0, "tool_abc", "Grep")-- sse = builder.stop_tool_block(0)- data = _parse_sse(sse)- assert data["type"] == "content_block_stop"---class TestSSEBuilderStateManagement:- """Tests for ensure_thinking_block, ensure_text_block, close_all_blocks."""-- def test_ensure_thinking_block_closes_text_first(self):- builder = SSEBuilder("msg_1", "model")- builder.start_text_block()- assert builder.blocks.text_started is True-- events = list(builder.ensure_thinking_block())- # Should close text then start thinking- assert len(events) == 2- assert builder.blocks.text_started is False- assert builder.blocks.thinking_started is True-- def test_ensure_thinking_block_noop_if_already_started(self):- builder = SSEBuilder("msg_1", "model")- builder.start_thinking_block()-- events = list(builder.ensure_thinking_block())- assert events == []-- def test_ensure_text_block_closes_thinking_first(self):- builder = SSEBuilder("msg_1", "model")- builder.start_thinking_block()- assert builder.blocks.thinking_started is True-- events = list(builder.ensure_text_block())- # Should close thinking then start text- assert len(events) == 2- assert builder.blocks.thinking_started is False- assert builder.blocks.text_started is True-- def test_ensure_text_block_noop_if_already_started(self):- builder = SSEBuilder("msg_1", "model")- builder.start_text_block()-- events = list(builder.ensure_text_block())- assert events == []-- def test_close_content_blocks(self):- builder = SSEBuilder("msg_1", "model")- builder.start_thinking_block()- builder.stop_thinking_block()- builder.start_text_block()-- events = list(builder.close_content_blocks())- # Should close text (thinking already stopped)- assert len(events) == 1- assert builder.blocks.text_started is False-- def test_close_all_blocks(self):- builder = SSEBuilder("msg_1", "model")- builder.start_thinking_block()- builder.stop_thinking_block()- builder.start_text_block()- builder.start_tool_block(0, "t1", "Read")- builder.start_tool_block(1, "t2", "Write")-- events = list(builder.close_all_blocks())- # Close text + 2 tool blocks (thinking already stopped)- assert len(events) == 3- assert builder.blocks.text_started is False-- def test_close_all_blocks_empty(self):- builder = SSEBuilder("msg_1", "model")- events = list(builder.close_all_blocks())- assert events == []---class TestSSEBuilderError:- """Tests for emit_error."""-- def test_emit_error(self):- builder = SSEBuilder("msg_1", "model")- events = list(builder.emit_error("Something went wrong"))-- assert len(events) == 3 # start, delta, stop- start_data = _parse_sse(events[0])- assert start_data["content_block"]["type"] == "text"-- delta_data = _parse_sse(events[1])- assert delta_data["delta"]["text"] == "Something went wrong"-- stop_data = _parse_sse(events[2])- assert stop_data["type"] == "content_block_stop"---class TestSSEBuilderTokenEstimation:- """Tests for estimate_output_tokens."""-- def test_estimate_with_text_only(self):- builder = SSEBuilder("msg_1", "model")- builder.start_text_block()- builder.emit_text_delta("hello world")-- tokens = builder.estimate_output_tokens()- assert tokens > 0-- def test_estimate_with_reasoning(self):- builder = SSEBuilder("msg_1", "model")- builder.start_thinking_block()- builder.emit_thinking_delta("deep thought")- builder.stop_thinking_block()- builder.start_text_block()- builder.emit_text_delta("answer")-- tokens = builder.estimate_output_tokens()- assert tokens > 0-- def test_estimate_empty(self):- builder = SSEBuilder("msg_1", "model")- tokens = builder.estimate_output_tokens()- assert tokens == 0-- def test_estimate_without_tiktoken(self):- """Fallback estimation when tiktoken is not available."""- builder = SSEBuilder("msg_1", "model")- builder.start_text_block()- builder.emit_text_delta("a" * 100) # 100 chars -> ~25 tokens-- with patch("core.anthropic.sse.ENCODER", None):- tokens = builder.estimate_output_tokens()- assert tokens == 25 # 100 // 4-- def test_estimate_with_tools_no_tiktoken(self):- """Fallback tool token estimation."""- builder = SSEBuilder("msg_1", "model")- builder.start_tool_block(0, "t1", "Read")- builder.emit_tool_delta(0, '{"path":"test.py"}')-- with patch("core.anthropic.sse.ENCODER", None):- tokens = builder.estimate_output_tokens()- # 1 tool * 50 = 50- assert tokens == 50diff --git a/tests/providers/test_stream_ledger.py b/tests/providers/test_stream_ledger.pynew file mode 100644index 00000000..499f64ac--- /dev/null+++ b/tests/providers/test_stream_ledger.py@@ -0,0 +1,833 @@+"""Tests for core.anthropic.streaming.ledger."""++from typing import Any, cast+from unittest.mock import patch++import pytest++from core.anthropic import AnthropicStreamLedger, StreamBlockLedger, map_stop_reason+from core.anthropic.stream_contracts import SSEEvent, parse_sse_text+from core.anthropic.streaming import ToolBlockState+++def _parse_sse(sse_str: str) -> dict:+ """Parse an SSE event string into its data payload."""+ events = parse_sse_text(sse_str)+ if len(events) != 1:+ raise ValueError(f"expected 1 SSE event, got {len(events)} in {sse_str!r}")+ return events[0].data+++class _CharEncoder:+ def encode(self, text: str) -> list[int]:+ return [0] * len(text)+++class TestMapStopReason:+ """Tests for map_stop_reason function."""++ @pytest.mark.parametrize(+ "openai_reason,expected",+ [+ ("stop", "end_turn"),+ ("length", "max_tokens"),+ ("tool_calls", "tool_use"),+ ("content_filter", "end_turn"),+ (None, "end_turn"),+ ("unknown_value", "end_turn"),+ ("", "end_turn"),+ ],+ ids=[+ "stop",+ "length",+ "tool_calls",+ "content_filter",+ "none",+ "unknown",+ "empty_string",+ ],+ )+ def test_map_stop_reason(self, openai_reason, expected):+ assert map_stop_reason(openai_reason) == expected+++class TestStreamBlockLedger:+ """Tests for StreamBlockLedger."""++ def test_allocate_index_increments(self):+ mgr = StreamBlockLedger()+ assert mgr.allocate_index() == 0+ assert mgr.allocate_index() == 1+ assert mgr.allocate_index() == 2++ def test_initial_state(self):+ mgr = StreamBlockLedger()+ assert mgr.thinking_index == -1+ assert mgr.text_index == -1+ assert mgr.thinking_started is False+ assert mgr.text_started is False+ assert mgr.tool_states == {}++ def test_flush_task_arg_buffers_logs_digest_not_secret(self, caplog):+ """Invalid Task JSON warnings must not echo argument prefixes (secrets)."""+ mgr = StreamBlockLedger()+ mgr.tool_states[0] = ToolBlockState(+ block_index=0, tool_id="call_x", name="Task", started=True+ )+ mgr.tool_states[+ 0+ ].task_arg_buffer = (+ '{"api_key": "sk-live-super-secret-do-not-log"}not_valid_json'+ )+ with caplog.at_level("WARNING"):+ out = mgr.flush_task_arg_buffers()+ assert out == [(0, "{}")]+ text = " | ".join(r.message for r in caplog.records)+ assert "sk-live-super-secret" not in text+ assert "buffer_sha256_prefix=" in text+++class TestAnthropicStreamLedgerMessageLifecycle:+ """Tests for message_start, message_delta, message_stop."""++ def test_message_start(self):+ builder = AnthropicStreamLedger("msg_123", "test-model", input_tokens=50)+ sse = builder.message_start()++ assert "event: message_start" in sse+ data = _parse_sse(sse)+ assert data["type"] == "message_start"+ msg = data["message"]+ assert msg["id"] == "msg_123"+ assert msg["model"] == "test-model"+ assert msg["role"] == "assistant"+ assert msg["content"] == []+ assert msg["usage"]["input_tokens"] == 50+ assert msg["usage"]["output_tokens"] == 1++ def test_message_delta(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.message_delta("end_turn", 42)++ assert "event: message_delta" in sse+ data = _parse_sse(sse)+ assert data["type"] == "message_delta"+ assert data["delta"]["stop_reason"] == "end_turn"+ assert data["usage"]["output_tokens"] == 42++ def test_message_start_coerces_non_int_input_tokens(self):+ builder = AnthropicStreamLedger("msg_1", "model", input_tokens=0)+ builder.input_tokens = cast(Any, "not_an_int")+ sse = builder.message_start()+ data = _parse_sse(sse)+ assert data["message"]["usage"]["input_tokens"] == 0+ assert data["message"]["usage"]["output_tokens"] == 1++ def test_message_delta_coerces_none_output_tokens(self):+ builder = AnthropicStreamLedger("msg_1", "model", input_tokens=3)+ sse = builder.message_delta("end_turn", None)+ data = _parse_sse(sse)+ assert data["usage"]["input_tokens"] == 3+ assert data["usage"]["output_tokens"] == 0++ def test_message_delta_preserves_zero_output_tokens(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.message_delta("end_turn", 0)+ data = _parse_sse(sse)+ assert data["usage"]["output_tokens"] == 0++ def test_message_stop(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.message_stop()++ assert "event: message_stop" in sse+ data = _parse_sse(sse)+ assert data["type"] == "message_stop"+++class TestAnthropicStreamLedgerContentBlocks:+ """Tests for content block start/delta/stop events."""++ def test_content_block_start_text(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_start(0, "text", text="hello")++ data = _parse_sse(sse)+ assert data["type"] == "content_block_start"+ assert data["index"] == 0+ assert data["content_block"]["type"] == "text"+ assert data["content_block"]["text"] == "hello"++ def test_content_block_start_thinking(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_start(1, "thinking")++ data = _parse_sse(sse)+ assert data["content_block"]["type"] == "thinking"+ assert data["content_block"]["thinking"] == ""++ def test_content_block_start_tool_use(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_start(+ 2, "tool_use", id="tool_123", name="Read", input={}+ )++ data = _parse_sse(sse)+ assert data["content_block"]["type"] == "tool_use"+ assert data["content_block"]["id"] == "tool_123"+ assert data["content_block"]["name"] == "Read"+ assert data["content_block"]["input"] == {}+ assert builder.has_emitted_tool_block()++ def test_content_block_start_tool_use_extra_content(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_start(+ 2,+ "tool_use",+ id="tool_123",+ name="Read",+ input={},+ extra_content={"google": {"thought_signature": "sig"}},+ )++ data = _parse_sse(sse)+ assert data["content_block"]["extra_content"] == {+ "google": {"thought_signature": "sig"}+ }++ def test_content_block_delta_text(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_delta(0, "text_delta", "hello world")++ data = _parse_sse(sse)+ assert data["type"] == "content_block_delta"+ assert data["index"] == 0+ assert data["delta"]["type"] == "text_delta"+ assert data["delta"]["text"] == "hello world"++ def test_content_block_delta_thinking(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_delta(1, "thinking_delta", "reasoning...")++ data = _parse_sse(sse)+ assert data["delta"]["type"] == "thinking_delta"+ assert data["delta"]["thinking"] == "reasoning..."++ def test_content_block_delta_input_json(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_delta(2, "input_json_delta", '{"key": "val"}')++ data = _parse_sse(sse)+ assert data["delta"]["type"] == "input_json_delta"+ assert data["delta"]["partial_json"] == '{"key": "val"}'++ def test_content_block_stop(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.content_block_stop(0)++ data = _parse_sse(sse)+ assert data["type"] == "content_block_stop"+ assert data["index"] == 0+++class TestAnthropicStreamLedgerHighLevelHelpers:+ """Tests for high-level thinking/text/tool block helpers."""++ def test_start_and_stop_thinking_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")++ start_sse = builder.start_thinking_block()+ data = _parse_sse(start_sse)+ assert data["content_block"]["type"] == "thinking"+ assert builder.blocks.thinking_started is True+ assert builder.blocks.thinking_index == 0++ stop_sse = builder.stop_thinking_block()+ data = _parse_sse(stop_sse)+ assert data["type"] == "content_block_stop"+ assert builder.blocks.thinking_started is False++ def test_emit_thinking_delta_accumulates(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_thinking_block()++ builder.emit_thinking_delta("part1 ")+ builder.emit_thinking_delta("part2")++ assert builder.accumulated_reasoning == "part1 part2"++ def test_start_and_stop_text_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")++ start_sse = builder.start_text_block()+ data = _parse_sse(start_sse)+ assert data["content_block"]["type"] == "text"+ assert builder.blocks.text_started is True+ assert builder.blocks.text_index == 0++ builder.stop_text_block()+ assert builder.blocks.text_started is False++ def test_emit_text_delta_accumulates(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_text_block()++ builder.emit_text_delta("hello ")+ builder.emit_text_delta("world")++ assert builder.accumulated_text == "hello world"++ def test_start_tool_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ sse = builder.start_tool_block(0, "tool_abc", "Grep")++ data = _parse_sse(sse)+ assert data["content_block"]["type"] == "tool_use"+ assert data["content_block"]["id"] == "tool_abc"+ assert data["content_block"]["name"] == "Grep"+ assert 0 in builder.blocks.tool_states++ def test_emit_tool_delta(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_tool_block(0, "tool_abc", "Grep")++ sse = builder.emit_tool_delta(0, '{"pattern":')+ data = _parse_sse(sse)+ assert data["delta"]["partial_json"] == '{"pattern":'+ block = builder.tool_block_for_tool_index(0)+ assert block is not None+ assert block.content == '{"pattern":'++ def test_stop_tool_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_tool_block(0, "tool_abc", "Grep")++ sse = builder.stop_tool_block(0)+ data = _parse_sse(sse)+ assert data["type"] == "content_block_stop"++ def test_text_suffix_after_closed_native_block_closes_once(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.ingest_native_event(+ SSEEvent(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "text", "text": ""},+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": "hello"},+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent(+ "content_block_stop",+ {"type": "content_block_stop", "index": 0},+ "",+ )+ )++ events = list(builder.append_text_suffix(" world"))+ events.extend(builder.success_tail("end_turn"))+ parsed = parse_sse_text("".join(events))++ assert [+ event.data["index"]+ for event in parsed+ if event.event == "content_block_start"+ ] == [1]+ assert [+ event.data["index"]+ for event in parsed+ if event.event == "content_block_delta"+ ] == [1]+ assert [+ event.data["index"]+ for event in parsed+ if event.event == "content_block_stop"+ ] == [1]++ def test_thinking_suffix_after_closed_native_block_closes_once(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.ingest_native_event(+ SSEEvent(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "thinking", "thinking": ""},+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "thinking_delta", "thinking": "step one"},+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent(+ "content_block_stop",+ {"type": "content_block_stop", "index": 0},+ "",+ )+ )++ events = list(builder.append_thinking_suffix(" step two"))+ events.extend(builder.success_tail("end_turn"))+ parsed = parse_sse_text("".join(events))++ assert [+ event.data["index"]+ for event in parsed+ if event.event == "content_block_start"+ ] == [1]+ assert [+ event.data["index"]+ for event in parsed+ if event.event == "content_block_delta"+ ] == [1]+ assert [+ event.data["index"]+ for event in parsed+ if event.event == "content_block_stop"+ ] == [1]++ def test_text_suffix_appends_to_open_native_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.ingest_native_event(+ SSEEvent(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "text", "text": ""},+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "text_delta", "text": "hello wor"},+ },+ "",+ )+ )++ events = list(builder.append_text_suffix("ld"))+ events.extend(builder.success_tail("end_turn"))+ parsed = parse_sse_text("".join(events))++ assert [event.event for event in parsed] == [+ "content_block_delta",+ "content_block_stop",+ "message_delta",+ "message_stop",+ ]+ assert parsed[0].data["index"] == 0+ assert parsed[0].data["delta"]["text"] == "ld"+ assert parsed[1].data["index"] == 0++ def test_thinking_suffix_appends_to_open_native_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.ingest_native_event(+ SSEEvent(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {"type": "thinking", "thinking": ""},+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {"type": "thinking_delta", "thinking": "step o"},+ },+ "",+ )+ )++ events = list(builder.append_thinking_suffix("ne"))+ events.extend(builder.success_tail("end_turn"))+ parsed = parse_sse_text("".join(events))++ assert [event.event for event in parsed] == [+ "content_block_delta",+ "content_block_stop",+ "message_delta",+ "message_stop",+ ]+ assert parsed[0].data["index"] == 0+ assert parsed[0].data["delta"]["thinking"] == "ne"+ assert parsed[1].data["index"] == 0++ def test_suffix_helpers_noop_after_message_delta(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_text_block()+ builder.emit_text_delta("hello")+ builder.stop_text_block()+ builder.start_tool_block(0, "toolu_1", "Read")+ builder.emit_tool_delta(0, '{"path":"test.py"}')+ builder.stop_tool_block(0)+ builder.message_delta("tool_use", 10)++ assert list(builder.append_text_suffix(" world")) == []+ assert list(builder.append_thinking_suffix(" step")) == []+ assert list(builder.append_tool_repair_suffix(0, " ")) == []++ def test_suffix_helpers_noop_after_message_stop(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.message_stop()++ assert list(builder.append_text_suffix("late")) == []+ assert list(builder.append_thinking_suffix("late")) == []++ def test_final_stop_reason_uses_emitted_tool_content(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ assert builder.final_stop_reason("end_turn") == "end_turn"++ builder.content_block_start(0, "tool_use", id="toolu_1", name="Read")++ assert builder.final_stop_reason("end_turn") == "tool_use"+++class TestAnthropicStreamLedgerStateManagement:+ """Tests for ensure_thinking_block, ensure_text_block, close_all_blocks."""++ def test_ensure_thinking_block_closes_text_first(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_text_block()+ assert builder.blocks.text_started is True++ events = list(builder.ensure_thinking_block())+ # Should close text then start thinking+ assert len(events) == 2+ assert builder.blocks.text_started is False+ assert builder.blocks.thinking_started is True++ def test_ensure_thinking_block_noop_if_already_started(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_thinking_block()++ events = list(builder.ensure_thinking_block())+ assert events == []++ def test_ensure_text_block_closes_thinking_first(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_thinking_block()+ assert builder.blocks.thinking_started is True++ events = list(builder.ensure_text_block())+ # Should close thinking then start text+ assert len(events) == 2+ assert builder.blocks.thinking_started is False+ assert builder.blocks.text_started is True++ def test_ensure_text_block_noop_if_already_started(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_text_block()++ events = list(builder.ensure_text_block())+ assert events == []++ def test_append_text_suffix_closes_open_thinking_before_switching(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_thinking_block()++ events = list(builder.append_thinking_suffix(" step"))+ events.extend(builder.append_text_suffix(" answer"))+ parsed = parse_sse_text("".join(events))++ assert [event.event for event in parsed] == [+ "content_block_delta",+ "content_block_stop",+ "content_block_start",+ "content_block_delta",+ ]+ assert parsed[0].data["index"] == 0+ assert parsed[1].data["index"] == 0+ assert parsed[2].data["index"] == 1+ assert parsed[2].data["content_block"]["type"] == "text"+ assert parsed[3].data["index"] == 1+ assert builder.blocks.thinking_started is False+ assert builder.blocks.text_started is True++ def test_append_thinking_suffix_closes_open_text_before_switching(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_text_block()++ events = list(builder.append_text_suffix(" answer"))+ events.extend(builder.append_thinking_suffix(" step"))+ parsed = parse_sse_text("".join(events))++ assert [event.event for event in parsed] == [+ "content_block_delta",+ "content_block_stop",+ "content_block_start",+ "content_block_delta",+ ]+ assert parsed[0].data["index"] == 0+ assert parsed[1].data["index"] == 0+ assert parsed[2].data["index"] == 1+ assert parsed[2].data["content_block"]["type"] == "thinking"+ assert parsed[3].data["index"] == 1+ assert builder.blocks.text_started is False+ assert builder.blocks.thinking_started is True++ def test_close_content_blocks(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_thinking_block()+ builder.stop_thinking_block()+ builder.start_text_block()++ events = list(builder.close_content_blocks())+ # Should close text (thinking already stopped)+ assert len(events) == 1+ assert builder.blocks.text_started is False++ def test_close_all_blocks(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_thinking_block()+ builder.stop_thinking_block()+ builder.start_text_block()+ builder.start_tool_block(0, "t1", "Read")+ builder.start_tool_block(1, "t2", "Write")++ events = list(builder.close_all_blocks())+ # Close text + 2 tool blocks (thinking already stopped)+ assert len(events) == 3+ assert builder.blocks.text_started is False++ def test_close_all_blocks_empty(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ events = list(builder.close_all_blocks())+ assert events == []+++class TestAnthropicStreamLedgerError:+ """Tests for emit_error."""++ def test_emit_error(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ events = list(builder.emit_error("Something went wrong"))++ assert len(events) == 3 # start, delta, stop+ start_data = _parse_sse(events[0])+ assert start_data["content_block"]["type"] == "text"++ delta_data = _parse_sse(events[1])+ assert delta_data["delta"]["text"] == "Something went wrong"++ stop_data = _parse_sse(events[2])+ assert stop_data["type"] == "content_block_stop"++ def test_midstream_error_tail_without_terminal_state_emits_message_tail(self):+ builder = AnthropicStreamLedger("msg_1", "model")++ events = list(builder.midstream_error_tail("Something went wrong"))+ parsed = parse_sse_text("".join(events))++ assert [event.event for event in parsed] == [+ "content_block_start",+ "content_block_delta",+ "content_block_stop",+ "message_delta",+ "message_stop",+ ]+ assert parsed[1].data["delta"]["text"] == "Something went wrong"+ assert parsed[3].data["delta"]["stop_reason"] == "end_turn"++ def test_midstream_error_tail_after_message_delta_uses_top_level_error(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.ingest_native_event(+ SSEEvent(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "end_turn", "stop_sequence": None},+ "usage": {"input_tokens": 1, "output_tokens": 2},+ },+ "",+ )+ )++ events = list(builder.midstream_error_tail("Something went wrong"))+ parsed = parse_sse_text("".join(events))++ assert [event.event for event in parsed] == ["error", "message_stop"]+ assert parsed[0].data["error"]["message"] == "Something went wrong"++ def test_midstream_error_tail_after_message_stop_does_not_duplicate_terminal(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.ingest_native_event(+ SSEEvent(+ "message_delta",+ {+ "type": "message_delta",+ "delta": {"stop_reason": "end_turn", "stop_sequence": None},+ "usage": {"input_tokens": 1, "output_tokens": 2},+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent("message_stop", {"type": "message_stop"}, "")+ )++ events = list(builder.midstream_error_tail("Something went wrong"))+ parsed = parse_sse_text("".join(events))++ assert [event.event for event in parsed] == ["error"]+ assert parsed[0].data["error"]["message"] == "Something went wrong"+++class TestAnthropicStreamLedgerTokenEstimation:+ """Tests for estimate_output_tokens."""++ def test_estimate_with_text_only(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_text_block()+ builder.emit_text_delta("hello world")++ tokens = builder.estimate_output_tokens()+ assert tokens > 0++ def test_estimate_with_reasoning(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_thinking_block()+ builder.emit_thinking_delta("deep thought")+ builder.stop_thinking_block()+ builder.start_text_block()+ builder.emit_text_delta("answer")++ tokens = builder.estimate_output_tokens()+ assert tokens > 0++ def test_estimate_empty(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ tokens = builder.estimate_output_tokens()+ assert tokens == 0++ def test_estimate_without_tiktoken(self):+ """Fallback estimation when tiktoken is not available."""+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_text_block()+ builder.emit_text_delta("a" * 100) # 100 chars -> ~25 tokens++ with patch("core.anthropic.streaming.ledger.ENCODER", None):+ tokens = builder.estimate_output_tokens()+ assert tokens == 25 # 100 // 4++ def test_estimate_with_tools_no_tiktoken(self):+ """Fallback tool token estimation."""+ builder = AnthropicStreamLedger("msg_1", "model")+ builder.start_tool_block(0, "t1", "Read")+ builder.emit_tool_delta(0, '{"path":"test.py"}')++ with patch("core.anthropic.streaming.ledger.ENCODER", None):+ tokens = builder.estimate_output_tokens()+ # 1 tool * 50 = 50+ assert tokens == 50++ def test_estimate_counts_native_tool_payload(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ tool_name = "Read"+ tool_args = '{"path":"test.py"}'+ builder.ingest_native_event(+ SSEEvent(+ "content_block_start",+ {+ "type": "content_block_start",+ "index": 0,+ "content_block": {+ "type": "tool_use",+ "id": "toolu_native",+ "name": tool_name,+ "input": {},+ },+ },+ "",+ )+ )+ builder.ingest_native_event(+ SSEEvent(+ "content_block_delta",+ {+ "type": "content_block_delta",+ "index": 0,+ "delta": {+ "type": "input_json_delta",+ "partial_json": tool_args,+ },+ },+ "",+ )+ )++ with patch("core.anthropic.streaming.ledger.ENCODER", _CharEncoder()):+ tokens = builder.estimate_output_tokens()++ assert tokens == len(tool_name) + len(tool_args) + 15 + 4++ def test_estimate_does_not_double_count_openai_tool_content_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ tool_name = "Read"+ tool_args = '{"path":"test.py"}'+ builder.start_tool_block(0, "toolu_openai", tool_name)+ builder.emit_tool_delta(0, tool_args)++ with patch("core.anthropic.streaming.ledger.ENCODER", _CharEncoder()):+ tokens = builder.estimate_output_tokens()++ assert tokens == len(tool_name) + len(tool_args) + 15 + 4++ def test_estimate_ignores_unstarted_openai_tool_state(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ state = builder.blocks.ensure_tool_state(0)+ state.name = "Read"+ state.pre_start_args = '{"path":"test.py"}'++ with patch("core.anthropic.streaming.ledger.ENCODER", _CharEncoder()):+ tokens = builder.estimate_output_tokens()++ assert tokens == 0++ def test_estimate_heuristic_style_tool_content_block(self):+ builder = AnthropicStreamLedger("msg_1", "model")+ tool_name = "Read"+ tool_args = '{"path":"test.py"}'+ builder.content_block_start(0, "tool_use", id="toolu_heuristic", name=tool_name)+ builder.content_block_delta(0, "input_json_delta", tool_args)+ builder.content_block_stop(0)++ with patch("core.anthropic.streaming.ledger.ENCODER", _CharEncoder()):+ tokens = builder.estimate_output_tokens()++ assert tokens == len(tool_name) + len(tool_args) + 15 + 4diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.pyindex 36e93e25..14fe24c0 100644--- a/tests/providers/test_streaming_errors.py+++ b/tests/providers/test_streaming_errors.py@@ -13,10 +13,20 @@ from core.anthropic.stream_contracts import (assert_anthropic_stream_contract,parse_sse_text,)+from core.anthropic.streaming import (+ MIDSTREAM_RECOVERY_ATTEMPTS,+ AnthropicStreamLedger,+ TruncatedProviderStreamError,+ make_text_recovery_body,+)from providers.base import ProviderConfigfrom providers.nvidia_nim import NvidiaNimProviderfrom providers.transports.openai_chat.recovery import OpenAIChatRecovery-from providers.transports.openai_chat.tool_calls import OpenAIToolCallAssembler+from providers.transports.openai_chat.tool_calls import (+ OpenAIToolCallAssembler,+ has_committed_sse_output,+ iter_heuristic_tool_use_sse,+)from tests.provider_request_mocks import make_openai_compat_stream_request@@ -37,6 +47,17 @@ class AsyncStreamMock:raise self._error+class ClosableAsyncStreamMock(AsyncStreamMock):+ """Async stream mock that records cleanup."""++ def __init__(self, chunks, error=None):+ super().__init__(chunks, error=error)+ self.closed = False++ async def aclose(self):+ self.closed = True++def _make_provider():"""Create a provider instance for testing."""config = ProviderConfig(@@ -180,6 +201,9 @@ class TestStreamingExceptionHandling:assert "message_start" in event_textassert "API failed" in event_textassert "message_stop" in event_text+ parsed = parse_sse_text(event_text)+ assert parsed[0].event == "message_start"+ assert sum(event.event == "message_start" for event in parsed) == 1_assert_no_content_deltas_after_error_text(events, "API failed")@pytest.mark.asyncio@@ -635,6 +659,51 @@ class TestStreamingExceptionHandling:)assert not any(event.event == "error" for event in parsed)+ @pytest.mark.asyncio+ @pytest.mark.parametrize("finish_reason", ["tool_calls", "stop"])+ async def test_heuristic_only_tool_stream_does_not_emit_fallback_text(+ self, finish_reason+ ):+ """Text-parsed tool calls count as emitted tool output when finalizing."""+ provider = _make_provider()+ request = _make_request()+ heuristic_tool = (+ "● <function=Read><parameter=path>test.py</parameter>"+ "<parameter=limit>10</parameter>"+ )+ stream_mock = AsyncStreamMock(+ [+ _make_chunk(content=heuristic_tool),+ _make_chunk(finish_reason=finish_reason),+ ]+ )++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream_mock,+ ):+ events = await _collect_stream(provider, request)++ parsed = parse_sse_text("".join(events))+ assert any(+ event.event == "content_block_start"+ and event.data.get("content_block", {}).get("type") == "tool_use"+ for event in parsed+ )+ assert not any(+ event.event == "content_block_delta"+ and event.data.get("delta", {}).get("type") == "text_delta"+ and event.data.get("delta", {}).get("text") == " "+ for event in parsed+ )+ assert any(+ event.event == "message_delta"+ and event.data.get("delta", {}).get("stop_reason") == "tool_use"+ for event in parsed+ )+@pytest.mark.asyncioasync def test_precommit_openai_holdback_retries_without_leaking_partial(self):"""A retryable early cutoff before holdback commit is retried invisibly."""@@ -663,7 +732,10 @@ class TestStreamingExceptionHandling:assert mock_create.await_count == 2assert "hidden" not in event_textassert "visible" in event_text- assert parse_sse_text(event_text)[-1].event == "message_stop"+ parsed = parse_sse_text(event_text)+ assert parsed[0].event == "message_start"+ assert sum(event.event == "message_start" for event in parsed) == 1+ assert parsed[-1].event == "message_stop"@pytest.mark.asyncioasync def test_clean_eof_after_text_continues_with_overlap_trim(self):@@ -703,6 +775,187 @@ class TestStreamingExceptionHandling:)assert not any(event.event == "error" for event in parsed)+ @pytest.mark.asyncio+ async def test_recovery_collect_text_requires_finish_reason(self):+ """Recovery collectors reject truncated OpenAI-chat continuation streams."""+ streams = [+ ClosableAsyncStreamMock([_make_chunk(content=f"world {index}")])+ for index in range(MIDSTREAM_RECOVERY_ATTEMPTS)+ ]+ create_stream = AsyncMock(side_effect=[(stream, {}) for stream in streams])+ recovery = OpenAIChatRecovery(+ provider_name="NIM",+ create_stream=create_stream,+ )++ with pytest.raises(TruncatedProviderStreamError):+ await recovery.collect_text({"messages": []})++ assert create_stream.await_count == MIDSTREAM_RECOVERY_ATTEMPTS+ assert all(stream.closed for stream in streams)++ @pytest.mark.asyncio+ async def test_recovery_collect_text_closes_retryable_failed_streams(self):+ """Recovery collectors close failed stream attempts before retrying."""+ streams = [+ ClosableAsyncStreamMock(+ [_make_chunk(content=f"partial {index}")],+ error=TimeoutError("recovery cutoff"),+ )+ for index in range(MIDSTREAM_RECOVERY_ATTEMPTS)+ ]+ create_stream = AsyncMock(side_effect=[(stream, {}) for stream in streams])+ recovery = OpenAIChatRecovery(+ provider_name="NIM",+ create_stream=create_stream,+ )++ with pytest.raises(TimeoutError):+ await recovery.collect_text({"messages": []})++ assert create_stream.await_count == MIDSTREAM_RECOVERY_ATTEMPTS+ assert all(stream.closed for stream in streams)++ @pytest.mark.asyncio+ async def test_recovery_collect_text_accepts_finish_reason(self):+ """Recovery collectors return text only after the upstream terminal marker."""+ stream = ClosableAsyncStreamMock(+ [+ _make_chunk(content="world"),+ _make_chunk(finish_reason="stop"),+ ]+ )+ create_stream = AsyncMock(+ return_value=(+ stream,+ {},+ )+ )+ recovery = OpenAIChatRecovery(+ provider_name="NIM",+ create_stream=create_stream,+ )++ assert await recovery.collect_text({"messages": []}) == ("world", "")+ assert stream.closed is True++ def test_text_recovery_body_preserves_thinking_context(self):+ """Continuation prompts include emitted thinking without provider-specific fields."""+ body = {+ "messages": [{"role": "user", "content": "hello"}],+ "tools": [{"name": "Read"}],+ "tool_choice": {"type": "auto"},+ }++ recovery_body = make_text_recovery_body(+ body,+ partial_text="visible answer",+ partial_thinking="hidden reasoning",+ )++ assert "tools" not in recovery_body+ assert "tool_choice" not in recovery_body+ assert recovery_body["messages"][-2] == {+ "role": "assistant",+ "content": "visible answer",+ }+ recovery_prompt = recovery_body["messages"][-1]+ assert recovery_prompt["role"] == "user"+ assert "hidden reasoning" in recovery_prompt["content"]+ assert "reasoning_content" not in recovery_prompt++ @pytest.mark.asyncio+ async def test_openai_text_recovery_passes_thinking_context(self):+ """OpenAI-chat recovery call sites seed emitted thinking in the prompt."""+ recovery = OpenAIChatRecovery(+ provider_name="NIM",+ create_stream=AsyncMock(),+ )+ ledger = AnthropicStreamLedger("msg_recovery", "model")+ ledger.start_thinking_block()+ ledger.emit_thinking_delta("hidden reasoning")+ list(ledger.ensure_text_block())+ ledger.emit_text_delta("visible answer")++ with patch.object(+ recovery,+ "collect_text",+ new_callable=AsyncMock,+ return_value=("visible answer done", "hidden reasoning more"),+ ) as mock_collect:+ events = await recovery.events(+ body={"messages": [{"role": "user", "content": "hello"}]},+ ledger=ledger,+ request=_make_request(),+ request_id="req_recovery",+ error=TimeoutError("cutoff"),+ tool_argument_alias_buffers={},+ )++ assert events is not None+ assert mock_collect.await_args is not None+ recovery_body = mock_collect.await_args.args[0]+ assert "hidden reasoning" in recovery_body["messages"][-1]["content"]++ @pytest.mark.asyncio+ async def test_primary_stream_closes_when_iteration_fails(self):+ """OpenAI-chat main streams close after iterator failures."""+ provider = _make_provider()+ request = _make_request()+ stream = ClosableAsyncStreamMock(+ [_make_chunk(content="partial")],+ error=ValueError("provider stream failed"),+ )++ with patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=stream,+ ):+ events = await _collect_stream(provider, request)++ assert stream.closed is True+ assert "provider stream failed" in "".join(events).lower()++ @pytest.mark.asyncio+ async def test_truncated_recovery_stream_falls_back_to_error_tail(self):+ """Partial recovery bytes are not converted into a successful response."""+ provider = _make_provider()+ request = _make_request()+ original_text = "hello wor" + ("x" * 70_000)+ original_stream = AsyncStreamMock([_make_chunk(content=original_text)])++ with (+ patch.object(+ provider._client.chat.completions,+ "create",+ new_callable=AsyncMock,+ return_value=original_stream,+ ) as mock_create,+ patch.object(+ OpenAIChatRecovery,+ "collect_text",+ new_callable=AsyncMock,+ side_effect=TruncatedProviderStreamError(+ "Recovery stream ended without finish_reason."+ ),+ ) as mock_collect,+ ):+ events = await _collect_stream(provider, request)++ event_text = "".join(events)+ assert mock_create.await_count == 1+ assert mock_collect.await_count == 1+ assert original_text in event_text+ assert "world" not in event_text+ assert "Provider stream ended without finish_reason." in event_text+ assert not any(+ event.event == "content_block_delta"+ and event.data.get("delta", {}).get("text") == "ld"+ for event in parse_sse_text(event_text)+ )+@pytest.mark.asyncioasync def test_incomplete_tool_call_repair_appends_schema_valid_suffix(self):"""A truncated tool JSON prefix is repaired append-only before tool_use tail."""@@ -786,12 +1039,33 @@ class TestStreamingExceptionHandling:class TestProcessToolCall:"""Tests for OpenAI tool-call assembly."""+ def test_heuristic_tool_use_sse_marks_committed_tool_output(self):+ """Heuristic tool blocks are emitted content, even without OpenAI tool state."""+ from core.anthropic import AnthropicStreamLedger++ ledger = AnthropicStreamLedger("msg_test", "test-model")+ events = list(+ iter_heuristic_tool_use_sse(+ ledger,+ {+ "id": "toolu_heuristic",+ "name": "Read",+ "input": {"path": "test.py"},+ },+ )+ )++ event_text = "".join(events)+ assert "tool_use" in event_text+ assert ledger.has_emitted_tool_block()+ assert has_committed_sse_output(ledger)+def test_tool_call_with_id(self):"""Tool call with id starts a tool block."""provider = _make_provider()- from core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc = {"index": 0,"id": "call_123",@@ -806,9 +1080,9 @@ class TestProcessToolCall:def 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 core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")t1 = {"index": 0,"id": "call_split",@@ -835,9 +1109,9 @@ class TestProcessToolCall:def test_tool_call_arguments_buffered_until_name(self):"""Argument deltas before tool name are emitted after the block starts."""provider = _make_provider()- from core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")t1 = {"index": 0,"id": "call_buf",@@ -859,9 +1133,9 @@ class TestProcessToolCall:def test_tool_call_without_id_generates_uuid(self):"""Tool call without id generates a uuid-based id."""provider = _make_provider()- from core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc = {"index": 0,"id": None,@@ -874,9 +1148,9 @@ class TestProcessToolCall:def test_task_tool_forces_background_false(self):"""Task tool with run_in_background=true is forced to false."""provider = _make_provider()- from core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")args = json.dumps({"run_in_background": True, "prompt": "test"})tc = {"index": 0,@@ -891,9 +1165,9 @@ class TestProcessToolCall: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 core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc1 = {"index": 0,"id": "call_task_chunked",@@ -916,9 +1190,9 @@ class TestProcessToolCall: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 core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc = {"index": 0,"id": "call_task2",@@ -936,9 +1210,9 @@ class TestProcessToolCall:def test_negative_tool_index_fallback(self):"""tc_index < 0 uses len(tool_indices) as fallback."""provider = _make_provider()- from core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc = {"index": -1,"id": "call_neg",@@ -951,9 +1225,9 @@ 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 core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc = {"index": None,"id": "call_none",@@ -968,9 +1242,9 @@ class TestProcessToolCall:def test_tool_args_emitted_as_delta(self):"""Arguments are emitted as input_json_delta events."""provider = _make_provider()- from core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc = {"index": 0,"id": "call_args",@@ -1089,9 +1363,9 @@ 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 core.anthropic import SSEBuilder+ from core.anthropic import AnthropicStreamLedger- sse = SSEBuilder("msg_test", "test-model")+ sse = AnthropicStreamLedger("msg_test", "test-model")tc1 = {"index": 0,"id": "call_malformed",diff --git a/tests/providers/test_subagent_interception.py b/tests/providers/test_subagent_interception.pyindex 86cb0ed2..eefbe7f4 100644--- a/tests/providers/test_subagent_interception.py+++ b/tests/providers/test_subagent_interception.py@@ -4,7 +4,7 @@ from unittest.mock import MagicMockimport pytestfrom config.nim import NimSettings-from core.anthropic import ContentBlockManager+from core.anthropic import StreamBlockLedgerfrom providers.base import ProviderConfigfrom providers.nvidia_nim import NvidiaNimProviderfrom providers.transports.openai_chat.tool_calls import OpenAIToolCallAssembler@@ -16,12 +16,12 @@ async def test_task_tool_interception():config = ProviderConfig(api_key="test")provider = NvidiaNimProvider(config, nim_settings=NimSettings())- # Mock request and sse builder with real ContentBlockManager+ # Mock request and stream ledger with real StreamBlockLedgerrequest = MagicMock()request.model = "test-model"sse = MagicMock()- sse.blocks = ContentBlockManager()+ sse.blocks = StreamBlockLedger()# Tool call data (Task tool)tc = {diff --git a/tests/providers/test_wafer.py b/tests/providers/test_wafer.pyindex a59a5be1..6fa43358 100644--- a/tests/providers/test_wafer.py+++ b/tests/providers/test_wafer.py@@ -9,6 +9,7 @@ import pytestfrom api.models.anthropic import Message, MessagesRequest, Toolfrom config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS+from core.anthropic.stream_contracts import parse_sse_textfrom providers.base import ProviderConfigfrom providers.wafer import WAFER_DEFAULT_BASE, WaferProviderfrom tests.stream_contract import assert_canonical_stream_error_envelope@@ -288,13 +289,9 @@ async def test_stream_uses_post_messages_path(wafer_provider):):events = [event async for event in wafer_provider.stream_response(request)]- assert events == [- "event: message_start\n",- 'data: {"type":"message_start"}\n',- "\n",- "event: message_stop\n",- 'data: {"type":"message_stop"}\n',- "\n",+ assert [event.event for event in parse_sse_text("".join(events))] == [+ "message_start",+ "message_stop",]assert response.is_closedassert mock_build.call_args.args[:2] == ("POST", "/messages")