agentengine-sdk-python 0.8.4__py3-none-any.whl → 0.8.6__py3-none-any.whl

ksadk/studio/model_usage.py

@@ -0,0 +1,109 @@
+"""Project provider usage without inventing or coercing reported counters."""
+
+from collections.abc import Mapping
+from dataclasses import dataclass, field
+from typing import Literal
+
+from ksadk.studio.contracts import Usage
+from ksadk.studio.errors import StudioError
+
+Wire = Literal["chat", "responses", "anthropic"]
+
+
+def _invalid() -> StudioError:
+    # A protocol error is not a transient transport error. No provider values
+    # or exception body belong in the public failure or a retry diagnostic.
+    return StudioError("MODEL_RESPONSE_INVALID", "Invalid model usage report", status_code=422)
+
+
+def _counter(value: object) -> int:
+    if type(value) is not int or value < 0:
+        raise _invalid()
+    return value
+
+
+def _fields(value: object, wire_api: Wire) -> dict[str, int]:
+    if value is None:
+        return {}
+    if not isinstance(value, Mapping):
+        raise _invalid()
+    input_key, output_key = (
+        ("prompt_tokens", "completion_tokens") if wire_api == "chat"
+        else ("input_tokens", "output_tokens")
+    )
+    names = [input_key, output_key]
+    if wire_api == "anthropic":
+        names.extend(("cache_read_input_tokens", "cache_creation_input_tokens"))
+    else:
+        names.append("total_tokens")
+    counters = {
+        name: _counter(value[name]) for name in names
+        if name in value and not (
+            wire_api == "anthropic" and name.startswith("cache_") and value[name] is None
+        )
+    }
+    if wire_api != "anthropic":
+        details = (
+            ("prompt_tokens_details", "completion_tokens_details") if wire_api == "chat"
+            else ("input_tokens_details", "output_tokens_details")
+        )
+        for envelope, name in zip(details, ("cached_tokens", "reasoning_tokens"), strict=True):
+            subdivision = value.get(envelope)
+            if subdivision is None:
+                continue
+            if not isinstance(subdivision, Mapping):
+                raise _invalid()
+            if name in subdivision:
+                counters[name] = _counter(subdivision[name])
+    return counters
+
+
+def _report(counters: dict[str, int], wire_api: Wire) -> Usage | None:
+    input_key, output_key = (
+        ("prompt_tokens", "completion_tokens") if wire_api == "chat"
+        else ("input_tokens", "output_tokens")
+    )
+    if input_key not in counters or output_key not in counters:
+        # The Studio DTO has integer placeholders for unknown usage. A partial
+        # provider envelope must never assert their defaults were reported.
+        return None
+    input_tokens, output_tokens = counters[input_key], counters[output_key]
+    if wire_api == "anthropic":
+        # Messages reports non-cached input separately from cache reads/writes.
+        # Canonical input is inclusive; only cache reads map to cached_input.
+        cached = counters.get("cache_read_input_tokens", 0)
+        input_tokens += cached + counters.get("cache_creation_input_tokens", 0)
+        total_tokens = input_tokens + output_tokens
+    else:
+        cached = counters.get("cached_tokens", 0)
+        total_tokens = counters.get("total_tokens", input_tokens + output_tokens)
+    return Usage(
+        input_tokens=input_tokens, output_tokens=output_tokens, total_tokens=total_tokens,
+        cached_input_tokens=cached, reasoning_output_tokens=counters.get("reasoning_tokens", 0),
+        reported=True, source="model-provider",
+    )
+
+
+def provider_usage(value: object, *, wire_api: Wire) -> Usage | None:
+    """Unknown/partial stays absent; malformed supplied fields are rejected.
+
+    A complete report needs both genuine integer primary counters, including
+    an explicit pair of zeroes. Optional details follow each wire's meaning.
+    """
+    return _report(_fields(value, wire_api), wire_api)
+
+
+@dataclass
+class AnthropicUsageAccumulator:
+    """Request-local, right-biased merge of Messages' split usage reports."""
+
+    _counters: dict[str, int] = field(default_factory=dict)
+
+    def update(self, value: object) -> Usage | None:
+        # Missing fields leave known values intact; zero is a defined update.
+        # Validate before mutation, so a rejected update cannot erase evidence.
+        self._counters.update(_fields(value, "anthropic"))
+        return self.report()
+
+    def report(self) -> Usage | None:
+        return _report(self._counters, "anthropic")

ksadk/studio/model_wire_failure.py

@@ -0,0 +1,110 @@
+"""Host-owned failure facts, without provider messages or hidden retry policy."""
+
+from collections.abc import Mapping
+
+from ksadk._model_input import ProviderInputObservation
+from ksadk.studio.contracts import Usage
+from ksadk.studio.errors import StudioError
+from ksadk.studio.model_wire_identity import invalid_model_frame
+
+
+class ModelResponseError(StudioError):
+    """Private response accounting survives a public, safe decoder rejection."""
+
+    def __init__(self, error: StudioError, usage: Usage | None = None) -> None:
+        super().__init__(error.code, error.message, status_code=error.status_code,
+                         field=error.field, details=dict(error.details))
+        self._response_usage = usage.model_copy(deep=True) if usage is not None else None
+        self.headers = getattr(error, "headers", None)
+        self.provider_input: ProviderInputObservation | None = None
+
+
+def response_error_usage(error: Exception) -> Usage | None:
+    # Neither public details nor an arbitrary plugin's attribute grants billing.
+    if type(error) is ModelResponseError and error._response_usage is not None:
+        return error._response_usage.model_copy(deep=True)
+    return None
+
+
+_CODES = {
+    "context_length_exceeded": "MODEL_PROVIDER_CONTEXT_LENGTH",
+    "context_window_exceeded": "MODEL_PROVIDER_CONTEXT_LENGTH",
+    "model_context_exceeded": "MODEL_PROVIDER_CONTEXT_LENGTH",
+    "model_context_window_exceeded": "MODEL_PROVIDER_CONTEXT_LENGTH",
+    "invalid_api_key": "MODEL_PROVIDER_AUTHENTICATION",
+    "authentication_error": "MODEL_PROVIDER_AUTHENTICATION",
+    "permission_error": "MODEL_PROVIDER_PERMISSION",
+    "invalid_request_error": "MODEL_PROVIDER_INVALID_REQUEST",
+    "not_found_error": "MODEL_PROVIDER_NOT_FOUND",
+    "rate_limit_exceeded": "MODEL_PROVIDER_RATE_LIMIT",
+    "rate_limit_error": "MODEL_PROVIDER_RATE_LIMIT",
+    "overloaded_error": "MODEL_PROVIDER_UNAVAILABLE",
+    "server_error": "MODEL_PROVIDER_UNAVAILABLE",
+    "api_error": "MODEL_PROVIDER_UNAVAILABLE",
+    "service_unavailable_error": "MODEL_PROVIDER_UNAVAILABLE",
+    "server_is_overloaded": "MODEL_PROVIDER_UNAVAILABLE",
+    "timeout_error": "MODEL_PROVIDER_TIMEOUT",
+    "request_too_large": "MODEL_PROVIDER_INVALID_REQUEST",
+    "billing_error": "MODEL_PROVIDER_QUOTA_EXHAUSTED",
+    "insufficient_quota": "MODEL_PROVIDER_QUOTA_EXHAUSTED",
+    "credit_balance_exhausted": "MODEL_PROVIDER_QUOTA_EXHAUSTED",
+    "organization_spend_limit_exceeded": "MODEL_PROVIDER_QUOTA_EXHAUSTED",
+    "project_spend_limit_exceeded": "MODEL_PROVIDER_QUOTA_EXHAUSTED",
+    "organization_usage_limit_exceeded": "MODEL_PROVIDER_QUOTA_EXHAUSTED",
+}
+
+
+def provider_error(
+    payload: dict, *, wire_api: str, status: int = 200,
+    usage: Usage | None = None, headers: Mapping[str, str] | None = None,
+    provider_request_id: str = "",
+) -> ModelResponseError | None:
+    """Known structured codes precede HTTP; unknown 2xx errors remain terminal.
+
+    An error alongside a purported successful answer is a protocol conflict,
+    not a provider rejection that can authorize context recovery or retries.
+    """
+    error = payload.get("error")
+    failed = wire_api == "responses" and payload.get("status") == "failed"
+    if error is None and not failed and status < 400:
+        return None
+    if status < 400 and (
+        (wire_api == "chat" and (payload.get("choices") or payload.get("message")))
+        or (wire_api == "responses" and payload.get("status") == "completed")
+        or (wire_api == "anthropic" and (
+            payload.get("type") == "message" or "content" in payload or "stop_reason" in payload
+        ))
+    ):
+        raise invalid_model_frame()
+    if error is not None and not isinstance(error, dict):
+        if status < 400:
+            raise invalid_model_frame()
+        error = None
+    fields = error or {}
+    for field in ("code", "type"):
+        if fields.get(field) is not None and type(fields[field]) is not str:
+            if status < 400:
+                raise invalid_model_frame()
+            fields = {}
+            break
+    # Only mapped codes become public facts. Text, arbitrary keys and vendor
+    # numeric codes cannot select a policy or escape into diagnostics.
+    code = next((_CODES[fields[field]] for field in ("code", "type")
+                 if fields.get(field) in _CODES), None)
+    if code is None:
+        code = ("MODEL_RATE_LIMITED" if status == 429 else "MODEL_REQUEST_FAILED") \
+            if status >= 400 else "MODEL_PROVIDER_ERROR"
+    details = {"upstreamStatus": status}
+    if provider_request_id:
+        details["providerRequestId"] = provider_request_id
+    message = (
+        "所选生成模型当前限流，请稍后重试或切换模型 Profile"
+        if code == "MODEL_RATE_LIMITED" else "模型提供方拒绝本次请求"
+    )
+    error = StudioError(
+        code, message, status_code=429 if status == 429 else 502,
+        details=details,
+    )
+    error.headers = {name: headers[name] for name in ("retry-after", "retry-after-ms")
+                     if headers is not None and name in headers}
+    return ModelResponseError(error, usage)

ksadk/studio/model_wire_identity.py

@@ -0,0 +1,138 @@
+"""Validate supplied provider identity before projecting a model response."""
+
+from dataclasses import dataclass
+
+from ksadk._model_json import load_model_json
+from ksadk.studio.errors import StudioError
+
+
+def invalid_model_frame() -> StudioError:
+    return StudioError("MODEL_RESPONSE_INVALID", "Invalid model response frame", status_code=422)
+
+
+def decode_model_frame(raw: str | bytes) -> dict:
+    try:
+        value = load_model_json(raw)
+    except (ValueError, TypeError, RecursionError):
+        raise invalid_model_frame() from None
+    if not isinstance(value, dict):
+        raise invalid_model_frame()
+    return value
+
+
+def _object(value: object) -> dict:
+    if value is None:
+        return {}
+    if not isinstance(value, dict):
+        raise invalid_model_frame()
+    return value
+
+
+def _text(value: object) -> None:
+    if value is not None and type(value) is not str:
+        raise invalid_model_frame()
+
+
+def _message(value: object) -> None:
+    message = _object(value)
+    role = message.get("role")
+    if role is not None and role != "assistant":
+        raise invalid_model_frame()
+    for name in ("content", "reasoning", "reasoning_content", "refusal"):
+        _text(message.get(name))
+
+
+def chat_choices(payload: dict) -> list[dict]:
+    """Select canonical choice zero; alternate choices never enter its batch.
+
+    A proxy which omits indexes retains the existing first-choice convention.
+    Explicit indexes are genuine nonnegative integers and take precedence over
+    array order. Validate declared fields even on an unselected alternative.
+    """
+    choices = payload.get("choices")
+    if choices is None:
+        return []
+    if not isinstance(choices, list):
+        raise invalid_model_frame()
+    zero = None
+    unindexed = None
+    seen = set()
+    for choice in choices:
+        if not isinstance(choice, dict):
+            raise invalid_model_frame()
+        index = choice.get("index")
+        if index is not None:
+            if type(index) is not int or index < 0 or index in seen:
+                raise invalid_model_frame()
+            seen.add(index)
+            if index == 0:
+                zero = choice
+        elif unindexed is None:
+            unindexed = choice
+        _text(choice.get("finish_reason"))
+        _message(choice.get("delta"))
+        _message(choice.get("message"))
+    selected = zero if zero is not None else unindexed
+    return [] if selected is None else [selected]
+
+
+@dataclass
+class ModelWireIdentity:
+    """One physical HTTP attempt; no identity is inferred when it is absent.
+
+    Provider aliases need not equal the host's requested model name, but a
+    supplied model and response identity cannot change within the attempt.
+    This does not authenticate an upstream model or replace Build/Scope pins.
+    """
+
+    response_id: str | None = None
+    model: str | None = None
+
+    def _pin(self, field: str, value: object) -> None:
+        if value is None:
+            return
+        if type(value) is not str or not value.strip():
+            raise invalid_model_frame()
+        previous = getattr(self, field)
+        if previous is not None and previous != value:
+            raise invalid_model_frame()
+        setattr(self, field, value)
+
+    def accept(self, payload: dict, *, wire_api: str) -> None:
+        if not isinstance(payload, dict):
+            raise invalid_model_frame()
+        if wire_api == "chat":
+            self._pin("response_id", payload.get("id"))
+            self._pin("model", payload.get("model"))
+            _message(payload.get("message"))
+            return
+        kind = payload.get("type")
+        if type(kind) is not str or not kind.strip():
+            raise invalid_model_frame()
+        if wire_api == "responses":
+            response = _object(payload.get("response"))
+            self._pin("response_id", response.get("id"))
+            self._pin("response_id", payload.get("response_id"))
+            self._pin("model", response.get("model"))
+            if kind in {
+                "response.output_text.delta", "response.reasoning_summary_text.delta",
+                "response.reasoning_text.delta", "response.function_call_arguments.delta",
+                "response.refusal.delta",
+            }:
+                _text(payload.get("delta"))
+            return
+        if kind == "message_start":
+            message = _object(payload.get("message"))
+            role = message.get("role")
+            if role is not None and role != "assistant":
+                raise invalid_model_frame()
+            self._pin("response_id", message.get("id"))
+            self._pin("model", message.get("model"))
+        if kind == "content_block_delta":
+            delta = _object(payload.get("delta"))
+            for field in ("text", "thinking", "partial_json"):
+                _text(delta.get(field))
+        if kind == "message_delta":
+            delta = _object(payload.get("delta"))
+            for field in ("stop_reason", "stop_sequence"):
+                _text(delta.get(field))

ksadk/studio/model_wire_snapshot.py

@@ -0,0 +1,45 @@
+"""Terminal Responses bodies must agree with already observed stream facts."""
+
+from dataclasses import dataclass
+
+from ksadk.studio.model_buffered_wire import BufferedProjection, buffered_projection
+from ksadk.studio.model_responses_content import ResponsesContent
+from ksadk.studio.model_wire_identity import invalid_model_frame
+from ksadk.studio.model_wire_tools import ResponsesToolCalls, WireTool
+
+
+@dataclass(frozen=True)
+class ResponseSnapshot:
+    projection: BufferedProjection
+    text_tail: str = ""
+    reasoning_tail: str = ""
+    completed_calls: tuple[WireTool, ...] = ()
+
+
+def _tail(observed: str, snapshot: str) -> str:
+    if not snapshot.startswith(observed):
+        raise invalid_model_frame()
+    return snapshot[len(observed):]
+
+
+def reconcile_responses_snapshot(
+    payload: dict, *, status: str, tools: ResponsesToolCalls, text: str, reasoning: str,
+    content: ResponsesContent | None = None,
+) -> ResponseSnapshot | None:
+    if "status" in payload and payload["status"] != status:
+        raise invalid_model_frame()
+    if "output" not in payload and "output_text" not in payload:
+        return None  # Preserve compatibility with terminal metadata-only frames.
+    projection = buffered_projection({**payload, "status": status}, wire_api="responses")
+    if projection.finish == "content_filter":
+        return ResponseSnapshot(projection)
+    text_tail, reasoning_tail = (content.reconcile_output(payload["output"])
+                                 if content is not None and "output" in payload else ("", ""))
+    completed = ()
+    if "output" in payload and status == "completed":
+        completed = tools.reconcile_output(payload["output"] or [])
+    return ResponseSnapshot(
+        projection, text_tail + _tail(text + text_tail, projection.content),
+        reasoning_tail + _tail(reasoning + reasoning_tail, projection.reasoning)
+        if "output" in payload else "", completed,
+    )

ksadk/studio/model_wire_tools.py

@@ -0,0 +1,283 @@
+"""Request-local tool item lifecycles for Studio's native wire decoders."""
+
+import json
+from dataclasses import dataclass, field
+
+from ksadk.studio.model_wire_identity import invalid_model_frame
+
+
+def validate_client_item_type(kind: str, *, wire_api: str) -> None:
+    """Unsupported provider effects cannot be silently dropped as client prose."""
+    hosted = (
+        kind in {
+            "web_search_call", "web_search_preview_call", "file_search_call",
+            "code_interpreter_call", "computer_use_call", "image_generation_call",
+            "mcp_call", "local_shell_call",
+        } if wire_api == "responses"
+        else kind == "server_tool_use" or kind.endswith("_tool_result")
+    )
+    if hosted:
+        raise invalid_model_frame()
+
+
+def _object(value: object) -> dict:
+    if not isinstance(value, dict):
+        raise invalid_model_frame()
+    return value
+
+
+def _text(value: object) -> str:
+    if type(value) is not str:
+        raise invalid_model_frame()
+    return value
+
+
+def _identity(value: object) -> str:
+    result = _text(value)
+    if not result.strip():
+        raise invalid_model_frame()
+    return result
+
+
+def _index(event: dict, name: str, *, required: bool = False) -> int | None:
+    if name not in event:
+        if required:
+            raise invalid_model_frame()
+        return None
+    value = event[name]
+    if type(value) is not int or value < 0:
+        raise invalid_model_frame()
+    return value
+
+
+@dataclass
+class WireTool:
+    call_id: str = ""
+    name: str = ""
+    arguments: str = ""
+    closed: bool = False
+    arguments_done: bool = False
+
+    def pin(self, item: dict, *, id_name: str) -> None:
+        for source, target in ((id_name, "call_id"), ("name", "name")):
+            if source not in item:
+                continue
+            value = _identity(item[source])
+            previous = getattr(self, target)
+            if previous and previous != value:
+                raise invalid_model_frame()
+            setattr(self, target, value)
+
+    def seal(self) -> None:
+        _identity(self.call_id)
+        _identity(self.name)
+        self.closed = True
+
+
+@dataclass
+class ResponsesItems:
+    """One shared slot namespace for message, reasoning and client tool items."""
+
+    indexes: dict[int, str] = field(default_factory=dict)
+    item_indexes: dict[str, int] = field(default_factory=dict)
+    kinds: dict[str, str] = field(default_factory=dict)
+
+    def pin(self, event: dict, item: dict | None = None, *, kind: str = "") -> str:
+        item_id = _identity(item.get("id")) if item is not None else _identity(event.get("item_id"))
+        if "item_id" in event and _identity(event["item_id"]) != item_id:
+            raise invalid_model_frame()
+        index = _index(event, "output_index")
+        if index is not None:
+            if self.indexes.get(index, item_id) != item_id:
+                raise invalid_model_frame()
+            if self.item_indexes.get(item_id, index) != index:
+                raise invalid_model_frame()
+            self.indexes[index] = item_id
+            self.item_indexes[item_id] = index
+        if item is not None:
+            kind = _identity(item.get("type"))
+        if kind:
+            if self.kinds.get(item_id, kind) != kind:
+                raise invalid_model_frame()
+            self.kinds[item_id] = kind
+        return item_id
+
+
+@dataclass
+class ResponsesToolCalls:
+    calls: dict[str, WireTool] = field(default_factory=dict)
+    items: ResponsesItems = field(default_factory=ResponsesItems)
+
+    def _key(self, event: dict, item: dict | None = None) -> str:
+        return self.items.pin(event, item, kind="function_call")
+
+    def accept(self, event: dict) -> WireTool | None:
+        kind = event["type"]
+        if kind in {"response.output_item.added", "response.output_item.done"}:
+            item = _object(event.get("item"))
+            item_type = _identity(item.get("type"))
+            validate_client_item_type(item_type, wire_api="responses")
+            self.items.pin(event, item)
+            if item_type != "function_call":
+                return None
+            key = self._key(event, item)
+            current = self.calls.get(key)
+            if kind == "response.output_item.added":
+                if current is not None:
+                    raise invalid_model_frame()
+                current = WireTool()
+                current.pin(item, id_name="call_id")
+                if "arguments" in item:
+                    current.arguments = _text(item["arguments"])
+                self.calls[key] = current
+                return None
+            # A complete standalone done snapshot remains compatible. Deltas
+            # still require a previously declared item, never a fabricated slot.
+            if current is None:
+                current = WireTool()
+                self.calls[key] = current
+            current.pin(item, id_name="call_id")
+            if "arguments" in item:
+                arguments = _text(item["arguments"])
+                if (current.closed or current.arguments_done) and arguments != current.arguments:
+                    raise invalid_model_frame()
+                current.arguments = arguments
+            if current.closed:
+                return None
+            current.seal()
+            return current
+        if kind in {
+            "response.function_call_arguments.delta", "response.function_call_arguments.done",
+        }:
+            key = self._key(event)
+            current = self.calls.get(key)
+            if current is None or current.closed or current.arguments_done:
+                raise invalid_model_frame()
+            if kind.endswith(".delta"):
+                current.arguments += _text(event.get("delta"))
+            else:
+                current.arguments = _text(event.get("arguments"))
+                current.arguments_done = True
+        return None
+
+    def finish(self) -> None:
+        if any(not tool.closed for tool in self.calls.values()):
+            raise invalid_model_frame()
+
+    def reconcile_output(self, output: list[dict]) -> tuple[WireTool, ...]:
+        """Complete snapshots may fill gaps, never remove or rewrite closed calls."""
+        seen = set()
+        completed = []
+        for index, item in enumerate(output):
+            if item.get("type") != "function_call":
+                continue
+            key = _identity(item.get("id"))
+            if key in seen:
+                raise invalid_model_frame()
+            seen.add(key)
+            current = self.calls.get(key)
+            arguments = _text(item.get("arguments"))
+            if current is not None and not current.closed and current.arguments:
+                if not arguments.startswith(current.arguments):
+                    raise invalid_model_frame()
+            tool = self.accept({"type": "response.output_item.done", "item": item,
+                                "output_index": index})
+            if tool is not None:
+                completed.append(tool)
+        if self.calls.keys() != seen:
+            raise invalid_model_frame()
+        self.finish()
+        return tuple(completed)
+
+
+@dataclass
+class AnthropicToolBlocks:
+    calls: dict[int, WireTool] = field(default_factory=dict)
+    block_types: dict[int, str] = field(default_factory=dict)
+    closed: set[int] = field(default_factory=set)
+    initial_inputs: set[int] = field(default_factory=set)
+    implicit_indexes: set[int] = field(default_factory=set)
+
+    def accept(self, event: dict) -> None:
+        kind = event["type"]
+        if kind == "content_block_start":
+            block = _object(event.get("content_block"))
+            block_type = _identity(block.get("type"))
+            validate_client_item_type(block_type, wire_api="anthropic")
+            index = _index(event, "index", required=True)
+            if index is not None:
+                if index in self.block_types or index in self.closed:
+                    raise invalid_model_frame()
+                self.block_types[index] = block_type
+            for name in ("text", "thinking", "signature"):
+                if name in block:
+                    _text(block[name])
+            if block_type in {"text", "thinking"}:
+                _text(block.get(block_type))
+            if block_type == "redacted_thinking":
+                _text(block.get("data"))
+            if block_type == "tool_use":
+                tool = WireTool()
+                tool.pin(block, id_name="id")
+                _identity(tool.call_id)
+                _identity(tool.name)
+                if "input" in block:
+                    initial = _object(block["input"])
+                    if initial:
+                        tool.arguments = json.dumps(initial, ensure_ascii=False)
+                        self.initial_inputs.add(index)
+                self.calls[index] = tool
+        elif kind == "content_block_delta":
+            delta = _object(event.get("delta"))
+            delta_type = _identity(delta.get("type"))
+            index = _index(event, "index")
+            if index is None and delta_type != "input_json_delta":
+                # A legacy proxy may omit the block index on text/thinking
+                # deltas; slot 0 stays compatible with that omission. Tool
+                # argument deltas always carry their block identity.
+                index = 0
+            if index in self.closed:
+                raise invalid_model_frame()
+            expected = {"text_delta": "text", "thinking_delta": "thinking",
+                        "signature_delta": "thinking", "citations_delta": "text",
+                        "input_json_delta": "tool_use"}.get(delta_type)
+            previous = self.block_types.get(index)
+            if expected is not None:
+                if previous is not None and previous != expected:
+                    raise invalid_model_frame()
+                if previous is None and expected in {"text", "thinking"}:
+                    # Compatibility for a legacy proxy omitting block_start:
+                    # the first typed non-executable delta still pins the slot.
+                    self.block_types[index] = expected
+                    self.implicit_indexes.add(index)
+                field_name = {"text_delta": "text", "thinking_delta": "thinking",
+                              "signature_delta": "signature"}.get(delta_type)
+                if field_name is not None:
+                    _text(delta.get(field_name))
+            if delta_type == "input_json_delta":
+                current = self.calls.get(index)
+                if current is None or index in self.initial_inputs:
+                    raise invalid_model_frame()
+                current.arguments += _text(delta.get("partial_json"))
+            elif index in self.calls:
+                # Text/thinking cannot replace an already declared tool input.
+                raise invalid_model_frame()
+            for name in ("text", "thinking", "signature"):
+                if name in delta:
+                    _text(delta[name])
+        elif kind == "content_block_stop":
+            index = _index(event, "index", required=True)
+            if index in self.closed or index not in self.block_types:
+                raise invalid_model_frame()
+            current = self.calls.get(index)
+            if current is not None:
+                current.seal()
+            self.closed.add(index)
+
+    def finish(self) -> tuple[WireTool, ...]:
+        if any(not tool.closed for tool in self.calls.values()):
+            raise invalid_model_frame()
+        if not self.block_types.keys() <= self.closed | self.implicit_indexes:
+            raise invalid_model_frame()
+        self.closed.update(self.implicit_indexes)
+        return tuple(self.calls.values())