harness-sdk-python 0.36.5__tar.gz → 0.37.0__tar.gz

{harness_sdk_python-0.36.5 → harness_sdk_python-0.37.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.36.5
+Version: 0.37.0
 Summary: RunManager: the harness-sdk runs subsystem for Python Statewire hosts
 Project-URL: Repository, https://github.com/assistant-ui/harness-sdk
 License-Expression: MIT
 Requires-Python: <4.0,>=3.12
 Requires-Dist: pinned<0.16,>=0.15.2
-Requires-Dist: statewire<0.18,>=0.17.4
+Requires-Dist: statewire<0.19,>=0.18.0
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.36.5 → harness_sdk_python-0.37.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.36.5"
+version = "0.37.0"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.12,<4.0"
-dependencies = ["statewire>=0.17.4,<0.18", "pinned>=0.15.2,<0.16"]
+dependencies = ["statewire>=0.18.0,<0.19", "pinned>=0.15.2,<0.16"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.36.5 → harness_sdk_python-0.37.0}/src/harness_sdk/__init__.py

@@ -14,16 +14,14 @@ from .checkpoints import (
     langgraph_state_snapshot,
     langgraph_switch_values,
 )
-from .deepagents import (
-    DeepagentsMessages,
-    deepagents_drop_ephemeral,
-    deepagents_ingest,
-    deepagents_restamp,
-    deepagents_role,
-    deepagents_upsert_ephemeral,
-)
+from .deepagents import DeepagentsThread, deepagents_role
+from .deepagents_host import DeepagentsHost
+from .interest import InterestError, check_request, covered, resolve
+from .messages import MAIN_NS, MessageTree
+from .parts import PartsAssembler
 from .linear_thread import linear_thread
 from .run_manager import RunManager, RunManagerDescriptor, run_manager
+from .wire import CONTEXT, INTEREST, HarnessMessages
 from .voice import (
     VoiceManager,
     VoiceManagerDescriptor,
@@ -37,11 +35,19 @@ from .voice import (
 )
 
 __all__ = [
+    "CONTEXT",
     "HARNESS_PROTOCOL",
+    "HarnessMessages",
+    "INTEREST",
     "CheckpointIndex",
     "CheckpointStore",
     "CheckpointThread",
-    "DeepagentsMessages",
+    "DeepagentsHost",
+    "DeepagentsThread",
+    "InterestError",
+    "MAIN_NS",
+    "MessageTree",
+    "PartsAssembler",
     "MemoryCheckpointIndex",
     "Plan",
     "PostgresCheckpointIndex",
@@ -53,11 +59,9 @@ __all__ = [
     "VoiceProvider",
     "VoiceTurnCommitDeferred",
     "checkpoint_thread",
-    "deepagents_drop_ephemeral",
-    "deepagents_ingest",
-    "deepagents_restamp",
+    "check_request",
+    "covered",
     "deepagents_role",
-    "deepagents_upsert_ephemeral",
     "end_voice",
     "langgraph_checkpoints",
     "langgraph_checkpointer",
@@ -65,6 +69,7 @@ __all__ = [
     "langgraph_state_snapshot",
     "langgraph_switch_values",
     "linear_thread",
+    "resolve",
     "run_manager",
     "start_voice",
     "temp_frontend_tool_result",

{harness_sdk_python-0.36.5 → harness_sdk_python-0.37.0}/src/harness_sdk/checkpoints.py

@@ -29,6 +29,8 @@ _TIP_TRIGGERS = (
 )
 _UNREAD: Any = object()
 
+_VALUE_KEYS = ("parent_id", "seq", "value")
+
 
 @dataclass(frozen=True)
 class Snapshot:
@@ -81,12 +83,18 @@ class CheckpointIndex(Protocol):
         checkpoint_id: str,
     ) -> None: ...
 
-    async def upsert_messages(self, rows: list[dict[str, Any]]) -> None: ...
+    async def upsert_messages(self, rows: list[dict[str, Any]]) -> None:
+        """Insert rows; ``anchor_checkpoint_id`` and ``branch_id`` are set once, ``parent_id``/``seq``/``value`` replace on conflict when present."""
+        ...
 
     async def get_message(
         self, thread_id: str, checkpoint_ns: str, message_id: str
     ) -> dict[str, Any] | None: ...
 
+    async def read_messages(self, thread_id: str) -> list[dict[str, Any]]:
+        """Every row of the thread carrying a ``value``, across namespaces, ordered by ``seq``."""
+        ...
+
 
 def _check_branch_ids(branch_ids: list[int], count: int) -> None:
     for branch_id in branch_ids:
@@ -144,13 +152,17 @@ class MemoryCheckpointIndex:
     async def upsert_messages(self, rows: list[dict[str, Any]]) -> None:
         for row in rows:
             key = (row["thread_id"], row["checkpoint_ns"], row["message_id"])
-            self._messages.setdefault(
+            stored = self._messages.setdefault(
                 key,
                 {
-                    "anchor_checkpoint_id": row["anchor_checkpoint_id"],
-                    "branch_id": row["branch_id"],
+                    "anchor_checkpoint_id": row.get("anchor_checkpoint_id"),
+                    "branch_id": row.get("branch_id"),
+                    "parent_id": None,
+                    "seq": None,
+                    "value": None,
                 },
             )
+            stored.update({k: row[k] for k in _VALUE_KEYS if k in row})
 
     async def get_message(
         self, thread_id: str, checkpoint_ns: str, message_id: str
@@ -158,6 +170,14 @@ class MemoryCheckpointIndex:
         row = self._messages.get((thread_id, checkpoint_ns, message_id))
         return dict(row) if row is not None else None
 
+    async def read_messages(self, thread_id: str) -> list[dict[str, Any]]:
+        rows = [
+            {"checkpoint_ns": ns, "message_id": mid, **row}
+            for (tid, ns, mid), row in self._messages.items()
+            if tid == thread_id and row["value"] is not None
+        ]
+        return sorted(rows, key=lambda r: (r["checkpoint_ns"], r["seq"]))
+
 
 class PostgresCheckpointIndex:
     """psycopg-backed CheckpointIndex over an ``AsyncConnection`` or ``AsyncConnectionPool``; ``setup()`` creates the two tables."""
@@ -204,7 +224,10 @@ class PostgresCheckpointIndex:
                 " checkpoint_ns TEXT NOT NULL,"
                 " message_id TEXT NOT NULL,"
                 " anchor_checkpoint_id TEXT,"
-                " branch_id INTEGER NOT NULL,"
+                " branch_id INTEGER,"
+                " parent_id TEXT,"
+                " seq INTEGER,"
+                " value JSONB,"
                 " PRIMARY KEY (thread_id, checkpoint_ns, message_id))"
             )
 
@@ -281,14 +304,30 @@ class PostgresCheckpointIndex:
             )
 
     async def upsert_messages(self, rows: list[dict[str, Any]]) -> None:
+        from psycopg.types.json import Jsonb
+
         async with self._connection() as conn, conn.cursor() as cur:
             await cur.executemany(
                 "INSERT INTO checkpoint_messages"
-                " (thread_id, checkpoint_ns, message_id, anchor_checkpoint_id, branch_id)"
+                " (thread_id, checkpoint_ns, message_id, anchor_checkpoint_id, branch_id,"
+                " parent_id, seq, value)"
                 " VALUES (%(thread_id)s, %(checkpoint_ns)s, %(message_id)s,"
-                " %(anchor_checkpoint_id)s, %(branch_id)s)"
-                " ON CONFLICT (thread_id, checkpoint_ns, message_id) DO NOTHING",
-                rows,
+                " %(anchor_checkpoint_id)s, %(branch_id)s, %(parent_id)s, %(seq)s, %(value)s)"
+                " ON CONFLICT (thread_id, checkpoint_ns, message_id) DO UPDATE SET"
+                " parent_id = COALESCE(EXCLUDED.parent_id, checkpoint_messages.parent_id),"
+                " seq = COALESCE(EXCLUDED.seq, checkpoint_messages.seq),"
+                " value = COALESCE(EXCLUDED.value, checkpoint_messages.value)",
+                [
+                    {
+                        "anchor_checkpoint_id": None,
+                        "branch_id": None,
+                        "parent_id": None,
+                        "seq": None,
+                        **row,
+                        "value": Jsonb(row["value"]) if row.get("value") is not None else None,
+                    }
+                    for row in rows
+                ],
             )
 
     async def get_message(
@@ -296,14 +335,27 @@ class PostgresCheckpointIndex:
     ) -> dict[str, Any] | None:
         async with self._connection() as conn:
             cur = await conn.execute(
-                "SELECT anchor_checkpoint_id, branch_id FROM checkpoint_messages"
+                "SELECT anchor_checkpoint_id, branch_id, parent_id, seq, value"
+                " FROM checkpoint_messages"
                 " WHERE thread_id = %s AND checkpoint_ns = %s AND message_id = %s",
                 (thread_id, checkpoint_ns, message_id),
             )
             row = await cur.fetchone()
         if row is None:
             return None
-        return {"anchor_checkpoint_id": row[0], "branch_id": row[1]}
+        return dict(zip(("anchor_checkpoint_id", "branch_id", "parent_id", "seq", "value"), row))
+
+    async def read_messages(self, thread_id: str) -> list[dict[str, Any]]:
+        async with self._connection() as conn:
+            cur = await conn.execute(
+                "SELECT checkpoint_ns, message_id, anchor_checkpoint_id, branch_id, parent_id, seq, value"
+                " FROM checkpoint_messages WHERE thread_id = %s AND value IS NOT NULL"
+                " ORDER BY checkpoint_ns, seq",
+                (thread_id,),
+            )
+            rows = await cur.fetchall()
+        keys = ("checkpoint_ns", "message_id", "anchor_checkpoint_id", "branch_id", "parent_id", "seq", "value")
+        return [dict(zip(keys, row)) for row in rows]
 
 
 def _message_dict(message: Any) -> dict[str, Any]:

harness_sdk_python-0.37.0/src/harness_sdk/deepagents.py

@@ -0,0 +1,377 @@
+"""DeepagentsThread: harness message trees over a deepagents graph. The
+langgraph checkpointer is the agent's resumption source; the checkpoint
+index rows carry the harness messages (``value``) the wire projects. A
+rewind forks the graph at the anchor message's checkpoint; a send off the
+head chain forks the same way.
+"""
+
+from typing import Any, Callable
+
+from statepatch import plain
+
+from .checkpoints import (
+    CheckpointIndex,
+    checkpoint_thread,
+    langgraph_checkpoints,
+    langgraph_snapshot,
+)
+from .messages import MAIN_NS, MessageTree
+from .parts import PartsAssembler, text_of
+
+_TYPE_TO_ROLE = {"human": "user", "ai": "assistant", "tool": "assistant", "system": "assistant"}
+
+
+def deepagents_role(message: dict[str, Any]) -> str:
+    """The harness role of a langgraph message dump."""
+    try:
+        return _TYPE_TO_ROLE[message["type"]]
+    except KeyError as exc:
+        raise ValueError(f"unsupported message type: {message['type']!r}") from exc
+
+
+def _user_text(message: dict[str, Any]) -> str:
+    return "\n\n".join(part["text"] for part in message["parts"] if part["type"] == "text")
+
+
+def _ns_of(namespace: tuple[str, ...]) -> str:
+    return MAIN_NS if not namespace else "|".join(namespace)
+
+
+def _checkpoint_ns(ns: str) -> str:
+    return "" if ns == MAIN_NS else ns
+
+
+class DeepagentsThread:
+    """One thread's harness messages over a compiled deepagents graph: boot, turn planning, stream folding, ingest, subagents."""
+
+    def __init__(
+        self,
+        agent: Any,
+        *,
+        index: CheckpointIndex,
+        thread_id: str,
+        tree: MessageTree,
+        threads: Any,
+        changed: Callable[[], None] = lambda: None,
+    ) -> None:
+        if not callable(getattr(agent, "aget_state", None)):
+            raise TypeError(f"agent must be a compiled langgraph graph, got {agent!r}")
+        self._agent = agent
+        self._index = index
+        self._thread_id = thread_id
+        self.tree = tree
+        self._threads = threads
+        self._changed = changed
+        self._captured: dict[str, Any] | None = None
+        self._admission: Any | None = None
+        self._input_checkpoint_seen = False
+        self._assemblers: dict[str, PartsAssembler] = {}
+        self._touched: set[tuple[str, str]] = set()
+        self._pending_subagents: dict[str, str] = {}
+        self.interrupt: dict[str, Any] | None = None
+
+    async def boot(self) -> None:
+        """Hydrate the tree from the index rows and the main branch window from the checkpointer."""
+        store = langgraph_checkpoints(self._agent, thread_id=self._thread_id, checkpoint_ns="")
+        self._thread = await checkpoint_thread(
+            store=store, index=self._index, thread_id=self._thread_id, role=deepagents_role
+        )
+        for row in await self._index.read_messages(self._thread_id):
+            ns = row["checkpoint_ns"] or MAIN_NS
+            self.tree.add(ns, row["value"], head=False)
+        for ns, thread in self.tree.threads.items():
+            if ns != MAIN_NS and thread.messages:
+                thread.head = max(thread.messages.values(), key=lambda m: m["seq"])["id"]
+                self._thread_state(ns)
+        if self._thread.transcript:
+            self.tree.set_head(MAIN_NS, self._harness_id(self._thread.transcript[-1]["id"]))
+        else:
+            self.tree.thread(MAIN_NS)
+        self._thread_state(MAIN_NS)
+
+    def _harness_id(self, langchain_id: str) -> str:
+        for _ns, message_id, message in self.tree:
+            if message_id == langchain_id or langchain_id in _provider_ids(message):
+                return message_id
+        raise KeyError(f"no harness message folds {langchain_id!r}")
+
+    def _langchain_tail(self, ns: str, message_id: str) -> str:
+        ids = _provider_ids(self.tree.get(ns, message_id))
+        return ids[-1] if ids else message_id
+
+    def _thread_state(self, ns: str, **fields: Any) -> None:
+        thread = self.tree.thread(ns)
+        current = plain(self._threads.get(ns)) or {"status": "idle"}
+        self._threads[ns] = {**current, **fields, "headId": thread.head}
+
+    async def get_message_meta(self, message_id: str | None) -> dict[str, Any] | None:
+        thread = self.tree.thread(MAIN_NS)
+        if message_id is None:
+            return {"isLeaf": thread.head is None}
+        message = thread.messages.get(message_id)
+        if message is None:
+            return None
+        return {
+            "parentId": message["parentId"],
+            "role": message["role"],
+            "isLeaf": not thread.children.get(message_id),
+            "onActiveBranch": True,
+        }
+
+    def config(self) -> dict[str, Any]:
+        return {"configurable": {"thread_id": self._thread_id}}
+
+    async def plan_turn(self, ctx: Any) -> tuple[Any, dict[str, Any]]:
+        """The dispatch's langgraph (payload, config): forks at the anchor when the batch does not extend the head."""
+        self.abandon_turn()
+        config = self.config()
+        if ctx.resume:
+            return None, config
+        thread = self.tree.thread(MAIN_NS)
+        if ctx.trigger == "input-resume":
+            from langgraph.types import Command
+
+            decisions = [
+                {"type": "approve"} if response and response.get("decision") == "approve" else {"type": "reject"}
+                for _request, response, _meta in ctx.input_outcomes
+            ]
+            self._admission = ctx.applied()
+            self._assemblers.pop(MAIN_NS, None)
+            return Command(resume={"decisions": decisions}), config
+        if ctx.has_rollback:
+            parent = ctx.rollback_to
+        elif ctx.messages:
+            parent = ctx.messages[0].get("parentId", thread.head)
+        else:
+            parent = thread.head
+        if parent is not None and parent not in thread.messages:
+            raise KeyError(f"anchor {parent!r} is not in the thread")
+        fork = parent != thread.head
+        if fork:
+            rollback = None if parent is None else self._langchain_tail(MAIN_NS, parent)
+            if rollback is not None and all(m["id"] != rollback for m in self._thread.transcript):
+                await self._thread.locate(rollback)
+            plan = await self._thread.plan("message-edit", rollback_to=rollback)
+        else:
+            plan = await self._thread.plan(ctx.trigger if ctx.trigger in ("message-send", "steer", "error-continue", "stop-continue") else "message-send")
+        from langchain_core.messages import HumanMessage
+
+        turn: list[Any] = [*plan.replay]
+        for message in ctx.messages:
+            turn.append(HumanMessage(id=message["id"], content=_user_text(message)))
+            self._append_user(message, parent)
+            parent = message["id"]
+        self.tree.set_head(MAIN_NS, parent)
+        self._thread_state(MAIN_NS)
+        self._admission = ctx.applied()
+        self._assemblers.pop(MAIN_NS, None)
+        if plan.fork:
+            if plan.checkpoint_id is not None:
+                config["configurable"]["checkpoint_id"] = plan.checkpoint_id
+            else:
+                from langchain_core.messages import RemoveMessage
+                from langgraph.graph.message import REMOVE_ALL_MESSAGES
+
+                turn = [RemoveMessage(id=REMOVE_ALL_MESSAGES), *turn]
+        self._changed()
+        return ({"messages": turn} if turn else None), config
+
+    def _append_user(self, message: dict[str, Any], parent: str | None) -> None:
+        if self.tree.get(MAIN_NS, message["id"]) is not None:
+            return
+        value = {
+            "id": message["id"],
+            "parentId": parent,
+            "role": "user",
+            "parts": [dict(p) for p in message["parts"]],
+        }
+        if message.get("metadata"):
+            value["metadata"] = dict(message["metadata"])
+        self.tree.add(MAIN_NS, value)
+        self._touched.add((MAIN_NS, message["id"]))
+
+    def append_users(self, messages: Any) -> list[Any]:
+        """Append steered user messages after the head; returns the langgraph turn entries."""
+        from langchain_core.messages import HumanMessage
+
+        thread = self.tree.thread(MAIN_NS)
+        turn = []
+        for message in messages:
+            self._append_user(message, thread.head)
+            turn.append(HumanMessage(id=message["id"], content=_user_text(message)))
+        self._thread_state(MAIN_NS)
+        self._assemblers.pop(MAIN_NS, None)
+        self._changed()
+        return turn
+
+    def admit(self, admission: Any) -> None:
+        """Hold a dispatch admission until the next root checkpoint confirms its input."""
+        self._admission = admission
+
+    def checkpoint_saved(self, config: Any, checkpoint: Any, metadata: Any) -> None:
+        """Confirm this turn's input from a FrontierCheckpointer checkpoint callback."""
+        configurable = config["configurable"]
+        if (
+            configurable["thread_id"] == self._thread_id
+            and configurable.get("checkpoint_ns", "") == ""
+            and metadata["source"] in ("input", "loop")
+        ):
+            self._confirm_admission()
+
+    def _confirm_admission(self) -> None:
+        if self._admission is not None:
+            self._admission.dur()
+            self._admission = None
+
+    def _assembler(self, ns: str, message_id: str) -> PartsAssembler:
+        assembler = self._assemblers.get(ns)
+        if assembler is None:
+            thread = self.tree.thread(ns)
+            value = {
+                "id": message_id,
+                "parentId": thread.head,
+                "role": "assistant",
+                "parts": [],
+                "metadata": {"provider": {"ids": []}},
+            }
+            self.tree.add(ns, value)
+            self._touched.add((ns, message_id))
+            assembler = self._assemblers[ns] = PartsAssembler(lambda: self.tree.get(ns, message_id))
+            self._thread_state(ns, status="streaming")
+            self._changed()
+        return assembler
+
+    def _fold_id(self, assembler: PartsAssembler, langchain_id: str | None) -> None:
+        if langchain_id is None:
+            return
+        ids = assembler.message["metadata"]["provider"]["ids"]
+        if langchain_id not in plain(ids):
+            ids.append(langchain_id)
+
+    def _spawn(self, ns: str, description: str) -> None:
+        main = self._assemblers.get(MAIN_NS)
+        if main is None:
+            return
+        for part in plain(main.parts):
+            if (
+                part["type"] == "tool"
+                and part["toolName"] == "task"
+                and part["state"] == "streaming"
+                and part["input"].get("description") == description
+                and not (part.get("metadata") or {}).get("ns")
+            ):
+                main.amend(part["toolInvocationId"], metadata={"ns": ns})
+                title = str(part["input"].get("subagent_type") or "subagent")
+                self._thread_state(ns, title=f"{title}: {description}"[:80])
+                self._changed()
+                return
+
+    def append_event(self, namespace: tuple[str, ...], mode: str, event: Any) -> None:
+        """Fold one ``astream`` event; the root checkpoint stream is captured for the turn's ingest."""
+        ns = _ns_of(namespace)
+        if mode == "checkpoints":
+            if ns == MAIN_NS:
+                self._captured = event
+                if event["metadata"]["source"] in ("input", "loop"):
+                    self._input_checkpoint_seen = True
+                return
+            messages = event["values"].get("messages", [])
+            if ns not in self.tree.threads and messages:
+                first = messages[0]
+                self.tree.add(
+                    ns,
+                    {
+                        "id": first.id,
+                        "parentId": None,
+                        "role": "user",
+                        "parts": [{"type": "text", "text": text_of(first.content), "state": "done"}],
+                    },
+                )
+                self._touched.add((ns, first.id))
+                self._thread_state(ns, status="streaming")
+                self._spawn(ns, text_of(first.content))
+                self._changed()
+            return
+        if mode == "messages":
+            message, meta = event
+            kind = getattr(message, "type", "")
+            if kind in ("ai", "AIMessageChunk"):
+                assembler = self._assembler(ns, message.id or f"ai-{len(self.tree.thread(ns).messages)}")
+                self._fold_id(assembler, message.id)
+                assembler.ai_chunk(message)
+            elif kind == "tool":
+                assembler = self._assemblers.get(ns)
+                if assembler is not None:
+                    self._fold_id(assembler, message.id)
+                    sub_ns = meta.get("langgraph_checkpoint_ns")
+                    if ns == MAIN_NS and sub_ns in self.tree.threads:
+                        assembler.amend(message.tool_call_id, metadata={"ns": sub_ns})
+                        self._finish(sub_ns)
+                    assembler.tool_result(message)
+            self._changed()
+            return
+        if mode == "updates" and isinstance(event, dict) and "__interrupt__" in event and ns == MAIN_NS:
+            assembler = self._assemblers.get(MAIN_NS)
+            waiting = assembler.streaming_tools() if assembler is not None else []
+            if waiting:
+                tool_id = waiting[-1]
+                assembler.amend(tool_id, state="pendingApproval")
+                self.interrupt = {"toolCallId": tool_id}
+                self._changed()
+
+    def _finish(self, ns: str) -> None:
+        assembler = self._assemblers.pop(ns, None)
+        if assembler is not None:
+            assembler.finish()
+        self._thread_state(ns, status="idle")
+
+    async def ingest_turn(self, *, refetch: bool = False) -> None:
+        """Ingest the turn's captured root checkpoint, persist the touched harness messages, and settle streaming state."""
+        captured, self._captured = self._captured, None
+        if refetch:
+            await self._thread.ingest_latest()
+        elif captured is None:
+            raise RuntimeError("turn did not produce a root checkpoint")
+        else:
+            await self._thread.ingest(langgraph_snapshot(captured))
+        if self._input_checkpoint_seen:
+            self._confirm_admission()
+        for ns in list(self._assemblers):
+            if self.interrupt is None or ns != MAIN_NS:
+                self._finish(ns)
+        for ns in self.tree.threads:
+            if ns != MAIN_NS:
+                self._thread_state(ns, status="idle")
+        await self._persist()
+        self._changed()
+
+    async def _persist(self) -> None:
+        touched, self._touched = self._touched, set()
+        rows = [
+            {
+                "thread_id": self._thread_id,
+                "checkpoint_ns": _checkpoint_ns(ns),
+                "message_id": message_id,
+                "parent_id": self.tree.get(ns, message_id)["parentId"],
+                "seq": self.tree.get(ns, message_id)["seq"],
+                "value": plain(self.tree.get(ns, message_id)),
+            }
+            for ns, message_id in sorted(touched, key=lambda t: self.tree.get(*t)["seq"])
+        ]
+        if rows:
+            await self._index.upsert_messages(rows)
+
+    def abandon_turn(self) -> None:
+        """Discard a stream capture and any fork planned for the abandoned turn."""
+        self._captured = None
+        self._admission = None
+        self._input_checkpoint_seen = False
+        self.interrupt = None
+        for ns in list(self._assemblers):
+            self._finish(ns)
+        self._thread.abandon_plan()
+
+
+def _provider_ids(message: Any) -> list[str]:
+    metadata = plain(message.get("metadata")) or {}
+    return list((metadata.get("provider") or {}).get("ids") or [])