harness-sdk-python 0.17.0__tar.gz → 0.18.0__tar.gz

{harness_sdk_python-0.17.0 → harness_sdk_python-0.18.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.17.0
+Version: 0.18.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.12,>=0.11.0
-Requires-Dist: statewire<0.10,>=0.9.0
+Requires-Dist: pinned<0.13,>=0.12.0
+Requires-Dist: statewire<0.10,>=0.9.2
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.17.0 → harness_sdk_python-0.18.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.17.0"
+version = "0.18.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.9.0,<0.10", "pinned>=0.11.0,<0.12"]
+dependencies = ["statewire>=0.9.2,<0.10", "pinned>=0.12.0,<0.13"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.17.0 → harness_sdk_python-0.18.0}/src/harness_sdk/run_manager.py

@@ -19,8 +19,12 @@ the unconfirmed batch record; ``ctx.applied()`` confirms it durably,
 ``steering.take()`` may refill it via deferred durable pops — at most one
 unconfirmed batch ever exists. Settle consumes a confirmed batch; a batch
 still unconfirmed at settle returns to the front of its lanes (after a crash,
-unconfirmed taken entries re-present there on their own). ``Complete`` with
-an unconfirmed batch settles as an error.
+unconfirmed taken entries re-present there on their own). A batch already
+durably confirmed redelivers in resume mode instead (``ctx.resume``): the
+input batch must not be re-dispatched (``messages`` and the rollback surface
+raise; meta and input outcomes stay readable) and the run continues from its
+own continuation state (``ctx.state`` or an external checkpointer).
+``Complete`` with an unconfirmed batch settles as an error.
 
 ``epoch`` counts the entry's dispatches (not redeliveries); a ``run/stop``
 carrying an ``epoch`` other than the live one rejects. A mid-run stop or
@@ -187,6 +191,7 @@ class RunManager(Tray):
     queue = persistent_queue()
     steerQueue = persistent_queue()
     outbox = persistent_outbox()  # {"record": ..., "lanes": [...]}: the in-flight dispatch
+    outcome = persistent(None)  # the settled run's verdict, held until its follow-on lands
     batchApplied = persistent(False)
     confirmedTakes = persistent(0)
     runId = persistent(None)
@@ -260,6 +265,13 @@ class RunManager(Tray):
 
     def _hydrate_machine(self) -> None:
         self.steerQueue.take_now(self.confirmedTakes.value)
+        settled = self.outcome.value
+        if settled is not None:
+            if self.outbox.value is not None and self.epoch.value != settled["epoch"]:
+                self.outcome.value = None  # the follow-on dispatch landed: the settle is done
+            else:
+                self._replay_settle()
+                self._outcome = settled
         recorded = self.outbox.value
         if recorded is not None and not self.batchApplied.value:
             record = recorded["item"]["record"]
@@ -268,7 +280,19 @@ class RunManager(Tray):
             self.dispatching.value = record
         else:
             self.dispatching.value = None
+        if recorded is not None:
+            # heal a dispatch torn after its outbox write landed
+            self._clear_input()
+            self.error.value = None
+            self._set_status("running")
         staged = self.nextDispatch.value
+        if (
+            staged is not None
+            and recorded is not None
+            and recorded["item"]["record"] == staged
+        ):
+            self.nextDispatch.value = None  # torn promotion: the outbox carries it
+            staged = None
         if staged is not None:
             self._staged_rewind = _Rewind(
                 staged["trigger"],
@@ -319,6 +343,8 @@ class RunManager(Tray):
         return self._lane(lane).value
 
     def _lane_of(self, message_id: str) -> str | None:
+        if self._is_dispatching(message_id):
+            return None  # claimed by the staged batch; its lane entry is spoken for
         for lane in ("steerQueue", "queue"):
             if any(item["id"] == message_id for item in self._lane_items(lane)):
                 return lane
@@ -369,15 +395,12 @@ class RunManager(Tray):
         fx = self._apply_intake()
         if not self._in_flight():
             self._stop_staged = False
-            if isinstance(outcome, RunManager.Complete):
+            if outcome is not None and outcome["kind"] == "complete":
                 self.dispatchedIds.value = []
             if self._staged_rewind is not None:
                 rewind, self._staged_rewind = self._staged_rewind, None
-                self._clear_input()
                 if self._batch:
                     self._unstage_batch()
-                self.stopping.value = None
-                self.nextDispatch.value = None
                 if self.runId.value is None:
                     self.runId.value = rewind.run_id
                 self._dispatch(
@@ -392,6 +415,8 @@ class RunManager(Tray):
                 self._settle_outcome(outcome)
             else:
                 self._idle_action(fx)
+            if self.outcome.value is not None:
+                self.outcome.value = None  # the follow-on's writes are enlisted ahead
         if self._in_flight() and (
             self._stop_staged or self._staged_rewind is not None
         ):
@@ -448,31 +473,35 @@ class RunManager(Tray):
                 self._dispatch(self._continue_type(), [], root_meta=fx.continue_meta)
         elif status == "input-required":
             if self._batch:
-                self._dispatch_staged(input_outcomes=self._take_input_outcomes())
+                self._dispatch_staged(input_outcomes=self._input_outcomes())
             elif fx.steer_added and self._lane_items("steerQueue"):
-                self._pop_dispatchable(input_outcomes=self._take_input_outcomes())
+                self._pop_dispatchable(input_outcomes=self._input_outcomes())
             elif self._input_requests and len(self._input_answers) == len(
                 self._input_requests
             ):
                 self._dispatch(
-                    "input-resume", [], input_outcomes=self._take_input_outcomes()
+                    "input-resume", [], input_outcomes=self._input_outcomes()
                 )
 
-    def _settle_outcome(self, outcome: Any) -> None:
-        if isinstance(outcome, RunManager.Complete):
+    def _settle_outcome(self, outcome: dict[str, Any]) -> None:
+        kind = outcome["kind"]
+        if kind == "complete":
             if not self._pop_dispatchable():
                 self._to_ready()
             return
-        if isinstance(outcome, RunManager.InputRequired):
-            self._input_requests = [dict(r) for r in outcome.requests]
+        if kind == "input-required":
+            requests = outcome["requests"]
+            self._input_requests = [dict(r) for r in requests]
             self._input_answers = {}
-            self.inputRequests.value = [dict(r) for r in outcome.requests]
+            self.inputRequests.value = [dict(r) for r in requests]
             self._set_status("input-required")
             return
-        status = "error" if isinstance(outcome, RunManager.Error) else "stopped"
-        if outcome.dispatch_queue and self._pop_dispatchable():
+        if outcome["dispatchQueue"] and self._pop_dispatchable():
             return
-        self._set_status(status)
+        error = outcome.get("error")
+        if error is not None:
+            self.error.value = error
+        self._set_status("error" if kind == "error" else "stopped")
 
     # ─── Dispatch and settle ────────────────────────────────
 
@@ -481,13 +510,11 @@ class RunManager(Tray):
         self._input_answers = {}
         self.inputRequests.value = None
 
-    def _take_input_outcomes(self) -> tuple[tuple[dict[str, Any], Any, Any], ...]:
-        outcomes = tuple(
+    def _input_outcomes(self) -> tuple[tuple[dict[str, Any], Any, Any], ...]:
+        return tuple(
             (request, *self._input_answers.get(request["id"], (None, None)))
             for request in self._input_requests
         )
-        self._clear_input()
-        return outcomes
 
     def _record_of(
         self,
@@ -530,19 +557,25 @@ class RunManager(Tray):
             root_meta=root_meta,
             input_outcomes=input_outcomes,
         )
+        item = {"record": record, "lanes": [lane for lane, _ in self._batch]}
         self.stopReason.value = None
         self.epoch.value = self.epoch.value + 1
-        self.outbox.dispatch(
-            {"record": record, "lanes": [lane for lane, _ in self._batch]}
-        )
+        self.outbox.dispatch(item)
         self._fresh = True
+        self._reclaim(item)  # the record owns its sources: consume them behind it
+        self.nextDispatch.value = None
+        self.stopping.value = None
+        self._clear_input()
         self.batchApplied.value = False
         self.error.value = None
         stripped = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
         if stripped:
-            self.dispatchedIds.value = [m["id"] for m in stripped]
+            known = self.dispatchedIds.value
+            added = [m["id"] for m in stripped if m["id"] not in known]
+            if added:
+                self.dispatchedIds.value = [*known, *added]
         self._set_status("running")
         self.dispatching.value = record
         self._idle.clear()
@@ -582,7 +615,8 @@ class RunManager(Tray):
         ]
         ctx = RunManager.RunContext(
             trigger=record["trigger"],
-            messages=tuple(messages),
+            _resume=self.batchApplied.value or self.confirmedTakes.value > 0,
+            _messages=tuple(messages),
             stop_requested=asyncio.Event(),
             _manager=self,
             _rollback_to=record["rollbackTo"] if "rollbackTo" in record else _ABSENT,
@@ -638,34 +672,80 @@ class RunManager(Tray):
         except asyncio.CancelledError:
             if self._closing or self.storage._retired is not None:
                 raise  # teardown: the un-acked outbox redelivers next activation
+            self.outcome.value = {
+                "kind": "cancel",
+                "epoch": self.epoch.value,
+                "dispatchQueue": False,
+            }
             self._settle(ctx)
             fx = self._apply_intake()
+            rewind = self._staged_rewind
+            if rewind is not None and not rewind.applied_sent:
+                # park the in-drain rewind durably; a cancel starts no dispatch
+                self.nextDispatch.value = self._record_of(
+                    rewind.type,
+                    list(rewind.messages),
+                    rollback_to=rewind.rollback_to,
+                    root_meta=rewind.root_meta,
+                )
+                rewind.applied()
+                rewind.applied_sent = True
             self._set_status("stopped")
+            self.outcome.value = None
             self._settle_applied(fx)
             self._idle.set()
             raise  # staged intake settled; a cancelled run starts no dispatch
         except Exception as exc:
-            self._settle(ctx)
-            message = str(exc) or type(exc).__name__
-            if isinstance(exc, StatewireReject):
-                self._freeze(exc.message, exc.payload)
-            else:
+            if not isinstance(exc, StatewireReject):
                 logger.exception(
                     "run %r crashed in %s",
                     self.runId.value,
                     getattr(fn, "__qualname__", repr(fn)),
                 )
-                self._freeze(message)
+            error = self._error_of(exc)
+            self.outcome.value = {
+                "kind": "error",
+                "epoch": self.epoch.value,
+                "dispatchQueue": False,
+                "error": error,
+            }
+            self._settle(ctx)
+            self._set_status("error")
+            self.error.value = error
             self._advance()
             return
+        self.outcome.value = self._outcome_record(outcome)
         self._settle(ctx)
-        self._outcome = outcome
+        self._outcome = self.outcome.value
         self._advance()
 
+    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": str(exc) or type(exc).__name__}
+
+    def _outcome_record(self, outcome: Any) -> dict[str, Any]:
+        epoch = self.epoch.value
+        if isinstance(outcome, RunManager.Complete):
+            return {"kind": "complete", "epoch": epoch}
+        if isinstance(outcome, RunManager.InputRequired):
+            return {
+                "kind": "input-required",
+                "epoch": epoch,
+                "requests": [dict(r) for r in outcome.requests],
+            }
+        kind = "error" if isinstance(outcome, RunManager.Error) else "stop"
+        return {"kind": kind, "epoch": epoch, "dispatchQueue": outcome.dispatch_queue}
+
     def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._run_live is ctx:
             self._run_live = None
         if self._batch:
+            self._drop_dispatched(item["id"] for _, item in self._batch)
             self._unstage_batch()
         else:
             record = self.dispatching.value
@@ -674,13 +754,36 @@ class RunManager(Tray):
                 and record["trigger"] != "steer"
                 and record["messages"]
             ):
-                self.dispatchedIds.value = []
+                # an unapplied rewind settled: its replacement never landed
+                self._drop_dispatched(m["id"] for m in record["messages"])
             self.dispatching.value = None
+        self._finish_settle()
+
+    def _drop_dispatched(self, ids: Iterable[str]) -> None:
+        dropped = set(ids)
+        kept = [i for i in self.dispatchedIds.value if i not in dropped]
+        if len(kept) != len(self.dispatchedIds.value):
+            self.dispatchedIds.value = kept
+
+    def _finish_settle(self) -> None:
         self.stopping.value = None
-        self.batchApplied.value = False
         self.confirmedTakes.value = 0
+        self.batchApplied.value = False
         self._clear_dispatch_state()  # commits confirmed takes; drops the run's checkpoint
-        self.outbox.ack()
+        if self.outbox.value is not None:
+            self.outbox.ack()
+
+    def _replay_settle(self) -> None:
+        recorded = self.outbox.value
+        if recorded is not None and not self.batchApplied.value:
+            item = recorded["item"]
+            record = item["record"]
+            self._batch = list(zip(item["lanes"], record["messages"]))
+            self._drop_dispatched(m["id"] for m in record["messages"])
+        if self._batch:
+            self._unstage_batch()
+        self.dispatching.value = None
+        self._finish_settle()
 
     def _applied(self) -> None:
         if self.dispatching.value is None:
@@ -700,6 +803,10 @@ class RunManager(Tray):
             self.steerQueue.untake(self._pending_takes)
             self._pending_takes = 0
             return
+        for lane, item in taken:  # claimed heads the dispatch never consumed
+            queue = self._lane(lane)
+            if queue.value and queue.peek()["id"] == item["id"]:
+                queue.popleft()
         for lane, item in reversed(taken):
             self._lane(lane).insert(0, item)
 
@@ -727,12 +834,18 @@ class RunManager(Tray):
 
     def _stage_batch(self, e: _Send) -> None:
         assert e.message is not None
-        steer = self._lane_items("steerQueue") if e.lane == "steerQueue" else []
+        steer = (
+            [
+                item
+                for item in self._lane_items("steerQueue")
+                if not self._is_dispatching(item["id"])
+            ]
+            if e.lane == "steerQueue"
+            else []
+        )
         if len(self._batch) + len(steer) >= self.max_queued:
             raise _reject("queue-full", f"queue is full ({self.max_queued} messages)")
-        if steer:
-            self.steerQueue.value = []
-            self._batch.extend(("steerQueue", item) for item in steer)
+        self._batch.extend(("steerQueue", item) for item in steer)
         self._batch.append((e.lane, self._stamped(e.message, e.meta)))
         self.dispatching.value = {
             "trigger": self._send_trigger(),
@@ -753,12 +866,11 @@ class RunManager(Tray):
     ) -> bool:
         steer = self._lane_items("steerQueue")
         if steer:
-            self.steerQueue.value = []
             self._batch = [("steerQueue", item) for item in steer]
             self._dispatch("message-send", steer, input_outcomes=input_outcomes)
             return True
         if self._lane_items("queue"):
-            item = self.queue.popleft()
+            item = self.queue.peek()
             self._batch = [("queue", item)]
             self._dispatch("message-send", [item], input_outcomes=input_outcomes)
             return True
@@ -779,15 +891,6 @@ class RunManager(Tray):
         if not rewind.future.done():
             rewind.future.set_result(None)
 
-    def _freeze(self, message: str, payload: Any = None) -> None:
-        self._set_status("error")
-        if isinstance(payload, dict):
-            self.error.value = {**payload, "message": message}
-        elif payload is not None:
-            self.error.value = {"message": message, "payload": payload}
-        else:
-            self.error.value = {"message": message}
-
     # ─── Message and placement validation ───────────────────
 
     def _prepared(
@@ -1444,6 +1547,10 @@ class RunManager(Tray):
                 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]
+            if added:
+                manager.dispatchedIds.value = [*known, *added]
             manager.dispatching.value = {"trigger": "steer", "messages": items}
             self._ctx._message_meta.update(
                 {item["id"]: item.get("meta") for item in items}
@@ -1456,8 +1563,9 @@ class RunManager(Tray):
     @dataclass(frozen=True, eq=False)
     class RunContext:
         trigger: str
-        messages: tuple[dict[str, Any], ...]
         stop_requested: asyncio.Event
+        _resume: bool
+        _messages: tuple[dict[str, Any], ...]
         _manager: "RunManager"
         _rollback_to: Any
         _message_meta: dict[str, Any]
@@ -1471,6 +1579,24 @@ class RunManager(Tray):
                 self, "steering", RunManager.Steering(asyncio.Event(), self)
             )
 
+        @property
+        def resume(self) -> bool:
+            """True when the batch was already durably applied before this redelivery: do not re-apply it, continue from the app's own continuation state."""
+            return self._resume
+
+        def _batch_only(self, name: str) -> None:
+            if self._resume:
+                raise RuntimeError(
+                    f"{name} is unavailable on a resume: the batch is already applied and"
+                    " must not be re-dispatched; continue from app-defined state"
+                )
+
+        @property
+        def messages(self) -> tuple[dict[str, Any], ...]:
+            """The dispatched input batch; unavailable on a resume."""
+            self._batch_only("messages")
+            return self._messages
+
         def meta(self, message_id: str | None = None) -> Any:
             """Op meta: a dispatched message's by id, or the run-starting op's with no id."""
             if message_id is None:
@@ -1490,10 +1616,12 @@ class RunManager(Tray):
 
         @property
         def has_rollback(self) -> bool:
+            self._batch_only("has_rollback")
             return self._rollback_to is not _ABSENT
 
         @property
         def rollback_to(self) -> str | None:
+            self._batch_only("rollback_to")
             if self._rollback_to is _ABSENT:
                 raise AttributeError(
                     "rollback_to is only present on rewind entries; check has_rollback"

{harness_sdk_python-0.17.0 → harness_sdk_python-0.18.0}/tests/test_durability.py

@@ -1,13 +1,12 @@
 """Contract: the durable seams of the run machine. A verdict never outruns the
 admission's flush; a crash redelivers the in-flight dispatch with its checkpoint
-and its epoch; a torn storage segment reconciles on the next activation; and the
-rich mid-flight state — the stopping window with its staged rewind, the applied
-batch, an unconfirmed steering take, and half-answered input requests — all
-hydrate back on the restarted machine.
+and its epoch; and the rich mid-flight state — the stopping window with its
+staged rewind, the applied batch, an unconfirmed steering take, and
+half-answered input requests — all hydrate back on the restarted machine.
+Torn storage segments are swept exhaustively in test_run_crash_sweep.py.
 """
 
 import asyncio
-import contextlib
 
 from pinned.testing import BarrierStateStore, MemoryStateStore
 from run_helpers import (
@@ -38,26 +37,6 @@ def survivors(store: MemoryStateStore) -> MemoryStateStore:
     return seeded(MemoryStateStore(), store)
 
 
-class TornStore(MemoryStateStore):
-    """Cuts the first batch writing under ``key`` right before that entry: the
-    writes ahead of it land, the rest of the segment is lost."""
-
-    def __init__(self, key: str) -> None:
-        super().__init__()
-        self._key = key
-        self.tore = asyncio.Event()
-
-    async def save_many(self, ns, id, entries, epoch) -> None:
-        paths = list(entries)
-        cut = next((i for i, path in enumerate(paths) if self._key in path), None)
-        if self.tore.is_set() or cut is None:
-            await super().save_many(ns, id, entries, epoch)
-            return
-        self.tore.set()
-        await super().save_many(ns, id, {p: entries[p] for p in paths[:cut]}, epoch)
-        raise RuntimeError("crash mid-segment")
-
-
 async def flush(host) -> None:
     """Await the machine's durable frontier: the crash point is everything before it."""
     await (await host.live.runs.get()).storage._frontier.wait()
@@ -114,39 +93,6 @@ async def test_a_crash_mid_run_redelivers_from_the_checkpoint():
         await drv2.wait_status("ready")
 
 
-async def test_a_torn_dispatch_segment_reconciles_on_the_next_activation():
-    store = MemoryStateStore()
-    script = Script()
-    async with run_host(script, store=store) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.applied()
-        await drv.command("run/enqueue", add("m2"), terminal=False)
-        await flush(host)
-        crashed = survivors(store)
-
-    torn = seeded(TornStore("queue"), crashed)
-    script2 = Script()
-    with contextlib.suppress(Exception):
-        async with run_host(script2, store=torn) as (drv2, host2):
-            redelivered = await script2.next_call()  # m1's batch is already confirmed
-            redelivered.finish(RunManager.Complete())  # settling m1 tears on m2's pop
-            await asyncio.wait_for(torn.tore.wait(), 5)
-            crashed = survivors(torn)
-
-    # m2's dispatch record landed; the queue entry it came from never cleared
-    assert any(key[2][:3] == ("runs", "~", "queue") for key in crashed.states)
-    script3 = Script()
-    async with run_host(script3, store=crashed) as (drv3, host3):
-        again = await script3.next_call()
-        assert [m["id"] for m in again.ctx.messages] == ["m2"]
-        again.applied()
-        again.finish(RunManager.Complete())
-        await drv3.wait_status("ready")
-        assert queue_ids(drv3.replica, "queue") == []
-        script3.no_call()  # the redelivery reclaimed the lane entry: no second run
-
-
 async def test_a_stale_epoch_stop_rejects_across_a_redelivery():
     store = MemoryStateStore()
     script = Script()
@@ -223,12 +169,14 @@ async def test_a_staged_rewind_survives_a_crash_in_the_stopping_window():
         await drv2.wait_status("ready")
 
 
-async def test_an_applied_batch_is_not_requeued_after_a_crash():
+async def test_an_applied_batch_redelivers_as_a_resume():
     store = MemoryStateStore()
     script = Script()
     async with run_host(script, store=store) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
+        assert call.ctx.resume is False
+        call.ctx.set_state({"step": 1})
         call.applied()
         await flush(host)
         crashed = survivors(store)
@@ -236,7 +184,23 @@ async def test_an_applied_batch_is_not_requeued_after_a_crash():
     script2 = Script()
     async with run_host(script2, store=crashed) as (drv2, host2):
         redelivered = await script2.next_call()
-        assert [m["id"] for m in redelivered.ctx.messages] == ["m1"]
+        assert redelivered.ctx.resume is True
+        assert redelivered.ctx.state == {"step": 1}
+        # informational reads of the applied batch stay open
+        assert redelivered.ctx.meta() is None
+        assert redelivered.ctx.meta("m1") is None
+        assert redelivered.ctx.input_outcomes == ()
+        for read in (
+            lambda: redelivered.ctx.messages,
+            lambda: redelivered.ctx.has_rollback,
+            lambda: redelivered.ctx.rollback_to,
+        ):
+            try:
+                read()
+            except RuntimeError:
+                pass
+            else:
+                raise AssertionError("a resume exposed a re-dispatchable batch")
         redelivered.finish(RunManager.Stop(dispatch_queue=True))
         await drv2.wait_status("stopped")
         assert queue_ids(drv2.replica, "queue") == []
@@ -259,9 +223,10 @@ async def test_an_unconfirmed_take_re_presents_on_the_restarted_steer_lane():
     script2 = Script()
     async with run_host(script2, store=crashed) as (drv2, host2):
         redelivered = await script2.next_call()
-        assert [m["id"] for m in redelivered.ctx.messages] == ["m1"]
+        assert redelivered.ctx.resume is True
         await drv2.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
         assert [m["id"] for m in redelivered.ctx.steering.take()] == ["s1"]
+        assert redelivered.ctx.meta("s1") is None  # a take's meta stays readable
         redelivered.applied()
         redelivered.finish(RunManager.Complete())
         await drv2.wait_status("ready")

{harness_sdk_python-0.17.0 → harness_sdk_python-0.18.0}/tests/test_edit_dispatched.py

@@ -30,10 +30,9 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
         assert settled["type"] == "accepted"
 
 
-@pytest.mark.parametrize("capabilities", [(), ("rewind",)])
-async def test_edit_of_dispatched_item_requires_rewind_during_run(capabilities):
+async def test_edit_of_dispatched_item_requires_rewind_during_run():
     script = Script()
-    async with run_host(script, capabilities=capabilities) as (drv, host):
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         (await script.next_call()).applied()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}

{harness_sdk_python-0.17.0 → harness_sdk_python-0.18.0}/tests/test_edit_reload.py

@@ -110,7 +110,12 @@ async def test_edit_unknown_source_and_duplicate_replacement():
             "duplicate-id",
         )
         drv.post("run/edit", edit_params("u1", msg("u1", "v2"), anchor=None))
-        await script.next_call()
+        call = await script.next_call()
+        assert call.ctx.trigger == "message-edit"
+        assert [(m["id"], m["parts"][0]["text"]) for m in call.ctx.messages] == [
+            ("u1", "v2")
+        ]
+        assert call.ctx.rollback_to is None
 
 
 async def test_edit_of_assistant_message_requires_assistant_edit():

{harness_sdk_python-0.17.0 → harness_sdk_python-0.18.0}/tests/test_enqueue.py

@@ -13,8 +13,12 @@ async def test_ready_add_dispatches_message_send():
         assert [m["id"] for m in call.ctx.messages] == ["m1"]
         assert not call.ctx.has_rollback
         await drv.wait_status("running")
-        assert "dispatch" not in drv.replica
+        assert drv.run["dispatching"] == {
+            "trigger": "message-send",
+            "messages": [msg("m1")],
+        }
         call.applied()
+        await drv.wait(lambda s: run_of(s)["dispatching"] is None)
         assert (await drv.res(seq))["type"] == "accepted"
         call.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -142,12 +146,13 @@ async def test_move_of_dispatched_item():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         (await script.next_call()).applied()
+        await drv.command("run/steer", add("s1"), terminal=False)
         assert_rejected(
             await drv.command("run/enqueue", target(messageId="m1"), terminal=False), "already-dispatched"
         )
         res = await drv.command("run/steer", target(messageId="m1"), terminal=False)
         assert res["type"] == "accepted"
-        assert queue_ids(drv.replica, "steerQueue") == []
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
         script.no_call()