harness-sdk-python 0.38.0__tar.gz → 0.39.0__tar.gz

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.0}/.gitignore

@@ -2,6 +2,7 @@ node_modules
 .next
 dist
 dist-test
+coverage
 .wrangler
 .DS_Store
 .env

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.38.0
+Version: 0.39.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.20,>=0.19.0
+Requires-Dist: pinned<0.17,>=0.16.0
+Requires-Dist: statewire<0.23,>=0.21.1
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.38.0"
+version = "0.39.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.19.0,<0.20", "pinned>=0.15.2,<0.16"]
+dependencies = ["statewire>=0.21.1,<0.23", "pinned>=0.16.0,<0.17"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.0}/src/harness_sdk/deepagents.py

@@ -10,6 +10,7 @@ main run; its rows persist under ``checkpoint_ns == ns``.
 from typing import Any, Callable
 
 from statepatch import plain
+from statewire import StatewireReject
 
 from .checkpoints import (
     CheckpointIndex,
@@ -32,8 +33,45 @@ def deepagents_role(message: dict[str, Any]) -> str:
         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 _file_block(part: dict[str, Any]) -> dict[str, Any]:
+    url, media_type = part["url"], part["mediaType"]
+    if url.startswith("data:"):
+        header, comma, data = url.removeprefix("data:").partition(",")
+        media_type, *params = header.split(";")
+        if not comma or not media_type or params[-1:] != ["base64"]:
+            raise ValueError("file data URLs must be data:<type>;base64,<data>")
+        source = {"base64": data, "mime_type": media_type}
+    else:
+        raise ValueError("file URLs must be inline data:<type>;base64,<data> URLs")
+    kind = media_type.split("/", 1)[0]
+    block = {"type": kind if kind in ("image", "audio", "video") else "file", **source}
+    if "filename" in part:
+        block["extras"] = {"filename": part["filename"]}
+    return block
+
+
+def _user_content(message: dict[str, Any]) -> str | list[dict[str, Any]]:
+    parts = message["parts"]
+    if all(part["type"] == "text" for part in parts):
+        return "\n\n".join(part["text"] for part in parts)
+    return [{"type": "text", "text": part["text"]} if part["type"] == "text" else _file_block(part) for part in parts]
+
+
+def check_file_parts(message: dict[str, Any]) -> dict[str, Any]:
+    """``prepare_message`` hook: a file part ``_file_block`` cannot carry rejects ``invalid-message``."""
+    parts = message.get("parts")
+    for part in parts if isinstance(parts, list) else ():
+        if (
+            isinstance(part, dict)
+            and part.get("type") == "file"
+            and isinstance(part.get("url"), str)
+            and isinstance(part.get("mediaType"), str)
+        ):
+            try:
+                _file_block(part)
+            except ValueError as exc:
+                raise StatewireReject(str(exc), payload={"reason": "invalid-message"}) from exc
+    return message
 
 
 def _ns_of(namespace: tuple[str, ...]) -> str:
@@ -123,19 +161,25 @@ class DeepagentsThread:
         """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
 
+            tool_ids = {p.get("toolInvocationId") for p in plain(self.tree.get(MAIN_NS, thread.head)["parts"])}
+            missing = [r["toolCallId"] for r, _response, _meta in ctx.input_outcomes if r["toolCallId"] not in tool_ids]
+            if missing:
+                raise KeyError(f"head {thread.head!r} holds no tool part for {missing!r}")
+            self._mount(MAIN_NS, thread.head)
+            if ctx.resume:
+                return None, config
             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.resume:
+            return None, config
         if ctx.has_rollback:
             parent = ctx.rollback_to
         elif ctx.messages:
@@ -156,7 +200,7 @@ class DeepagentsThread:
 
         turn: list[Any] = [*plan.replay]
         for message in ctx.messages:
-            turn.append(HumanMessage(id=message["id"], content=_user_text(message)))
+            turn.append(HumanMessage(id=message["id"], content=_user_content(message)))
             self._append_user(message, parent)
             parent = message["id"]
         self.tree.set_head(MAIN_NS, parent)
@@ -196,7 +240,7 @@ class DeepagentsThread:
         turn = []
         for message in messages:
             self._append_user(message, thread.head)
-            turn.append(HumanMessage(id=message["id"], content=_user_text(message)))
+            turn.append(HumanMessage(id=message["id"], content=_user_content(message)))
         self._thread_state(MAIN_NS)
         self._assemblers.pop(MAIN_NS, None)
         self._changed()
@@ -233,10 +277,14 @@ class DeepagentsThread:
                 "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()
+            assembler = self._mount(ns, message_id)
+        return assembler
+
+    def _mount(self, ns: str, message_id: str) -> PartsAssembler:
+        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:
@@ -317,14 +365,16 @@ class DeepagentsThread:
                 self.interrupt = {"toolCallId": tool_id}
                 self._changed()
 
-    def _finish(self, ns: str) -> None:
+    def _finish(self, ns: str, outcome: dict[str, Any] | None = None) -> None:
         assembler = self._assemblers.pop(ns, None)
         if assembler is not None:
             assembler.finish()
+            for key, value in (outcome or {}).items():
+                assembler.message[key] = value
         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."""
+    async def ingest_turn(self, *, refetch: bool = False, outcome: dict[str, Any] | None = None) -> None:
+        """Ingest the turn's captured root checkpoint, persist the touched harness messages, and settle streaming state; ``outcome`` lands on the turn's open replies."""
         captured, self._captured = self._captured, None
         if refetch:
             await self._thread.ingest_latest()
@@ -336,7 +386,7 @@ class DeepagentsThread:
             self._confirm_admission()
         for ns in self._turn_namespaces():
             if self.interrupt is None or ns != MAIN_NS:
-                self._finish(ns)
+                self._finish(ns, outcome)
         for ns in self.tree.threads:
             if ns != MAIN_NS and _root_of(ns) not in self._subagents:
                 self._thread_state(ns, status="idle")
@@ -354,14 +404,14 @@ class DeepagentsThread:
             raise ValueError(f"subagent namespace must be a root namespace other than {MAIN_NS!r}, got {ns!r}")
         if ns in self._subagents:
             raise RuntimeError(f"subagent {ns!r} is already running")
+        config = {"configurable": {"thread_id": f"{self._thread_id}/{ns}"}}
+        payload = {"messages": [HumanMessage(id=message["id"], content=_user_content(message))]}
         thread = self.tree.thread(ns)
         self.tree.add(ns, {**message, "parentId": thread.head})
         self._touched.add((ns, message["id"]))
         self._thread_state(ns, status="streaming")
         self._subagents.add(ns)
         self._changed()
-        config = {"configurable": {"thread_id": f"{self._thread_id}/{ns}"}}
-        payload = {"messages": [HumanMessage(id=message["id"], content=_user_text(message))]}
         try:
             async for namespace, mode, event in self._agent.astream(
                 payload, config=config, stream_mode=["messages", "updates", "checkpoints"], subgraphs=True
@@ -416,14 +466,19 @@ class DeepagentsThread:
         await self._persist()
         self._changed()
 
-    def abandon_turn(self) -> None:
-        """Discard a stream capture and any fork planned for the abandoned turn."""
+    async def fail_turn(self, error: str) -> None:
+        """Abandon the turn with its open replies marked ``failed`` and persist the touched messages."""
+        self.abandon_turn({"status": "failed", "error": error})
+        await self._persist()
+
+    def abandon_turn(self, outcome: dict[str, Any] | None = None) -> None:
+        """Discard a stream capture and any fork planned for the abandoned turn; ``outcome`` lands on the turn's open replies."""
         self._captured = None
         self._admission = None
         self._input_checkpoint_seen = False
         self.interrupt = None
         for ns in self._turn_namespaces():
-            self._finish(ns)
+            self._finish(ns, outcome)
         self._thread.abandon_plan()
 
 

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.0}/src/harness_sdk/deepagents_host.py

@@ -14,10 +14,10 @@ from typing import Any
 from statewire import Statewire, command
 
 from .checkpoints import CheckpointIndex
-from .deepagents import DeepagentsThread
+from .deepagents import DeepagentsThread, check_file_parts
 from .messages import MAIN_NS
 from .protocol import HARNESS_PROTOCOL
-from .run_manager import RunManager, run_manager
+from .run_manager import RunManager, error_of, run_manager
 from .voice import VoiceTurnCommitDeferred, end_voice, set_voice_mic, start_voice, voice_client_departed
 from .voice_thread import VoiceThread, is_ephemeral
 from .wire import HarnessMessages
@@ -26,6 +26,11 @@ logger = logging.getLogger(__name__)
 _HALTED = ("stopped", "error")
 
 
+def _interrupted(ctx: RunManager.RunContext) -> dict[str, Any]:
+    reason = ctx.stop_reason
+    return {"status": "interrupted"} if reason is None else {"status": "interrupted", "stopReason": reason}
+
+
 class DeepagentsHost(VoiceThread, HarnessMessages, Statewire):
     """One thread: ``build_agent(checkpointer)`` returns the compiled deepagents graph."""
 
@@ -128,15 +133,20 @@ class DeepagentsHost(VoiceThread, HarnessMessages, Statewire):
 
     # ─── Runs ───────────────────────────────────────────────
 
-    @run_manager(capabilities=("rewind",))
+    @run_manager(capabilities=("rewind", "files"), prepare_message=check_file_parts)
     async def run(self, ctx: RunManager.RunContext) -> Any:
         payload, config = await self.messages.plan_turn(ctx)
         while True:
             try:
                 outcome = await self._stream_turn(ctx, payload, config)
-                await self.messages.ingest_turn(refetch=outcome is not None)
+                await self.messages.ingest_turn(
+                    refetch=outcome is not None, outcome=None if outcome is None else _interrupted(ctx)
+                )
+            except Exception as exc:
+                await self.messages.fail_turn(error_of(exc)["message"])
+                raise
             except BaseException:
-                self.messages.abandon_turn()
+                self.messages.abandon_turn(_interrupted(ctx))
                 raise
             if outcome is not None:
                 return outcome

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.0}/src/harness_sdk/parts.py

@@ -73,6 +73,7 @@ class PartsAssembler:
         text = text_of(content)
         if text:
             self._append_text("text", text, chunk_id)
+        self._cite(chunk)
         for tool_chunk in getattr(chunk, "tool_call_chunks", None) or []:
             key = (chunk_id, tool_chunk.get("index") or 0)
             tool_id = tool_chunk.get("id") or self._chunk_tools.get(key)
@@ -120,6 +121,18 @@ class PartsAssembler:
             elif call.get("args"):
                 self.parts[index]["input"] = call["args"]
 
+    def _cite(self, chunk: Any) -> None:
+        cited = {part["url"] for part in plain(self.parts) if part["type"] == "source"}
+        for block in chunk.content_blocks:
+            if block["type"] != "text":
+                continue
+            for note in block.get("annotations", []):
+                url = note.get("url") if note["type"] == "citation" else None
+                if url and url not in cited:
+                    cited.add(url)
+                    title = note.get("title")
+                    self.parts.append({"type": "source", "url": url, **({"title": title} if title else {})})
+
     def tool_result(self, message: Any) -> None:
         tool_id = getattr(message, "tool_call_id", None)
         index = self._index(tool_id) if tool_id else None

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.0}/src/harness_sdk/run_manager.py

@@ -79,9 +79,14 @@ from pinned.trays import Tray, TrayDescriptor, TrayCtx, TrayMapNamespace, inbox
 from pinned.trays import persistent, persistent_outbox, persistent_queue
 from statepatch import observable
 from statewire import StatewireReject
+from statewire.ops import encode_envelope
 
 logger = logging.getLogger(__name__)
 
+MAX_MESSAGE_ID_LENGTH = 256
+MAX_MESSAGE_BYTES = 1 << 20
+MAX_RUN_IDS = 4096
+
 _ABSENT: Any = object()
 _PARKED: Any = object()
 
@@ -110,16 +115,27 @@ _TRIGGERS = (
 
 _DECISIONS = ("approve", "reject", "edit", "respond")
 
-_RESERVED_KEYS = frozenset({"~admit"})
+_RESERVED_KEYS = frozenset({"~admit", "~parent"})
 
 
 def _reject(reason: str, message: str) -> StatewireReject:
     return StatewireReject(message, payload={"reason": reason})
 
 
+def error_of(exc: Exception) -> dict[str, Any]:
+    """A run's client-visible error: a reject's message and payload, any other exception's type name only."""
+    if isinstance(exc, StatewireReject):
+        if isinstance(exc.payload, dict):
+            return {**exc.payload, "message": exc.message}
+        if exc.payload is not None:
+            return {"message": exc.message, "payload": exc.payload}
+        return {"message": exc.message}
+    return {"message": type(exc).__name__}
+
+
 def _public(message: dict[str, Any]) -> dict[str, Any]:
-    """The message without its admission tag; the wire state is public."""
-    return {k: v for k, v in message.items() if k != "~admit"}
+    """The message without its reserved tags; the wire state is public."""
+    return {k: v for k, v in message.items() if k not in _RESERVED_KEYS}
 
 
 def _public_record(record: dict[str, Any]) -> dict[str, Any]:
@@ -158,6 +174,12 @@ def _validated_message(cls: "type[RunManager]", message: Any) -> dict[str, Any]:
         )
     if not isinstance(message.get("id"), str) or message["id"] == "":
         raise _reject("invalid-message", "message.id must be a non-empty string")
+    if len(message["id"]) > MAX_MESSAGE_ID_LENGTH:
+        raise _reject(
+            "invalid-message", f"message.id exceeds {MAX_MESSAGE_ID_LENGTH} characters"
+        )
+    if message["id"].startswith("voice-"):
+        raise _reject("invalid-message", "message.id uses the reserved voice- prefix")
     if message.get("role") != "user":
         raise _reject("invalid-message", 'message.role must be "user"')
     parts = message.get("parts")
@@ -198,9 +220,18 @@ def _validated_message(cls: "type[RunManager]", message: Any) -> dict[str, Any]:
     metadata = message.get("metadata", _ABSENT)
     if metadata is not _ABSENT and not isinstance(metadata, dict):
         raise _reject("invalid-message", "message.metadata must be an object")
-    parent_id = message.get("parentId", _ABSENT)
-    if parent_id is not _ABSENT and parent_id is not None and not isinstance(parent_id, str):
-        raise _reject("invalid-message", "message.parentId must be a string")
+    if "parentId" in message:
+        raise _reject(
+            "invalid-message", "message.parentId is not a send field: runAnchorMessageId names the parent"
+        )
+    try:
+        encoded = encode_envelope(message)
+    except (TypeError, ValueError, OverflowError, RecursionError) as exc:
+        raise _reject("invalid-message", "message is not wire-encodable") from exc
+    if len(encoded) > MAX_MESSAGE_BYTES:
+        raise _reject(
+            "invalid-message", f"message exceeds {MAX_MESSAGE_BYTES} encoded bytes"
+        )
     return message
 
 
@@ -291,7 +322,6 @@ class _Dequeue:
 
 @dataclass
 class _Edit:
-    source_id: str
     source_meta: dict[str, Any]
     message: dict[str, Any]
     meta: Any
@@ -602,7 +632,32 @@ class RunManager(Tray):
 
     # ─── Staging and advance ────────────────────────────────
 
+    def _tracked_ids(self) -> set[str]:
+        ids = set(self.dispatchedIds.value) | set(self.authors.value)
+        for lane in ("queue", "steerQueue"):
+            ids.update(item["id"] for item in self._lane_items(lane))
+        ids.update(item["id"] for _, item in self._batch)
+        if self._staged_rewind is not None:
+            ids.update(item["id"] for item in self._staged_rewind.messages)
+        for entry in self._intake:
+            if isinstance(entry, (_Send, _Edit)) and entry.message is not None:
+                ids.add(entry.message["id"])
+        return ids
+
+    def _check_id_capacity(self, ids: Iterable[str]) -> None:
+        known = self._tracked_ids()
+        added = set(ids) - known
+        if added and len(known) + len(added) > MAX_RUN_IDS:
+            raise _reject("run-full", f"run id limit reached ({MAX_RUN_IDS} unique ids)")
+
     def _admit(self, entry: Any) -> None:
+        if isinstance(entry, (_Send, _Edit)) and entry.message is not None:
+            try:
+                self._check_id_capacity((entry.message["id"],))
+            except StatewireReject as exc:
+                if not entry.future.done():
+                    entry.future.set_exception(exc)
+                return
         self._idle.clear()
         self._intake.append(entry)
         self._schedule(self._advance)
@@ -810,6 +865,7 @@ class RunManager(Tray):
             raise ValueError(f"invalid trigger: {trigger!r}")
         if self._in_flight():
             raise RuntimeError("a run is already in flight")
+        self._check_id_capacity(message["id"] for message in messages)
         record = self._record_of(
             trigger,
             list(messages),
@@ -838,7 +894,7 @@ class RunManager(Tray):
         ]
         if stripped:
             known = self.dispatchedIds.value
-            added = [m["id"] for m in stripped if m["id"] not in known]
+            added = list(dict.fromkeys(m["id"] for m in stripped if m["id"] not in known))
             if added:
                 self.dispatchedIds.value = [*known, *added]
         self.dispatching.value = _public_record(record)
@@ -876,7 +932,11 @@ class RunManager(Tray):
             elif record.get("inputOutcomes"):
                 root_meta = record["inputOutcomes"][0]["meta"]
         messages = [
-            {k: v for k, v in message.items() if k not in ("meta", "~admit")}
+            {
+                "parentId" if k == "~parent" else k: v
+                for k, v in message.items()
+                if k not in ("meta", "~admit")
+            }
             for message in record["messages"]
         ]
         ctx = RunManager.RunContext(
@@ -975,7 +1035,7 @@ class RunManager(Tray):
                     self.id,
                     getattr(fn, "__qualname__", repr(fn)),
                 )
-            error = self._error_of(exc)
+            error = error_of(exc)
             self.outcome.value = {
                 "kind": "error",
                 "epoch": self.epoch.value,
@@ -1036,15 +1096,6 @@ class RunManager(Tray):
             return
         self.delete()
 
-    def _error_of(self, exc: Exception) -> dict[str, Any]:
-        if isinstance(exc, StatewireReject):
-            if isinstance(exc.payload, dict):
-                return {**exc.payload, "message": exc.message}
-            if exc.payload is not None:
-                return {"message": exc.message, "payload": exc.payload}
-            return {"message": exc.message}
-        return {"message": type(exc).__name__}
-
     def _outcome_record(self, outcome: Any) -> dict[str, Any]:
         epoch = self.epoch.value
         if isinstance(outcome, RunManager.Complete):
@@ -1162,7 +1213,7 @@ class RunManager(Tray):
             if queue.value and queue.peek()["id"] == item["id"]:
                 queue.popleft()
         for lane, item in reversed(taken):
-            self._lane(lane).insert(0, item)
+            self._lane(lane).insert(0, {k: v for k, v in item.items() if k != "~parent"})
 
     def _dispatchable(self, lane: str) -> bool:
         # an unconsumed outcome means the settle is mid-drain: its follow-on decides
@@ -1200,8 +1251,11 @@ class RunManager(Tray):
         )
         if len(self._batch) + len(steer) >= self.max_queued:
             raise _reject("queue-full", f"queue is full ({self.max_queued} messages)")
+        staged = self._stamped(e.message, e.meta)
+        if not self._batch and not steer and e.anchor is not _ABSENT:
+            staged["~parent"] = e.anchor
         self._batch.extend(("steerQueue", item) for item in steer)
-        self._batch.append((e.lane, self._stamped(e.message, e.meta)))
+        self._batch.append((e.lane, staged))
         self.dispatching.value = _public_record(
             self._record_of(self._send_trigger(), [item for _, item in self._batch])
         )
@@ -1403,14 +1457,15 @@ class RunManager(Tray):
             self._check_anchor(e)
         # ids stay bound to their first author: a dequeued id re-enters authors-only
         self._check_author(e.message_id, e.principal)
-        if e.principal is not None:
-            self.authors.value = {**self.authors.value, e.message_id: e.principal}
+        self._check_id_capacity((e.message_id,))
         if self._dispatchable(e.lane):
             self._stage_batch(e)
         else:
             self._insert_new(e.lane, e.message, e.params, e.meta)
             if e.lane == "steerQueue":
                 fx.steer_added = True
+        if e.principal is not None:
+            self.authors.value = {**self.authors.value, e.message_id: e.principal}
         # A mint racing a live run merges into it; settle carries the surviving id.
         result = None if e.minted or e.anchor is _ABSENT else {"runId": self.id}
         fx.staged_sends.append((e.future, e.applied, result))
@@ -1498,14 +1553,12 @@ class RunManager(Tray):
 
     def _apply_edit(self, e: _Edit) -> Any:
         self._check_run_owner(e.principal)
+        self._check_id_capacity((e.message["id"],))
         staged = self._staged_rewind
         if (
             staged is not None
             and any(m["id"] == e.message["id"] for m in staged.messages)
-        ) or (
-            e.message["id"] != e.source_id
-            and self._lane_of(e.message["id"]) is not None
-        ):
+        ) or self._lane_of(e.message["id"]) is not None:
             raise _reject(
                 "duplicate-id", f"message id {e.message['id']} is already used"
             )
@@ -1541,8 +1594,17 @@ class RunManager(Tray):
     @inbox
     def admit_steer(self, message: dict[str, Any]) -> None:
         """Durably admit one steer message; a ``ctx.dispatch`` target."""
-        if not isinstance(message, dict) or not isinstance(message.get("id"), str):
-            raise TypeError(f"a steer message needs a string id, got {message!r}")
+        message = _validated_message(type(self), message)
+        admission = self.storage._admission
+        replay = admission is not None and (
+            admission.ignored or any(
+                item.get("~admit") == admission.key
+                for item in [*self.steerQueue._taken, *self.steerQueue.value]
+            )
+        )
+        if not replay:
+            self._check_id_capacity((message["id"],))
+            self._check_capacity("steerQueue")
         self._idle.clear()
         self.steerQueue.append(self._stamped(message, message.get("meta")))
         self._sync_steering()
@@ -1653,13 +1715,14 @@ class RunManager(Tray):
                 raise RuntimeError("take() after undo()")
             if manager.dispatching.value is not None:
                 raise RuntimeError("take before the current batch is applied")
+            manager._check_id_capacity(item["id"] for item in manager.steerQueue.value)
             items = manager.steerQueue.take_now()
             if not items:
                 return ()
             manager._pending_takes += len(items)
             manager._batch = [("steerQueue", item) for item in items]
             known = manager.dispatchedIds.value
-            added = [item["id"] for item in items if item["id"] not in known]
+            added = list(dict.fromkeys(item["id"] for item in items if item["id"] not in known))
             if added:
                 manager.dispatchedIds.value = [*known, *added]
             manager.dispatching.value = _public_record(
@@ -2172,15 +2235,11 @@ class RunManagerNamespace(TrayMapNamespace):
         message = _validated_message(
             cls, params.get("message") if isinstance(params, dict) else None
         )
-        if (
-            message["id"] != source_id
-            and await self._api.get_message_meta(message["id"]) is not None
-        ):
+        if await self._api.get_message_meta(message["id"]) is not None:
             raise _reject("duplicate-id", f"message id {message['id']} is already used")
         tray, _minted = await self._machine(run_id, auth_result)
         return await tray._stage(
             _Edit(
-                source_id,
                 source_meta,
                 message,
                 meta,