Skip to content

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

Python

Refactor provider stream engine (#883)

Ali Khokhar60e5797ce426
diff --git a/ARCHITECTURE.md b/ARCHITECTURE.md
index 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.py
index 7f56d931..eb0cacd4 100644
--- a/api/request_pipeline.py
+++ b/api/request_pipeline.py
@@ -15,7 +15,7 @@ from loguru import logger
from config.provider_catalog import PROVIDER_CATALOG
from config.settings import Settings
from 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_HEADERS
from core.openai_responses import OpenAIResponsesAdapter
from core.trace import api_messages_request_snapshot, trace_event, traced_async_stream
from providers.base import BaseProvider
diff --git a/api/web_tools/streaming.py b/api/web_tools/streaming.py
index 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_event
from . import outbound
from .constants import _MAX_FETCH_CHARS
diff --git a/core/anthropic/__init__.py b/core/anthropic/__init__.py
index 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_policy
from .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, ThinkTagParser
from .tokens import get_token_count
from .tools import HeuristicToolParser
from .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.py
deleted file mode 100644
index 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 None
diff --git a/core/anthropic/provider_stream_error.py b/core/anthropic/provider_stream_error.py
index 5534c501..76f2f8b7 100644
--- a/core/anthropic/provider_stream_error.py
+++ b/core/anthropic/provider_stream_error.py
@@ -6,7 +6,7 @@ import uuid
from collections.abc import Iterator
from typing import Any
-from core.anthropic.sse import SSEBuilder
+from core.anthropic.streaming import AnthropicStreamLedger
def 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.py
deleted file mode 100644
index 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_tokens
diff --git a/core/anthropic/stream_recovery_session.py b/core/anthropic/stream_recovery_session.py
deleted file mode 100644
index 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__.py
new file mode 100644
index 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.py
new file mode 100644
index 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 event
diff --git a/core/anthropic/streaming/ledger.py b/core/anthropic/streaming/ledger.py
new file mode 100644
index 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"] = False
diff --git a/core/anthropic/streaming/lifecycle.py b/core/anthropic/streaming/lifecycle.py
new file mode 100644
index 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.py
similarity index 65%
rename from core/anthropic/stream_recovery.py
rename to core/anthropic/streaming/recovery.py
index 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 time
from collections.abc import Callable
from copy import deepcopy
from dataclasses import dataclass
+from enum import StrEnum
from typing import Any
import httpx
@@ -14,6 +15,8 @@ import jsonschema
import openai
from loguru import logger
+from core.trace import trace_event
+
EARLY_TRANSPARENT_TOTAL_ATTEMPTS = 5
EARLY_TRANSPARENT_MAX_RETRIES = EARLY_TRANSPARENT_TOTAL_ATTEMPTS - 1
MIDSTREAM_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 = False
def 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 events
def discard(self) -> None:
- """Drop held events without committing them downstream."""
self._events = []
self._bytes = 0
self._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 + suffix
parsed = 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 candidate
return 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"] = True
messages = _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"] = messages
return 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.py
index 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 inspect
from typing import Any
import httpx
@@ -16,16 +15,6 @@ from providers.error_mapping import attach_provider_error_body
from 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.py
index 610ee1a2..1e2a139a 100644
--- a/providers/transports/anthropic_messages/recovery.py
+++ b/providers/transports/anthropic_messages/recovery.py
@@ -7,21 +7,21 @@ from typing import Any
import httpx
-from core.anthropic.emitted_sse_tracker import EmittedNativeSseTracker
from 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_aclose
IterStreamChunks = Callable[..., AsyncIterator[str]]
@@ -68,7 +68,18 @@ class AnthropicMessagesRecovery:
]
text_parts: list[str] = []
thinking_parts: list[str] = []
+ terminal_seen = False
for 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 None
schemas = 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_id
and block.name
@@ -127,7 +142,7 @@ class AnthropicMessagesRecovery:
):
continue
schema = 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 None
repair_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 None
events = 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_reasoning
if 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.py
index 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 Any
import 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_aclose
from .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 = 0
chunk_bytes = 0
@@ -125,12 +110,15 @@ class AnthropicMessagesStreamRunner:
):
chunk_count += 1
chunk_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 = True
yield event
return
except 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 = None
state = self._transport._new_stream_state(
self._request, thinking_enabled=thinking_enabled
)
- emitted_tracker = EmittedNativeSseTracker()
+ ledger = self._new_ledger()
sent_any_event = False
continue
- 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 = None
if recovery_events is not None:
- for event in recovery_session.flush_uncommitted(decision):
+ for event in recovery.flush_uncommitted(decision):
sent_any_event = True
yield event
for 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 = True
yield 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 event
else:
- 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.py
index 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 AnthropicMessagesStreamAdapter
StreamChunkMode = 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 event
diff --git a/providers/transports/http.py b/providers/transports/http.py
new file mode 100644
index 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 result
diff --git a/providers/transports/openai_chat/recovery.py b/providers/transports/openai_chat/recovery.py
index 8f7ec47b..90987277 100644
--- a/providers/transports/openai_chat/recovery.py
+++ b/providers/transports/openai_chat/recovery.py
@@ -5,20 +5,22 @@ from __future__ import annotations
from collections.abc import Awaitable, Callable, Iterator
from 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_states
CreateStream = 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 = None
for attempt in range(MIDSTREAM_RECOVERY_ATTEMPTS):
+ stream: Any | None = None
try:
stream, _ = await self._create_stream(body)
text_parts: list[str] = []
thinking_parts: list[str] = []
+ terminal_seen = False
async for chunk in stream:
if not getattr(chunk, "choices", None):
continue
choice = chunk.choices[0]
+ if choice.finish_reason is not None:
+ terminal_seen = True
delta = choice.delta
if 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_error
return "", ""
@@ -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_reasoning
if 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_prefix
if 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_prefix
if yield_text:
- events.append(sse.emit_tool_delta(tool_index, yield_text))
+ events.append(ledger.emit_tool_delta(tool_index, yield_text))
continue
schema = 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 None
return events
diff --git a/providers/transports/openai_chat/stream.py b/providers/transports/openai_chat/stream.py
index 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 logger
from 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_event
from providers.error_mapping import map_error
+from providers.transports.http import maybe_await_aclose
from .recovery import OpenAIChatRecovery
from .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_name
req_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 = None
stream_opened = False
try:
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 event
for 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:
continue
for event in hold_events(
- sse.ensure_thinking_block()
+ ledger.ensure_thinking_block()
):
yield event
for event in hold_event(
- sse.emit_thinking_delta(part.content)
+ ledger.emit_thinking_delta(part.content)
):
yield event
else:
@@ -163,23 +168,23 @@ class OpenAIChatStreamRunner:
if filtered_text:
for event in hold_events(
- sse.ensure_text_block()
+ ledger.ensure_text_block()
):
yield event
for event in hold_event(
- sse.emit_text_delta(filtered_text)
+ ledger.emit_text_delta(filtered_text)
):
yield event
for 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_event
if delta.tool_calls:
- for event in hold_events(sse.close_content_blocks()):
+ for event in hold_events(ledger.close_content_blocks()):
yield event
for tc in delta.tool_calls:
extra_content = tool_call_extra_content(tc)
@@ -195,7 +200,7 @@ class OpenAIChatStreamRunner:
tc_info["extra_content"] = extra_content
for 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:
raise
except 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 = None
if recovery_events is not None:
- for event in recovery_session.flush_uncommitted(decision):
+ for event in recovery.flush_uncommitted(decision):
yield event
for 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 event
elif 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 event
return
+ 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 = None
else:
- 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 event
if 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 event
for 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 event
for 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 event
completion = (
@@ -347,7 +357,7 @@ class OpenAIChatStreamRunner:
if isinstance(completion, int):
output_tokens = completion
else:
- 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_tokens
if 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.py
index 53dbb721..e31aae9c 100644
--- a/providers/transports/openai_chat/tool_calls.py
+++ b/providers/transports/openai_chat/tool_calls.py
@@ -7,9 +7,8 @@ import uuid
from collections.abc import Callable, Iterator
from 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 0
if 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_content
if 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_args
state.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:
return
if 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 += arguments
return
yield 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":
continue
aliases = tool_argument_aliases.get(state.name, {})
if not aliases:
continue
restored = 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:
return
if 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))
return
aliases = (
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)
return
buffered_args = tool_argument_alias_buffers.get(tc_index, "") + args
@@ -253,9 +244,9 @@ class OpenAIToolCallAssembler:
tool_argument_alias_buffers[tc_index] = buffered_args
return
tool_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.py
index 978586dc..e7cba810 100644
--- a/providers/transports/openai_chat/transport.py
+++ b/providers/transports/openai_chat/transport.py
@@ -9,7 +9,7 @@ from typing import Any
import httpx
from openai import AsyncOpenAI
-from core.anthropic import SSEBuilder
+from core.anthropic.streaming import AnthropicStreamLedger
from providers.base import BaseProvider, ProviderConfig
from 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_ids
from providers.rate_limit import GlobalRateLimiter
-from .stream import OpenAIChatStreamRunner
+from .stream import OpenAIChatStreamAdapter
class 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 event
diff --git a/smoke/capabilities.py b/smoke/capabilities.py
index 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.py
index 741cb224..b69e3b49 100644
--- a/tests/api/test_openai_responses.py
+++ b/tests/api/test_openai_responses.py
@@ -7,8 +7,8 @@ import pytest
from fastapi.testclient import TestClient
from api.app import create_app
-from core.anthropic.sse import format_sse_event
from core.anthropic.stream_contracts import parse_sse_text
+from core.anthropic.streaming import format_sse_event
class FakeProvider:
diff --git a/tests/api/test_safe_logging.py b/tests/api/test_safe_logging.py
index 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_mod
from api.models.anthropic import Message, MessagesRequest
from api.request_pipeline import ApiRequestPipeline
from config.settings import Settings
-from core.anthropic.sse import SSEBuilder
+from core.anthropic import AnthropicStreamLedger
def 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 == 1
message = str(mock_debug.call_args)
diff --git a/tests/contracts/test_import_boundaries.py b/tests/contracts/test_import_boundaries.py
index 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.py
index 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 API
integration tests.
"""
@@ -7,8 +7,12 @@ from __future__ import annotations
from 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_event
def 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.py
index 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_RETRY
assert decision.early_retry_attempt == 1
assert session.early_retries == 1
assert 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_RETRY
assert decision.early_retry_attempt == attempt
decision = 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_ERROR
assert session.early_retries == EARLY_TRANSPARENT_MAX_RETRIES
def 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_RECOVERY
assert decision.retryable
assert decision.committed
assert 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() -> Non
complete_tool_salvageable=True,
)
- assert decision.action == StreamFailureAction.MIDSTREAM_RECOVERY
+ assert decision.action == RecoveryFailureAction.MIDSTREAM_RECOVERY
assert not decision.committed
assert decision.has_buffered
assert 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_ERROR
assert not decision.retryable
assert session.early_retries == 0
diff --git a/tests/core/openai_responses/test_sse.py b/tests/core/openai_responses/test_sse.py
index 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 Any
import pytest
-from core.anthropic.sse import format_sse_event
from core.anthropic.stream_contracts import parse_sse_text
+from core.anthropic.streaming import format_sse_event
from core.openai_responses import OpenAIResponsesAdapter
_ADAPTER = OpenAIResponsesAdapter()
diff --git a/tests/messaging/test_stream_transcript_contract.py b/tests/messaging/test_stream_transcript_contract.py
index 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 AnthropicStreamLedger
from core.anthropic.stream_contracts import (
assert_anthropic_stream_contract,
has_tool_use,
@@ -13,7 +13,7 @@ from messaging.transcript import RenderCtx, TranscriptBuffer
def 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.py
index d279a946..28ba76ef 100644
--- a/tests/providers/test_anthropic_messages.py
+++ b/tests/providers/test_anthropic_messages.py
@@ -7,8 +7,13 @@ import httpx
import pytest
from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
-from core.anthropic.sse import format_sse_event
from 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 ProviderConfig
from providers.transports.anthropic_messages import AnthropicMessagesTransport
from 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_closed
assert 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.asyncio
async 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.asyncio
async 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.py
index 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, patch
import httpx
import pytest
+from core.anthropic.stream_contracts import event_names, parse_sse_text
from providers.base import ProviderConfig
from providers.rate_limit import GlobalRateLimiter
from 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.fixture
def 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"] == 2
assert too_many.is_closed
assert 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"] == 2
assert bad.is_closed
assert 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.py
index 1fe8db69..a2d8e7b2 100644
--- a/tests/providers/test_llamacpp.py
+++ b/tests/providers/test_llamacpp.py
@@ -6,6 +6,7 @@ import httpx
import pytest
from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from core.anthropic.stream_contracts import parse_sse_text
from providers.base import ProviderConfig
from providers.llamacpp import LlamaCppProvider
from 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 format
assert 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.asyncio
diff --git a/tests/providers/test_lmstudio.py b/tests/providers/test_lmstudio.py
index 7c2d2535..6749bb16 100644
--- a/tests/providers/test_lmstudio.py
+++ b/tests/providers/test_lmstudio.py
@@ -6,6 +6,7 @@ import httpx
import pytest
from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from core.anthropic.stream_contracts import parse_sse_text
from providers.base import ProviderConfig
from providers.lmstudio import LMStudioProvider
from 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 format
assert 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.asyncio
diff --git a/tests/providers/test_ollama.py b/tests/providers/test_ollama.py
index 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, patch
import httpx
import pytest
+from core.anthropic.stream_contracts import parse_sse_text
from providers.base import ProviderConfig
from providers.ollama import OLLAMA_DEFAULT_BASE, OllamaProvider
from 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 True
assert "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.asyncio
diff --git a/tests/providers/test_sse_builder.py b/tests/providers/test_sse_builder.py
deleted file mode 100644
index 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 == 50
diff --git a/tests/providers/test_stream_ledger.py b/tests/providers/test_stream_ledger.py
new file mode 100644
index 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 + 4
diff --git a/tests/providers/test_streaming_errors.py b/tests/providers/test_streaming_errors.py
index 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 ProviderConfig
from providers.nvidia_nim import NvidiaNimProvider
from 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_text
assert "API failed" in event_text
assert "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.asyncio
async 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 == 2
assert "hidden" not in event_text
assert "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.asyncio
async 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.asyncio
async 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.py
index 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 MagicMock
import pytest
from config.nim import NimSettings
-from core.anthropic import ContentBlockManager
+from core.anthropic import StreamBlockLedger
from providers.base import ProviderConfig
from providers.nvidia_nim import NvidiaNimProvider
from 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 StreamBlockLedger
request = 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.py
index a59a5be1..6fa43358 100644
--- a/tests/providers/test_wafer.py
+++ b/tests/providers/test_wafer.py
@@ -9,6 +9,7 @@ import pytest
from api.models.anthropic import Message, MessagesRequest, Tool
from config.constants import ANTHROPIC_DEFAULT_MAX_OUTPUT_TOKENS
+from core.anthropic.stream_contracts import parse_sse_text
from providers.base import ProviderConfig
from providers.wafer import WAFER_DEFAULT_BASE, WaferProvider
from 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_closed
assert mock_build.call_args.args[:2] == ("POST", "/messages")