harness-sdk-python 0.12.0__tar.gz → 0.13.0__tar.gz

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.12.0
+Version: 0.13.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

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "harness-sdk-python"
-version = "0.12.0"
+version = "0.13.0"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/src/harness_sdk/run_manager.py

@@ -5,19 +5,28 @@ Implements the full state x command matrix from runs.mdx on a single
 
 Commands stage entries into an intake list and schedule a drain; the drain
 reduces the whole intake in order, then takes exactly one action based on
-status and net effect (interrupt, dispatch, or continue). A dispatchable send
-appends straight into ``dispatching`` — it never transits a queue lane — and
-everything staged there by the end of the drain dispatches as one run. Every
+status and net effect (rewind > send-dispatch > continue > input-resume). A
+dispatchable send appends straight into ``dispatching`` — it never transits a
+queue lane — and everything staged there by the end of the drain dispatches
+as one run; in error/stop the dispatch is the continuation
+(``error-continue`` / ``stop-continue``) carrying the send's messages. Every
 initiator acks and settles accepted with its state-visible application —
 sends with their insert (lane or ``dispatching``), edit/reload/continue at
 their dispatch; ``run/stop`` awaits a future the drain resolves once the
 in-flight run has ended.
 
-``entry["dispatching"]`` is the dispatch record (or None): the payload the
-run callback receives. ``ctx.ack()`` clears it; ``steering.take()`` may
-refill it — at most one unacked batch ever exists. Settle consumes the
-delivered batch, acked or not; steer entries still undelivered in the lane
-stay queued for the next run.
+``entry["dispatching"]`` is the dispatch record (absent between an ack and
+the next dispatch or take): the payload the run callback receives.
+``ctx.ack()`` clears it; ``steering.take()`` may refill it — at most one
+unacked batch ever exists. Settle consumes the delivered batch, acked or not;
+steer entries still undelivered in the lane stay queued for the next run.
+
+A mid-run stop or rewind opens a stopping window on the entry:
+``stopping: {reason}`` plus, for rewinds, the staged dispatch as
+``nextDispatch`` — written in the same envelope as the opener's pending
+answer. On run end one envelope promotes ``nextDispatch`` into
+``dispatching`` and clears the window; a later stop/rewind supersedes the
+staged one, which settles rejected (``superseded``).
 """
 
 import asyncio
@@ -44,9 +53,9 @@ _CAPABILITIES = frozenset(
 )
 
 _TRIGGERS = (
-    "message-send",
-    "message-edit",
-    "message-reload",
+    "send-message",
+    "edit-message",
+    "reload-message",
     "input-resume",
     "error-continue",
     "stop-continue",
@@ -140,6 +149,7 @@ class _Rewind:
     future: "asyncio.Future[Any]"
     run_id: str
     root_meta: Any = None
+    acked: bool = False
 
 
 @dataclass
@@ -201,7 +211,7 @@ class RunManager:
         self._outcome: Any = None
         self._staged_stops: list["asyncio.Future[Any]"] = []
         self._stop_reason: str | None = None
-        self._staged_rewinds: list[_Rewind] = []
+        self._staged_rewind: _Rewind | None = None
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
@@ -248,26 +258,33 @@ class RunManager:
         for lane in ("queue", "steerQueue"):
             if not isinstance(entry.get(lane), list):
                 raise ValueError(f"the restored {lane} must be a list")
-        for key in ("dispatching", "error"):
-            if entry.get(key, _ABSENT) is not None:
-                raise ValueError(f"the restored entry must carry {key}: None")
+        for key in ("dispatching", "error", "stopping", "nextDispatch"):
+            if key in entry:
+                raise ValueError(f"the restored entry must not carry {key}")
         requests = entry.get("inputRequests")
         if not isinstance(requests, list) or not requests:
             raise ValueError("the restored inputRequests must be a non-empty list")
+        answers: dict[str, Any] = {}
         for request in requests:
             if not isinstance(request, dict):
                 raise ValueError("restored input requests must be objects")
-            if request.get("response") is not None:
-                raise ValueError(
-                    "restored input requests must carry response: None"
+            if "response" in request:
+                if not isinstance(request["response"], dict):
+                    raise ValueError("a restored response must be an object")
+                answers[request.get("id")] = (
+                    request["response"],
+                    request.get("meta"),
                 )
         outcome = RunManager.InputRequired(
             tuple(
-                {k: v for k, v in request.items() if k != "response"}
+                {k: v for k, v in request.items() if k not in ("response", "meta")}
                 for request in requests
             )
         )
+        if len(answers) == len(requests):
+            raise ValueError("a fully answered pending set cannot restore")
         self._input_requests = [dict(r) for r in outcome.requests]
+        self._input_answers = answers
         self._state["status"] = "input-required"
 
     # ─── State access ───────────────────────────────────────
@@ -287,8 +304,6 @@ class RunManager:
                     "status": "ready",
                     "queue": [],
                     "steerQueue": [],
-                    "dispatching": None,
-                    "error": None,
                 }
             )
         return self._state["runs"][0]
@@ -345,12 +360,14 @@ class RunManager:
             self._staged_stops.clear()
             if isinstance(outcome, RunManager.Complete):
                 self._dispatched_ids = ()
-            if self._staged_rewinds:
-                rewind = self._staged_rewinds.pop(0)
+            if self._staged_rewind is not None:
+                rewind, self._staged_rewind = self._staged_rewind, None
                 self._clear_input()
                 if self._dispatching:
                     self._unstage_dispatching()
                 entry = self._ensure_entry()
+                entry.pop("stopping", None)
+                entry.pop("nextDispatch", None)
                 if entry["runId"] is None:
                     entry["runId"] = rewind.run_id
                 self._dispatch(
@@ -359,14 +376,17 @@ class RunManager:
                     rollback_to=rewind.rollback_to,
                     root_meta=rewind.root_meta,
                 )
-                rewind.ack()
+                if not rewind.acked:
+                    rewind.ack()
                 if not rewind.future.done():
                     rewind.future.set_result(None)
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
                 self._idle_action(fx)
-        if self._task is not None and (self._staged_stops or self._staged_rewinds):
+        if self._task is not None and (
+            self._staged_stops or self._staged_rewind is not None
+        ):
             assert self._ctx is not None
             self._ctx.stop_requested.set()
         for future, ack, result in fx.staged_sends:
@@ -382,6 +402,11 @@ class RunManager:
     def _apply(self, entry: Any, fx: _Effects) -> None:
         if isinstance(entry, _Stop):
             self._staged_stops.append(entry.future)
+            if self._task is not None:
+                if self._staged_rewind is not None:
+                    self._supersede()
+                    self._entry().pop("nextDispatch", None)
+                self._entry()["stopping"] = {"reason": "stop"}
             return
         if isinstance(entry, _Continue):
             if not fx.continue_requested:
@@ -413,10 +438,10 @@ class RunManager:
             if self._dispatching:
                 self._dispatch_staged()
         elif status in ("error", "stopped"):
-            if fx.continue_requested or fx.steer_added:
-                self._dispatch(self._continue_type(), [], root_meta=fx.continue_meta)
-            elif self._dispatching:
+            if self._dispatching:
                 self._dispatch_staged()
+            elif fx.continue_requested or fx.steer_added:
+                self._dispatch(self._continue_type(), [], root_meta=fx.continue_meta)
         elif status == "input-required":
             if self._dispatching:
                 self._dispatch_staged(input_outcomes=self._take_input_outcomes())
@@ -438,9 +463,7 @@ class RunManager:
             self._input_requests = [dict(r) for r in outcome.requests]
             self._input_answers = {}
             entry = self._entry()
-            entry["inputRequests"] = [
-                {**r, "response": None} for r in outcome.requests
-            ]
+            entry["inputRequests"] = [dict(r) for r in outcome.requests]
             self._set_status("input-required")
             return
         status = "error" if isinstance(outcome, RunManager.Error) else "stopped"
@@ -465,6 +488,27 @@ class RunManager:
         self._clear_input()
         return outcomes
 
+    def _record_of(
+        self,
+        trigger: str,
+        items: list[dict[str, Any]],
+        *,
+        rollback_to: Any = _ABSENT,
+        root_meta: Any = None,
+        input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = (),
+    ) -> dict[str, Any]:
+        record: dict[str, Any] = {"trigger": trigger, "messages": items}
+        if rollback_to is not _ABSENT:
+            record["rollbackTo"] = rollback_to
+        if root_meta is not None:
+            record["rootMeta"] = root_meta
+        if input_outcomes:
+            record["inputOutcomes"] = [
+                {"request": request, "response": response, "meta": meta}
+                for request, response, meta in input_outcomes
+            ]
+        return record
+
     def _dispatch(
         self,
         trigger: str,
@@ -483,19 +527,18 @@ class RunManager:
         messages = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
-        record: dict[str, Any] = {"trigger": trigger, "messages": items}
-        if rollback_to is not _ABSENT:
-            record["rollbackTo"] = rollback_to
-        if input_outcomes:
-            record["inputOutcomes"] = [
-                {"request": request, "response": response, "meta": meta}
-                for request, response, meta in input_outcomes
-            ]
+        record = self._record_of(
+            trigger,
+            items,
+            rollback_to=rollback_to,
+            root_meta=root_meta,
+            input_outcomes=input_outcomes,
+        )
         self._dispatch_record = dict(record)
         self._stop_reason = None
         entry = self._ensure_entry()
         entry["dispatching"] = record
-        entry["error"] = None
+        entry.pop("error", None)
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
         self._set_status("running")
@@ -555,30 +598,31 @@ class RunManager:
         self._dispatch_record = None
         self._dispatching = []
         entry = self._ensure_entry()
-        record = plain(entry["dispatching"])
+        record = plain(entry.get("dispatching"))
         if record is not None and record["trigger"] != "steer" and record["messages"]:
             self._dispatched_ids = ()
-        entry["dispatching"] = None
+        entry.pop("dispatching", None)
+        entry.pop("stopping", None)
 
     def _ack(self) -> None:
         entry = self._entry()
-        record = plain(entry["dispatching"])
+        record = plain(entry.get("dispatching"))
         if record is None:
             raise RuntimeError("ack() with no unacked batch")
         self._dispatching = []
-        entry["dispatching"] = None
+        entry.pop("dispatching", None)
 
     def _unstage_dispatching(self) -> None:
         taken, self._dispatching = self._dispatching, []
         entry = self._ensure_entry()
-        entry["dispatching"] = None
+        entry.pop("dispatching", None)
         for lane in ("steerQueue", "queue"):
             front = [item for taken_lane, item in taken if taken_lane == lane]
             if front:
                 entry[lane] = front + self._lane_items(lane)
 
     def _dispatchable(self, lane: str) -> bool:
-        if self._task is not None or self._staged_rewinds:
+        if self._task is not None or self._staged_rewind is not None:
             return False
         if self._dispatching:
             return True
@@ -595,6 +639,10 @@ class RunManager:
             )
         return False
 
+    def _send_trigger(self) -> str:
+        status = self._status()
+        return self._continue_type() if status in ("error", "stopped") else "send-message"
+
     def _stage_dispatch(self, e: _Send) -> None:
         assert e.message is not None
         steer = self._lane_items("steerQueue") if e.lane == "steerQueue" else []
@@ -605,7 +653,7 @@ class RunManager:
             self._dispatching.extend(("steerQueue", item) for item in steer)
         self._dispatching.append((e.lane, self._stamped(e.message, e.meta)))
         self._ensure_entry()["dispatching"] = {
-            "trigger": "message-send",
+            "trigger": self._send_trigger(),
             "messages": [item for _, item in self._dispatching],
         }
 
@@ -613,7 +661,7 @@ class RunManager:
         self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
     ) -> None:
         self._dispatch(
-            "message-send",
+            self._send_trigger(),
             [item for _, item in self._dispatching],
             input_outcomes=input_outcomes,
         )
@@ -625,16 +673,40 @@ class RunManager:
         if steer:
             self._entry()["steerQueue"] = []
             self._dispatching = [("steerQueue", item) for item in steer]
-            self._dispatch("message-send", steer, input_outcomes=input_outcomes)
+            self._dispatch("send-message", steer, input_outcomes=input_outcomes)
             return True
         queue = self._lane_items("queue")
         if queue:
             self._entry()["queue"].pop(0)
             self._dispatching = [("queue", queue[0])]
-            self._dispatch("message-send", [queue[0]], input_outcomes=input_outcomes)
+            self._dispatch("send-message", [queue[0]], input_outcomes=input_outcomes)
             return True
         return False
 
+    def _supersede(self) -> None:
+        rewind, self._staged_rewind = self._staged_rewind, None
+        assert rewind is not None
+        if not rewind.future.done():
+            rewind.future.set_exception(
+                _reject("superseded", "a later stop/rewind replaced this command")
+            )
+
+    def _stage_rewind(self, rewind: _Rewind) -> None:
+        if self._staged_rewind is not None:
+            self._supersede()
+        self._staged_rewind = rewind
+        if self._task is not None:
+            entry = self._entry()
+            entry["stopping"] = {"reason": rewind.type}
+            entry["nextDispatch"] = self._record_of(
+                rewind.type,
+                list(rewind.messages),
+                rollback_to=rewind.rollback_to,
+                root_meta=rewind.root_meta,
+            )
+            rewind.ack()
+            rewind.acked = True
+
     def _freeze(self, message: str, payload: Any = None) -> None:
         self._set_status("error")
         entry = self._entry()
@@ -915,9 +987,9 @@ class RunManager:
         if e.source_meta is None:
             raise _reject("unknown-id", f"message {e.message_id} is unknown")
         self._check_anchor(e)
-        self._staged_rewinds.append(
+        self._stage_rewind(
             _Rewind(
-                "message-edit",
+                "edit-message",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
                 e.ack,
@@ -956,7 +1028,10 @@ class RunManager:
                 f"input request {e.request_id} is already answered",
             )
         self._input_answers[e.request_id] = (e.response, e.meta)
-        self._entry()["inputRequests"][index]["response"] = e.response
+        replicated = self._entry()["inputRequests"][index]
+        replicated["response"] = e.response
+        if e.meta is not None:
+            replicated["meta"] = e.meta
         return None
 
     def _apply_edit(self, e: _Edit) -> Any:
@@ -967,9 +1042,9 @@ class RunManager:
             raise _reject(
                 "duplicate-id", f"message id {e.message['id']} is already used"
             )
-        self._staged_rewinds.append(
+        self._stage_rewind(
             _Rewind(
-                "message-edit",
+                "edit-message",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
                 e.ack,
@@ -980,9 +1055,9 @@ class RunManager:
         return _PARKED
 
     def _apply_reload(self, e: _Reload) -> Any:
-        self._staged_rewinds.append(
+        self._stage_rewind(
             _Rewind(
-                "message-reload",
+                "reload-message",
                 [],
                 e.source_meta["parentId"],
                 e.ack,
@@ -1280,7 +1355,7 @@ class RunManager:
             self._ctx._ensure_active()
             manager = self._ctx._manager
             entry = manager._entry()
-            if plain(entry["dispatching"]) is not None:
+            if plain(entry.get("dispatching")) is not None:
                 raise RuntimeError("take before the current batch is acked")
             items = manager._lane_items("steerQueue")
             if not items:

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/tests/test_ack_visibility.py

@@ -91,7 +91,7 @@ async def test_rewind_edit_acks_with_its_dispatch():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         seq = drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.trigger == "edit-message"
         await drv.wait_status("running")
         assert dispatching_ids(covered_state(drv, seq)) == ["u2"]
         host.live.state["messages"] = [msg("u2")]

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/tests/test_batches.py

@@ -5,7 +5,7 @@ drain takes exactly one action; late-settling commands ride a later envelope.
 import asyncio
 from typing import Any
 
-from run_helpers import Script, add, queue_ids, run_host
+from run_helpers import Script, add, edit_params, msg, queue_ids, run_host
 
 from harness_sdk import RunManager
 
@@ -21,7 +21,7 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
             ]
         )
         call = await script.next_call()
-        assert call.ctx.trigger == "message-send"
+        assert call.ctx.trigger == "send-message"
         assert [m["id"] for m in call.ctx.messages] == ["s1", "s2", "s3"]
         script.no_call()
         assert queue_ids(drv.replica, "steerQueue") == []
@@ -114,3 +114,71 @@ async def test_handler_tail_staging_decides_in_its_own_envelope():
         assert dispatch_env.get("ack", 0) >= seq
         assert (await drv.res(seq))["type"] == "accepted"
         call.ack()
+
+
+async def test_rewind_outranks_send_and_continue_in_one_batch():
+    script = Script()
+    async with run_host(
+        script, capabilities=("rewind", "incomplete-continuation")
+    ) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        script.thread["m1"] = {
+            "parentId": None,
+            "role": "user",
+            "isLeaf": True,
+            "onActiveBranch": True,
+        }
+        script.thread["a1"] = {
+            "parentId": "m1",
+            "role": "assistant",
+            "isLeaf": True,
+            "onActiveBranch": True,
+        }
+        call.ack()
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        first = drv.batch(
+            [
+                ("run/enqueue", add("q1", anchor="a1")),
+                ("run/edit", edit_params("m1", msg("m2"), anchor=None)),
+                ("run/continue", None),
+            ]
+        )
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "edit-message"
+        assert [m["id"] for m in rerun.ctx.messages] == ["m2"]
+        script.no_call()
+        assert (await drv.res(first))["type"] == "accepted"
+        assert (await drv.res(first + 1))["type"] == "accepted"
+        assert (await drv.res(first + 2))["type"] == "accepted"
+        assert queue_ids(drv.replica, "queue") == ["q1"]
+        rerun.ack()
+        rerun.finish(RunManager.Complete())
+
+
+async def test_send_outranks_the_completing_input_answer():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        request = {"type": "tool-call", "id": "r1", "toolCallId": "tc1"}
+        call.finish(RunManager.InputRequired((request,)))
+        await drv.wait_status("input-required")
+        first = drv.batch(
+            [
+                ("run/input", {"requestId": "r1", "response": {"output": "ok"}}),
+                ("run/steer", add("s1")),
+            ]
+        )
+        run = await script.next_call()
+        assert run.ctx.trigger == "send-message"
+        assert [m["id"] for m in run.ctx.messages] == ["s1"]
+        assert run.ctx.input_outcomes == ((request, {"output": "ok"}, None),)
+        script.no_call()
+        assert (await drv.res(first))["type"] == "accepted"
+        assert (await drv.res(first + 1))["type"] == "accepted"
+        run.ack()
+        run.finish(RunManager.Complete())
+        await drv.wait_status("ready")

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/tests/test_branch_anchor.py

@@ -196,7 +196,7 @@ async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-reload"
+        assert call.ctx.trigger == "reload-message"
         call.ack()
         script.thread["a1"] = {
             "parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/tests/test_dispatching.py

@@ -17,7 +17,7 @@ from statewire_helpers import apply_ops
 
 def dispatching_ids(replica):
     runs = replica["runs"]
-    record = runs[0]["dispatching"] if runs else None
+    record = runs[0].get("dispatching") if runs else None
     return [item["id"] for item in record["messages"]] if record else []
 
 
@@ -58,7 +58,7 @@ async def test_idle_send_dispatches_straight_into_dispatching():
         drv.post("run/enqueue", add("m1"))
         await script.next_call()
         await drv.wait_status("running")
-        assert drv.run["dispatching"]["trigger"] == "message-send"
+        assert drv.run["dispatching"]["trigger"] == "send-message"
         assert dispatching_ids(drv.replica) == ["m1"]
         assert queue_ids(drv.replica, "queue") == []
         assert residence(drv, "m1") == ["dispatching"]
@@ -119,7 +119,7 @@ async def test_edit_replacement_rides_dispatching_until_ack():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         seq = drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.trigger == "edit-message"
         await drv.wait_status("running")
         assert dispatching_ids(drv.replica) == ["u2"]
         host.live.state["messages"] = [msg("u2")]

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/tests/test_edit_dispatched.py

@@ -19,7 +19,7 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
         await drv.wait_status("running")
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.trigger == "edit-message"
         assert [m["parts"][0]["text"] for m in rerun.ctx.messages] == ["edited"]
         assert rerun.ctx.has_rollback
         assert rerun.ctx.rollback_to == "p0"
@@ -54,7 +54,7 @@ async def test_edit_of_dispatched_non_leaf_stops_and_reruns(command):
         seq = drv.post(command, target(message=msg("m1", "edited")))
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.trigger == "edit-message"
         assert [m["parts"][0]["text"] for m in rerun.ctx.messages] == ["edited"]
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
@@ -72,7 +72,7 @@ async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
         seq = drv.post("run/enqueue", target(message=msg("m1", "edited")))
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.trigger == "edit-message"
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(seq))["type"] == "accepted"
@@ -90,5 +90,5 @@ async def test_edit_of_dispatched_item_in_error_reruns_without_stop():
         await drv.wait_status("error")
         drv.post("run/enqueue", target(message=msg("m1", "edited")))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.trigger == "edit-message"
         assert rerun.ctx.rollback_to is None

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.0}/tests/test_edit_reload.py

@@ -27,7 +27,7 @@ async def test_edit_in_ready_dispatches_message_edit():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/edit", edit_params("u1", msg("u2", "v2"), anchor=None))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-edit"
+        assert call.ctx.trigger == "edit-message"
         assert [m["id"] for m in call.ctx.messages] == ["u2"]
         assert call.ctx.has_rollback
         assert call.ctx.rollback_to is None
@@ -71,7 +71,7 @@ async def test_deep_edit_with_queue_non_empty_reruns_and_keeps_queue():
         await drv.wait_status("error")
         drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         rerun = await script.next_call()
-        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.trigger == "edit-message"
         assert rerun.ctx.rollback_to is None
         assert [item["id"] for item in drv.run["queue"]] == ["m2"]
 
@@ -88,7 +88,7 @@ async def test_leaf_edit_in_error_accepted_with_queue_non_empty():
         await drv.wait_status("error")
         drv.post("run/edit", edit_params("m1", msg("u2"), anchor=None))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-edit"
+        assert call.ctx.trigger == "edit-message"
         assert call.ctx.rollback_to is None
         assert [item["id"] for item in drv.run["queue"]] == ["m2"]
 
@@ -140,7 +140,7 @@ async def test_reload_dispatches_with_empty_messages():
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-reload"
+        assert call.ctx.trigger == "reload-message"
         assert call.ctx.messages == ()
         assert call.ctx.rollback_to == "u1"
         call.ack()
@@ -205,7 +205,7 @@ async def test_deep_reload_with_queue_non_empty_reruns_and_keeps_queue():
         await drv.wait_status("error")
         drv.post("run/reload", reload_params("a0", anchor="u0"))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-reload"
+        assert call.ctx.trigger == "reload-message"
         assert call.ctx.rollback_to == "u0"
         assert [item["id"] for item in drv.run["queue"]] == ["m2"]
 
@@ -260,7 +260,7 @@ async def test_edit_anchor_assertion():
         script.no_call()
         drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-edit"
+        assert call.ctx.trigger == "edit-message"
         assert call.ctx.rollback_to is None
 
 
@@ -283,5 +283,5 @@ async def test_reload_anchor_assertion():
         script.no_call()
         drv.post("run/reload", reload_params("a1", anchor="u1"))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-reload"
+        assert call.ctx.trigger == "reload-message"
         assert call.ctx.rollback_to == "u1"