@oneciel-ai/ciel-runtime 0.2.2 → 0.2.4

package/ciel_runtime_support/runtime_primitives.py

@@ -0,0 +1,78 @@
+from __future__ import annotations
+
+import hashlib
+from pathlib import Path
+from typing import Any, Callable, Mapping
+
+
+def source_fingerprint(path: Path) -> str:
+    try:
+        return hashlib.sha256(path.read_bytes()).hexdigest()[:16]
+    except Exception:
+        try:
+            stat = path.stat()
+            return f"{int(stat.st_mtime_ns)}-{int(stat.st_size)}"
+        except Exception:
+            return "unknown"
+
+
+def positive_environment_int(environment: Mapping[str, str], name: str, default: int) -> int:
+    raw = str(environment.get(name) or "").strip()
+    if raw:
+        try:
+            value = int(raw)
+            if value > 0:
+                return value
+        except ValueError:
+            pass
+    return default
+
+
+def model_preset(
+    model_id: str,
+    presets: Mapping[str, dict[str, Any]],
+    lookup_ids: Callable[[str], tuple[str, ...] | list[str]],
+) -> dict[str, Any]:
+    for candidate in lookup_ids(model_id):
+        if candidate in presets:
+            return presets[candidate]
+        candidate_base = candidate.split(":", 1)[0]
+        for key, value in presets.items():
+            if candidate.startswith(key) or (":" not in candidate and key.startswith(candidate_base)):
+                return value
+    return {}
+
+
+def join_url(base: str, path: str) -> str:
+    base = base.rstrip("/")
+    if base.endswith("/v1") and path.startswith("/v1/"):
+        return base + path[3:]
+    return base + path
+
+
+def url_is_up(url: str, request_json: Callable[..., Any]) -> bool:
+    try:
+        request_json(url, timeout=1.5)
+        return True
+    except Exception:
+        return False
+
+
+def colorize_status_text(
+    text: str,
+    *,
+    enabled: bool,
+    palette: tuple[int, ...],
+    monotonic: Callable[[], float],
+) -> str:
+    if not enabled:
+        return text
+    parts: list[str] = []
+    phase = int(monotonic() * 8)
+    for index, char in enumerate(text):
+        if char.isspace():
+            parts.append(char)
+            continue
+        color = palette[(phase + index) % len(palette)]
+        parts.append(f"\033[1;38;5;{color}m{char}\033[0m")
+    return "".join(parts)

package/ciel_runtime_support/speech_http_controller.py

@@ -0,0 +1,335 @@
+"""Speech configuration and OpenAI-compatible ASR/TTS proxy endpoints."""
+
+from __future__ import annotations
+
+import base64
+import json
+import secrets
+import urllib.error
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass
+from http.server import BaseHTTPRequestHandler
+from typing import Any, Callable
+
+
+SpeechConfig = dict[str, Any]
+
+
+@dataclass(frozen=True, slots=True)
+class SpeechHttpPorts:
+    load_config: Callable[[], dict[str, Any]]
+    save_config: Callable[[dict[str, Any]], None]
+    write_json: Callable[..., None]
+    log: Callable[[str, str], None]
+    urlopen: Callable[..., Any] = urllib.request.urlopen
+
+
+@dataclass(frozen=True, slots=True)
+class SpeechHttpController:
+    ports: SpeechHttpPorts
+
+    def get(self, handler: BaseHTTPRequestHandler, path: str) -> bool:
+        if path == "/ca/speech/config":
+            self.ports.write_json(handler, self.public_config())
+            return True
+        if path == "/ca/speech/health":
+            self.ports.write_json(handler, self.health_payload())
+            return True
+        if path == "/ca/web/chat/api":
+            self.ports.write_json(handler, self.discovery_payload())
+            return True
+        if path == "/v1/audio/voices":
+            return self._proxy_get(handler, "tts", "voices_endpoint")
+        return False
+
+    def post(
+        self,
+        handler: BaseHTTPRequestHandler,
+        path: str,
+        raw: bytes,
+        content_type: str,
+    ) -> bool:
+        if path == "/ca/speech/config":
+            return self._save_public_config(handler, raw)
+        if path in {"/v1/audio/transcriptions", "/v1/audio/translations"}:
+            return self._proxy_asr(handler, raw, content_type)
+        if path in {"/v1/audio/speech", "/v1/audio/speech/batch"}:
+            return self._proxy_tts(handler, raw, content_type, batch=path.endswith("/batch"))
+        if path == "/v1/audio/voices":
+            return self._proxy_raw(handler, "tts", "voices_endpoint", raw, content_type)
+        return False
+
+    def public_config(self) -> dict[str, Any]:
+        speech = self._speech_config()
+        public: dict[str, Any] = {"ok": True}
+        for name in ("asr", "tts"):
+            source = speech.get(name) if isinstance(speech.get(name), dict) else {}
+            item = {key: value for key, value in source.items() if key != "api_key"}
+            item["api_key_set"] = bool(str(source.get("api_key") or "").strip())
+            public[name] = item
+        tailscale = speech.get("tailscale")
+        public["tailscale"] = dict(tailscale) if isinstance(tailscale, dict) else {}
+        public["endpoints"] = self.discovery_payload()["endpoints"]
+        return public
+
+    def discovery_payload(self) -> dict[str, Any]:
+        return {
+            "ok": True,
+            "web_chat": "/ca/web/chat",
+            "endpoints": {
+                "chat_health": "GET /ca/channel/health",
+                "chat_messages": "GET|POST /ca/channel/messages",
+                "chat_wait": "GET /ca/channel/wait",
+                "chat_stream": "GET /ca/channel/stream",
+                "chat_files": "POST /ca/channel/files",
+                "speech_config": "GET|POST /ca/speech/config",
+                "speech_health": "GET /ca/speech/health",
+                "asr": "POST /v1/audio/transcriptions",
+                "asr_translate": "POST /v1/audio/translations",
+                "tts": "POST /v1/audio/speech",
+                "tts_batch": "POST /v1/audio/speech/batch",
+                "tts_voices": "GET|POST /v1/audio/voices",
+                "models": "GET /v1/models",
+                "responses": "POST /v1/responses",
+                "messages": "POST /v1/messages",
+            },
+        }
+
+    def health_payload(self) -> dict[str, Any]:
+        services = {name: self._probe(name) for name in ("asr", "tts")}
+        return {"ok": all(not item["enabled"] or item["reachable"] for item in services.values()), "services": services}
+
+    def _speech_config(self) -> SpeechConfig:
+        speech = self.ports.load_config().get("speech")
+        return speech if isinstance(speech, dict) else {}
+
+    def _service_config(self, name: str) -> SpeechConfig:
+        service = self._speech_config().get(name)
+        return service if isinstance(service, dict) else {}
+
+    def _save_public_config(self, handler: BaseHTTPRequestHandler, raw: bytes) -> bool:
+        try:
+            update = json.loads(raw.decode("utf-8") if raw else "{}")
+            if not isinstance(update, dict):
+                raise ValueError("configuration body must be a JSON object")
+            config = self.ports.load_config()
+            speech = config.setdefault("speech", {})
+            if not isinstance(speech, dict):
+                speech = {}
+                config["speech"] = speech
+            for name in ("asr", "tts"):
+                incoming = update.get(name)
+                if not isinstance(incoming, dict):
+                    continue
+                current = speech.setdefault(name, {})
+                if not isinstance(current, dict):
+                    current = {}
+                    speech[name] = current
+                for key, value in incoming.items():
+                    if key in {"api_key_set", "clear_api_key"}:
+                        continue
+                    if key == "api_key" and not str(value or "").strip():
+                        continue
+                    current[key] = self._validated_value(name, key, value)
+                if incoming.get("clear_api_key") is True:
+                    current["api_key"] = ""
+            tailscale = update.get("tailscale")
+            if isinstance(tailscale, dict):
+                current_tailscale = speech.setdefault("tailscale", {})
+                if not isinstance(current_tailscale, dict):
+                    current_tailscale = {}
+                    speech["tailscale"] = current_tailscale
+                for key in ("enabled", "asr_hostname", "tts_hostname"):
+                    if key in tailscale:
+                        current_tailscale[key] = tailscale[key]
+            self.ports.save_config(config)
+            self.ports.write_json(handler, self.public_config())
+        except (UnicodeError, ValueError, TypeError) as exc:
+            self.ports.write_json(handler, {"ok": False, "error": str(exc)}, 400)
+        return True
+
+    @staticmethod
+    def _validated_value(service: str, key: str, value: Any) -> Any:
+        allowed = {
+            "asr": {"enabled", "base_url", "endpoint", "model", "language", "api_key", "timeout_seconds"},
+            "tts": {"enabled", "base_url", "endpoint", "voices_endpoint", "model", "voice", "language", "response_format", "speed", "auto_speak", "api_key", "timeout_seconds"},
+        }
+        if key not in allowed[service]:
+            raise ValueError(f"unsupported {service} setting: {key}")
+        if key in {"enabled", "auto_speak"}:
+            return bool(value)
+        if key == "timeout_seconds":
+            return max(1, min(3600, int(value)))
+        if key == "speed":
+            return max(0.25, min(4.0, float(value)))
+        text = str(value or "").strip()
+        if key == "base_url":
+            parsed = urllib.parse.urlparse(text)
+            if parsed.scheme not in {"http", "https"} or not parsed.netloc:
+                raise ValueError(f"invalid {service} base_url")
+            return text.rstrip("/")
+        if key in {"endpoint", "voices_endpoint"} and not text.startswith("/"):
+            raise ValueError(f"{service} {key} must begin with /")
+        return text
+
+    def _probe(self, name: str) -> dict[str, Any]:
+        config = self._service_config(name)
+        enabled = bool(config.get("enabled"))
+        result: dict[str, Any] = {
+            "enabled": enabled,
+            "configured": bool(str(config.get("base_url") or "").strip()),
+            "reachable": False,
+        }
+        if not enabled:
+            return result
+        try:
+            request = urllib.request.Request(self._url(config, "/health"), headers=self._headers(config, "application/json"))
+            with self.ports.urlopen(request, timeout=min(10.0, self._timeout(config))) as response:
+                result["status"] = int(getattr(response, "status", 200))
+                result["reachable"] = result["status"] < 500
+        except Exception as exc:
+            result["error"] = f"{type(exc).__name__}: {exc}"
+        return result
+
+    def _proxy_get(self, handler: BaseHTTPRequestHandler, service: str, endpoint_key: str) -> bool:
+        config = self._service_config(service)
+        if not self._require_enabled(handler, service, config):
+            return True
+        request = urllib.request.Request(self._url(config, str(config.get(endpoint_key) or "")), headers=self._headers(config, "application/json"))
+        return self._open_and_write(handler, service, config, request)
+
+    def _proxy_asr(self, handler: BaseHTTPRequestHandler, raw: bytes, content_type: str) -> bool:
+        config = self._service_config("asr")
+        if not self._require_enabled(handler, "asr", config):
+            return True
+        if "application/json" in content_type.lower():
+            try:
+                body = json.loads(raw.decode("utf-8"))
+                if not isinstance(body, dict):
+                    raise ValueError("request must be a JSON object")
+                audio = base64.b64decode(str(body.get("audio_base64") or ""), validate=True)
+                if not audio:
+                    raise ValueError("audio_base64 is required")
+                fields = {
+                    "model": str(body.get("model") or config.get("model") or ""),
+                    "language": str(body.get("language") or config.get("language") or ""),
+                    "response_format": str(body.get("response_format") or "json"),
+                }
+                if fields["language"].lower() == "auto":
+                    fields.pop("language")
+                raw, content_type = self._multipart(fields, "file", str(body.get("filename") or "recording.wav"), str(body.get("content_type") or "audio/wav"), audio)
+            except (ValueError, TypeError, UnicodeError) as exc:
+                self.ports.write_json(handler, {"error": {"type": "invalid_request_error", "message": str(exc)}}, 400)
+                return True
+        return self._proxy_raw(handler, "asr", "endpoint", raw, content_type)
+
+    def _proxy_tts(self, handler: BaseHTTPRequestHandler, raw: bytes, content_type: str, *, batch: bool) -> bool:
+        config = self._service_config("tts")
+        if not self._require_enabled(handler, "tts", config):
+            return True
+        if "application/json" in content_type.lower():
+            try:
+                body = json.loads(raw.decode("utf-8") if raw else "{}")
+                if not isinstance(body, dict):
+                    raise ValueError("request must be a JSON object")
+                if not batch:
+                    body.setdefault("model", str(config.get("model") or ""))
+                    body.setdefault("voice", str(config.get("voice") or "default"))
+                    body.setdefault("language", str(config.get("language") or "Auto"))
+                    body.setdefault("response_format", str(config.get("response_format") or "wav"))
+                    body.setdefault("speed", float(config.get("speed") or 1.0))
+                raw = json.dumps(body, ensure_ascii=False).encode("utf-8")
+            except (ValueError, TypeError, UnicodeError) as exc:
+                self.ports.write_json(handler, {"error": {"type": "invalid_request_error", "message": str(exc)}}, 400)
+                return True
+        endpoint = str(config.get("endpoint") or "/v1/audio/speech") + ("/batch" if batch else "")
+        return self._proxy_bytes(handler, "tts", config, endpoint, raw, content_type)
+
+    def _proxy_raw(self, handler: BaseHTTPRequestHandler, service: str, endpoint_key: str, raw: bytes, content_type: str) -> bool:
+        config = self._service_config(service)
+        if not self._require_enabled(handler, service, config):
+            return True
+        return self._proxy_bytes(handler, service, config, str(config.get(endpoint_key) or ""), raw, content_type)
+
+    def _proxy_bytes(self, handler: BaseHTTPRequestHandler, service: str, config: SpeechConfig, endpoint: str, raw: bytes, content_type: str) -> bool:
+        request = urllib.request.Request(
+            self._url(config, endpoint),
+            data=raw,
+            headers=self._headers(config, content_type or "application/octet-stream"),
+            method="POST",
+        )
+        return self._open_and_write(handler, service, config, request)
+
+    def _open_and_write(self, handler: BaseHTTPRequestHandler, service: str, config: SpeechConfig, request: urllib.request.Request) -> bool:
+        try:
+            with self.ports.urlopen(request, timeout=self._timeout(config)) as response:
+                self._write_bytes(handler, response.read(), int(getattr(response, "status", 200)), str(response.headers.get("content-type") or "application/octet-stream"))
+        except urllib.error.HTTPError as exc:
+            self._write_bytes(handler, exc.read(), int(exc.code), str(exc.headers.get("content-type") or "application/json"))
+        except Exception as exc:
+            self.ports.log("ERROR", f"speech_proxy_failed service={service} error={type(exc).__name__}: {exc}")
+            self.ports.write_json(handler, {"error": {"type": "upstream_error", "message": f"{service.upper()} upstream unavailable: {exc}"}}, 502)
+        return True
+
+    @staticmethod
+    def _require_enabled(handler: BaseHTTPRequestHandler, service: str, config: SpeechConfig) -> bool:
+        if bool(config.get("enabled")) and str(config.get("base_url") or "").strip():
+            return True
+        body = json.dumps({"error": {"type": "service_disabled", "message": f"{service.upper()} is not configured or enabled"}}).encode()
+        handler.send_response(503)
+        handler.send_header("content-type", "application/json")
+        handler.send_header("content-length", str(len(body)))
+        handler.end_headers()
+        handler.wfile.write(body)
+        return False
+
+    @staticmethod
+    def _write_bytes(handler: BaseHTTPRequestHandler, data: bytes, status: int, content_type: str) -> None:
+        handler.send_response(status)
+        handler.send_header("content-type", content_type)
+        handler.send_header("content-length", str(len(data)))
+        handler.send_header("cache-control", "no-store")
+        handler.end_headers()
+        handler.wfile.write(data)
+
+    @staticmethod
+    def _headers(config: SpeechConfig, content_type: str) -> dict[str, str]:
+        headers = {"accept": "*/*", "content-type": content_type}
+        api_key = str(config.get("api_key") or "").strip()
+        if api_key:
+            headers["authorization"] = f"Bearer {api_key}"
+        return headers
+
+    @staticmethod
+    def _url(config: SpeechConfig, endpoint: str) -> str:
+        return str(config.get("base_url") or "").rstrip("/") + "/" + endpoint.lstrip("/")
+
+    @staticmethod
+    def _timeout(config: SpeechConfig) -> float:
+        try:
+            return max(1.0, min(3600.0, float(config.get("timeout_seconds") or 300)))
+        except (TypeError, ValueError):
+            return 300.0
+
+    @staticmethod
+    def _multipart(fields: dict[str, str], file_field: str, filename: str, mime: str, data: bytes) -> tuple[bytes, str]:
+        boundary = "ciel-" + secrets.token_hex(16)
+        chunks: list[bytes] = []
+        for name, value in fields.items():
+            chunks.extend([
+                f"--{boundary}\r\n".encode(),
+                f'Content-Disposition: form-data; name="{name}"\r\n\r\n'.encode(),
+                str(value).encode("utf-8"), b"\r\n",
+            ])
+        safe_filename = filename.replace('"', "_").replace("\r", "_").replace("\n", "_")
+        chunks.extend([
+            f"--{boundary}\r\n".encode(),
+            f'Content-Disposition: form-data; name="{file_field}"; filename="{safe_filename}"\r\n'.encode(),
+            f"Content-Type: {mime}\r\n\r\n".encode(), data, b"\r\n",
+            f"--{boundary}--\r\n".encode(),
+        ])
+        return b"".join(chunks), f"multipart/form-data; boundary={boundary}"
+
+
+__all__ = ["SpeechHttpController", "SpeechHttpPorts"]

package/ciel_runtime_support/sse_stream_collection.py

@@ -0,0 +1,236 @@
+"""Collect SSE chat responses into one message, cutting loops short.
+
+The Ollama collection path reads NDJSON; the other two protocols the
+Codex-facing collector speaks are SSE. DeepSeek publishes both formats -- an
+OpenAI-compatible endpoint at ``https://api.deepseek.com`` and an
+Anthropic-compatible one at ``https://api.deepseek.com/anthropic`` -- and
+ciel-runtime uses the Anthropic one, so a repetition loop on deepseek.com
+arrives through :func:`collect_anthropic_message_stream`. Switching endpoints
+would not have helped: both collectors used one blocking POST, which is what
+let a loop run to completion before anything could look at it.
+
+Each collector assembles exactly the payload the matching decoder already
+expects, so nothing downstream changes.
+"""
+
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass, field
+from typing import Any, Iterable
+
+from .runaway_output_guard import (
+    RunawayOutputDetector,
+    RunawayOutputPolicy,
+    RunawayVerdict,
+)
+
+
+@dataclass(frozen=True, slots=True)
+class SseStreamCollection:
+    response: dict[str, Any]
+    verdict: RunawayVerdict | None = None
+    chunks: int = 0
+
+
+def iter_sse_payloads(lines: Iterable[Any]) -> Iterable[dict[str, Any]]:
+    """Yield decoded ``data:`` payloads, ignoring framing and keepalives."""
+
+    for raw in lines:
+        line = (
+            raw.decode("utf-8", errors="ignore")
+            if isinstance(raw, (bytes, bytearray))
+            else str(raw)
+        ).strip()
+        if not line or not line.startswith("data:"):
+            continue
+        body = line[5:].strip()
+        if not body or body == "[DONE]":
+            continue
+        try:
+            payload = json.loads(body)
+        except ValueError:
+            continue
+        if isinstance(payload, dict):
+            yield payload
+
+
+@dataclass
+class _ToolFragment:
+    call_id: str = ""
+    name: str = ""
+    arguments: str = ""
+
+
+def collect_openai_chat_stream(
+    lines: Iterable[Any], policy: RunawayOutputPolicy | None = None
+) -> SseStreamCollection:
+    """Merge OpenAI chat-completion chunks into one non-streaming response."""
+
+    text_runaway = RunawayOutputDetector(policy)
+    reasoning_runaway = RunawayOutputDetector(policy)
+    verdict: RunawayVerdict | None = None
+    content: list[str] = []
+    reasoning: list[str] = []
+    fragments: dict[int, _ToolFragment] = {}
+    finish_reason = ""
+    usage: dict[str, Any] = {}
+    envelope: dict[str, Any] = {}
+    chunks = 0
+    for payload in iter_sse_payloads(lines):
+        chunks += 1
+        for key in ("id", "model", "created", "system_fingerprint"):
+            if payload.get(key) is not None:
+                envelope[key] = payload[key]
+        if isinstance(payload.get("usage"), dict):
+            usage = payload["usage"]
+        choices = payload.get("choices")
+        choice = choices[0] if isinstance(choices, list) and choices and isinstance(choices[0], dict) else {}
+        if choice.get("finish_reason"):
+            finish_reason = str(choice["finish_reason"])
+        delta = choice.get("delta") if isinstance(choice.get("delta"), dict) else {}
+        reasoning_chunk = str(delta.get("reasoning_content") or "")
+        if reasoning_chunk:
+            reasoning.append(reasoning_chunk)
+            verdict = verdict or reasoning_runaway.feed(reasoning_chunk)
+        text_chunk = str(delta.get("content") or "")
+        if text_chunk:
+            content.append(text_chunk)
+            verdict = verdict or text_runaway.feed(text_chunk)
+        for call in delta.get("tool_calls") or []:
+            if not isinstance(call, dict):
+                continue
+            try:
+                index = int(call.get("index") or 0)
+            except (TypeError, ValueError):
+                index = 0
+            fragment = fragments.setdefault(index, _ToolFragment())
+            if call.get("id"):
+                fragment.call_id = str(call["id"])
+            function = call.get("function") if isinstance(call.get("function"), dict) else {}
+            if function.get("name"):
+                fragment.name = str(function["name"])
+            if function.get("arguments"):
+                fragment.arguments += str(function["arguments"])
+        if verdict is not None:
+            break
+    message: dict[str, Any] = {"role": "assistant", "content": "".join(content)}
+    if reasoning:
+        message["reasoning_content"] = "".join(reasoning)
+    if fragments:
+        message["tool_calls"] = [
+            {
+                "id": fragment.call_id or f"call_{index + 1}",
+                "type": "function",
+                "function": {"name": fragment.name, "arguments": fragment.arguments},
+            }
+            for index, fragment in sorted(fragments.items())
+        ]
+    response = {
+        **envelope,
+        "choices": [{"index": 0, "message": message, "finish_reason": finish_reason or "stop"}],
+    }
+    if usage:
+        response["usage"] = usage
+    return SseStreamCollection(response=response, verdict=verdict, chunks=chunks)
+
+
+@dataclass
+class _ContentBlock:
+    block: dict[str, Any] = field(default_factory=dict)
+    text: list[str] = field(default_factory=list)
+    thinking: list[str] = field(default_factory=list)
+    signature: str = ""
+    partial_json: str = ""
+
+    def finish(self) -> dict[str, Any]:
+        block = dict(self.block)
+        kind = str(block.get("type") or "")
+        if kind == "text":
+            block["text"] = str(block.get("text") or "") + "".join(self.text)
+        elif kind in ("thinking", "redacted_thinking"):
+            block["thinking"] = str(block.get("thinking") or "") + "".join(self.thinking)
+            if self.signature:
+                block["signature"] = self.signature
+        elif kind == "tool_use" and self.partial_json:
+            try:
+                parsed = json.loads(self.partial_json)
+            except ValueError:
+                parsed = None
+            block["input"] = parsed if isinstance(parsed, dict) else block.get("input") or {}
+        return block
+
+
+def collect_anthropic_message_stream(
+    lines: Iterable[Any], policy: RunawayOutputPolicy | None = None
+) -> SseStreamCollection:
+    """Merge Anthropic Messages SSE events into one non-streaming message."""
+
+    text_runaway = RunawayOutputDetector(policy)
+    thinking_runaway = RunawayOutputDetector(policy)
+    verdict: RunawayVerdict | None = None
+    message: dict[str, Any] = {
+        "type": "message",
+        "role": "assistant",
+        "content": [],
+        "stop_reason": None,
+    }
+    blocks: dict[int, _ContentBlock] = {}
+    chunks = 0
+    for payload in iter_sse_payloads(lines):
+        chunks += 1
+        event_type = str(payload.get("type") or "")
+        if event_type == "message_start":
+            started = payload.get("message")
+            if isinstance(started, dict):
+                message.update({key: value for key, value in started.items() if key != "content"})
+            continue
+        if event_type == "content_block_start":
+            index = payload.get("index")
+            block = payload.get("content_block")
+            if isinstance(index, int) and isinstance(block, dict):
+                blocks[index] = _ContentBlock(block=dict(block))
+            continue
+        if event_type == "content_block_delta":
+            index = payload.get("index")
+            delta = payload.get("delta") if isinstance(payload.get("delta"), dict) else {}
+            if not isinstance(index, int):
+                continue
+            state = blocks.setdefault(index, _ContentBlock(block={"type": "text", "text": ""}))
+            delta_type = str(delta.get("type") or "")
+            if delta_type == "text_delta":
+                chunk = str(delta.get("text") or "")
+                state.text.append(chunk)
+                verdict = verdict or text_runaway.feed(chunk)
+            elif delta_type == "thinking_delta":
+                chunk = str(delta.get("thinking") or "")
+                state.thinking.append(chunk)
+                verdict = verdict or thinking_runaway.feed(chunk)
+            elif delta_type == "signature_delta":
+                state.signature += str(delta.get("signature") or "")
+            elif delta_type == "input_json_delta":
+                state.partial_json += str(delta.get("partial_json") or "")
+            if verdict is not None:
+                break
+            continue
+        if event_type == "message_delta":
+            delta = payload.get("delta") if isinstance(payload.get("delta"), dict) else {}
+            for key in ("stop_reason", "stop_sequence"):
+                if delta.get(key) is not None:
+                    message[key] = delta[key]
+            usage = payload.get("usage")
+            if isinstance(usage, dict):
+                message["usage"] = {**(message.get("usage") or {}), **usage}
+            continue
+    message["content"] = [state.finish() for _index, state in sorted(blocks.items())]
+    if verdict is not None and not message.get("stop_reason"):
+        message["stop_reason"] = "max_tokens"
+    return SseStreamCollection(response=message, verdict=verdict, chunks=chunks)
+
+
+__all__ = [
+    "SseStreamCollection",
+    "collect_anthropic_message_stream",
+    "collect_openai_chat_stream",
+    "iter_sse_payloads",
+]