harness-sdk-python 0.6.0__tar.gz → 0.7.0__tar.gz

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/.gitignore

@@ -20,3 +20,4 @@ __pycache__
 # agentdoc mounted docs
 /d[0-9]*.md
 /doc_*.md
+apps/docs/.docs

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.6.0
+Version: 0.7.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.6.0 → harness_sdk_python-0.7.0}/pyproject.toml

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

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/src/harness_sdk/fenced_postgres.py

@@ -7,7 +7,7 @@ try:
     from langchain_core.runnables import RunnableConfig
     from langgraph.checkpoint.base import SerializerProtocol
     from langgraph.checkpoint.postgres.aio import AsyncPostgresSaver, _ainternal
-    from psycopg import AsyncPipeline, errors
+    from psycopg import AsyncConnection, AsyncPipeline, errors
     from psycopg.pq import TransactionStatus
     from psycopg.cursor_async import AsyncCursor
     from psycopg.rows import DictRow, dict_row
@@ -126,6 +126,57 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
         self.on_fence_lost = on_fence_lost
         self._fence_lost_notified = False
 
+    @staticmethod
+    async def _validate_and_bump(
+        cur: "AsyncCursor[DictRow]",
+        thread_id: str,
+        *,
+        create_fence_table: bool,
+        fence_table: str,
+    ) -> int:
+        if create_fence_table:
+            await cur.execute(_create_sql(fence_table))
+            await cur.execute(_create_fn_sql(fence_table))
+        else:
+            await cur.execute(
+                "SELECT to_regclass(%s) AS tbl, to_regprocedure(%s) AS fn",
+                (fence_table, f"{_assert_fn(fence_table)}(text, bigint)"),
+            )
+            row = await cur.fetchone()
+            if row["tbl"] is None:
+                raise _missing_fence_error(f"fence table {fence_table!r}")
+            if row["fn"] is None:
+                raise _missing_fence_error(
+                    f"fence function {_assert_fn(fence_table)!r}"
+                )
+        await cur.execute(_bump_sql(fence_table), (thread_id,))
+        return (await cur.fetchone())["epoch"]
+
+    @classmethod
+    async def bump_epoch(
+        cls,
+        conn: "AsyncConnection[Any]",
+        thread_id: str,
+        *,
+        create_fence_table: bool,
+        fence_table: str = DEFAULT_FENCE_TABLE,
+    ) -> int:
+        """Bump ``thread_id``'s epoch inside the caller's open transaction; the epoch is effective only once the caller commits, which must happen before it is used for writes."""
+        _require_thread_id(thread_id)
+        _require_fence_table(fence_table)
+        if conn.info.transaction_status != TransactionStatus.INTRANS:
+            raise RuntimeError(
+                "bump_epoch requires a connection with a transaction in "
+                "progress; use acquire for idle connections"
+            )
+        async with conn.cursor(binary=True, row_factory=dict_row) as cur:
+            return await cls._validate_and_bump(
+                cur,
+                thread_id,
+                create_fence_table=create_fence_table,
+                fence_table=fence_table,
+            )
+
     @classmethod
     async def acquire(
         cls,
@@ -149,23 +200,12 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
                 c.transaction(),
                 c.cursor(binary=True, row_factory=dict_row) as cur,
             ):
-                if create_fence_table:
-                    await cur.execute(_create_sql(fence_table))
-                    await cur.execute(_create_fn_sql(fence_table))
-                else:
-                    await cur.execute(
-                        "SELECT to_regclass(%s) AS tbl, to_regprocedure(%s) AS fn",
-                        (fence_table, f"{_assert_fn(fence_table)}(text, bigint)"),
-                    )
-                    row = await cur.fetchone()
-                    if row["tbl"] is None:
-                        raise _missing_fence_error(f"fence table {fence_table!r}")
-                    if row["fn"] is None:
-                        raise _missing_fence_error(
-                            f"fence function {_assert_fn(fence_table)!r}"
-                        )
-                await cur.execute(_bump_sql(fence_table), (thread_id,))
-                epoch = (await cur.fetchone())["epoch"]
+                epoch = await cls._validate_and_bump(
+                    cur,
+                    thread_id,
+                    create_fence_table=create_fence_table,
+                    fence_table=fence_table,
+                )
         if pipe is not None:
             await pipe.sync()
         return cls(

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/src/harness_sdk/run_manager.py

@@ -125,7 +125,6 @@ class _Rewind:
     ack: Callable[[], None]
     future: "asyncio.Future[Any]"
     root_meta: Any = None
-    acked: bool = False
 
 
 @dataclass
@@ -134,7 +133,9 @@ class _Effects:
     new_added: bool = False
     continue_requested: bool = False
     continue_meta: Any = None
-    staged_sends: list[tuple[str, "asyncio.Future[Any]"]] = field(default_factory=list)
+    staged_sends: list[tuple[str, "asyncio.Future[Any]", Callable[[], None]]] = field(
+        default_factory=list
+    )
     continues: list["asyncio.Future[Any]"] = field(default_factory=list)
 
 
@@ -192,6 +193,10 @@ class RunManager:
         self._stop_reason: str | None = None
         self._staged_rewinds: list[_Rewind] = []
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
+        # Deferred covering acks: they only ride an envelope whose state shows
+        # the command's effect (message-ack append, or the revert re-insert).
+        self._deferred_acks: dict[str, Callable[[], None]] = {}
+        self._dispatch_ack: Callable[[], None] | None = None
         self._run_acked = True
         self._leaf_confirmed: str | None = None
         self._send_futures: list["asyncio.Future[Any]"] = []
@@ -307,7 +312,7 @@ class RunManager:
                     rollback_to=rewind.rollback_to,
                     root_meta=rewind.root_meta,
                 )
-                rewind.ack()
+                self._dispatch_ack = rewind.ack
                 if not rewind.future.done():
                     self._run_futures.append(rewind.future)
             elif outcome is not None:
@@ -317,16 +322,15 @@ class RunManager:
         if self._task is not None and (self._staged_stops or self._staged_rewinds):
             assert self._ctx is not None
             self._ctx.stop_requested.set()
-            for rewind in self._staged_rewinds:
-                if not rewind.acked:
-                    rewind.ack()
-                    rewind.acked = True
         dispatching = {item["id"] for _, item in self._dispatching}
-        for message_id, future in fx.staged_sends:
+        for message_id, future, ack in fx.staged_sends:
             if message_id in dispatching:
+                self._deferred_acks[message_id] = ack
                 self._send_futures.append(future)
-            elif not future.done():
-                future.set_result(None)
+            else:
+                ack()
+                if not future.done():
+                    future.set_result(None)
         for future in fx.continues:
             if not future.done():
                 future.set_result(None)
@@ -538,6 +542,7 @@ class RunManager:
             self._ctx = None
             self._task = None
         self._dispatch_record = None
+        self._dispatch_ack = None
 
     def _settle_initiators(self, error: StatewireReject | None) -> None:
         futures, self._run_futures = self._run_futures, []
@@ -556,6 +561,13 @@ class RunManager:
                 future.set_result(None)
 
     def _ack_messages(self) -> None:
+        if self._dispatch_ack is not None:
+            self._dispatch_ack()
+            self._dispatch_ack = None
+        for _, item in self._dispatching:
+            ack = self._deferred_acks.pop(item["id"], None)
+            if ack is not None:
+                ack()
         self._dispatching = []
         self._run_acked = True
         self._leaf_confirmed = plain(self._entry()["runLeafMessageId"])
@@ -572,6 +584,10 @@ class RunManager:
             front = [item for taken_lane, item in taken if taken_lane == lane]
             if front:
                 entry[lane] = front + self._lane_items(lane)
+        for _, item in taken:
+            ack = self._deferred_acks.pop(item["id"], None)
+            if ack is not None:
+                ack()
         ids = {item["id"] for _, item in taken}
         self._dispatched_ids = tuple(id for id in self._dispatched_ids if id not in ids)
         if plain(entry["runLeafMessageId"]) in ids:
@@ -809,8 +825,7 @@ class RunManager:
             raise _reject("invalid-message", "anchorMessageId is required")
         self._check_anchor(e)
         self._insert_new(e.lane, e.message, e.params, e.meta)
-        fx.staged_sends.append((e.message_id, e.future))
-        e.ack()
+        fx.staged_sends.append((e.message_id, e.future, e.ack))
         fx.new_added = True
         if e.lane == "steerQueue":
             fx.steer_added = True

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/tests/run_helpers.py

@@ -5,7 +5,7 @@ from dataclasses import dataclass
 from typing import Any
 
 from statewire import Statewire, command
-from statewire_helpers import apply_ops, post_command, statewire_client, stream_of
+from statewire_helpers import apply_ops, attach, post_command, statewire_client, stream_of
 
 from harness_sdk import RunManager
 
@@ -127,20 +127,47 @@ class RunDriver:
     """One SSE-attached statewire client: sends commands, mirrors the state
     replica from ops, and returns each command's settled response."""
 
-    def __init__(self, client, stream) -> None:
+    def __init__(self, client, stream, app=None) -> None:
         self._client = client
         self._stream = stream
+        self._app = app
+        self._side_seqs: dict[str, int] = {}
         self._seq = 0
         self._acked = 0
         self._res: dict[int, list[dict[str, Any]]] = {}
+        self._posts: list["asyncio.Task[None]"] = []
         self.replica: dict[str, Any] = {}
         self.envelopes: list[dict[str, Any]] = []
 
+    def _spawn(self, body: dict[str, Any], seq: int) -> None:
+        async def _post() -> None:
+            response = await post_command(self._client, body, seq=seq)
+            assert response.status_code == 200, response.text
+
+        self._posts.append(asyncio.create_task(_post()))
+
+    def post(self, method: str, params: Any = None) -> int:
+        """Background POST for a command whose receipt is held until its effect
+        publishes (a dispatching send or rewind); settle via ``res(seq)``."""
+        self._seq += 1
+        body = {"method": method, "params": [] if params is None else [params]}
+        self._spawn(body, self._seq)
+        return self._seq
+
+    async def side(self, method: str, params: Any = None, *, client_id: str = "c2"):
+        """A second client's command: its own seq stream stays admissible while
+        this client's receipt is deferred; its verdicts ride the other stream."""
+        await attach(self._app, client_id=client_id)
+        seq = self._side_seqs[client_id] = self._side_seqs.get(client_id, 0) + 1
+        body = {"method": method, "params": [] if params is None else [params]}
+        response = await post_command(self._client, body, seq=seq, client_id=client_id)
+        assert response.status_code == 200, response.text
+
     async def pump(self, timeout: float = 5) -> None:
         env = await self._stream.next_event(timeout=timeout)
         assert env is not None, "stream ended unexpectedly"
         self.envelopes.append(env)
-        apply_ops(self.replica, env)
+        apply_ops(self.replica, copy.deepcopy(env))
         if "ack" in env:
             self._acked = max(self._acked, env["ack"])
         for rsp in env.get("res", []):
@@ -156,9 +183,9 @@ class RunDriver:
         assert response.status_code == 200, response.text
         return await self.res(seq, terminal=terminal)
 
-    async def batch(self, commands: list[tuple[str, Any]]) -> int:
-        """POST one batch; returns the first member's seq (members are
-        consecutive). Responses via ``res(first + i)``."""
+    def batch(self, commands: list[tuple[str, Any]]) -> int:
+        """Background POST of one batch; returns the first member's seq
+        (members are consecutive). Responses via ``res(first + i)``."""
         first = self._seq + 1
         self._seq += len(commands)
         body = {
@@ -167,8 +194,7 @@ class RunDriver:
                 for method, params in commands
             ]
         }
-        response = await post_command(self._client, body, seq=first)
-        assert response.status_code == 200, response.text
+        self._spawn(body, first)
         return first
 
     async def context(self, value: dict[str, Any]) -> dict[str, Any]:
@@ -250,9 +276,19 @@ async def run_host(
     async with statewire_client(host_cls) as (app, client):
         async with stream_of(app) as stream:
             snapshot = await stream.next_event()
-            driver = RunDriver(client, stream)
-            apply_ops(driver.replica, snapshot)
-            yield driver, host_cls
+            driver = RunDriver(client, stream, app)
+            driver.envelopes.append(snapshot)
+            apply_ops(driver.replica, copy.deepcopy(snapshot))
+            try:
+                yield driver, host_cls
+            finally:
+                for task in driver._posts:
+                    task.cancel()
+                for result in await asyncio.gather(
+                    *driver._posts, return_exceptions=True
+                ):
+                    if isinstance(result, AssertionError):
+                        raise result
 
 
 def msg(id: str, text: str | None = None) -> dict[str, Any]:

harness_sdk_python-0.7.0/tests/test_ack_visibility.py

@@ -0,0 +1,83 @@
+"""Contract: settle-after-visibility. A send or rewind's covering ack only
+rides an envelope whose state carries the command's effect — the message in
+``state.messages`` (the executor appends it before ``ctx.ack_messages()``) or
+in a published queue lane. A parked send acks with its insert; a dispatched
+entry whose run ends unacked acks with the revert that re-publishes it."""
+
+import copy
+
+from run_helpers import Script, add, msg, queue_ids, run_host
+
+from harness_sdk import RunManager
+from statewire_helpers import apply_ops
+
+
+def covered_state(drv, seq):
+    """The replica as of the envelope that first covers ``seq``."""
+    state: dict = {}
+    for env in copy.deepcopy(drv.envelopes):
+        apply_ops(state, env)
+        if env.get("ack", 0) >= seq:
+            return state
+    raise AssertionError(f"no envelope covers seq {seq}")
+
+
+def lane_and_message_ids(state):
+    runs = state.get("runs") or [{}]
+    return {
+        *(m["id"] for m in state.get("messages", [])),
+        *(item["id"] for item in runs[0].get("queue", [])),
+        *(item["id"] for item in runs[0].get("steerQueue", [])),
+    }
+
+
+async def test_dispatched_send_acks_with_the_message_ack_append():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        seq = drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        await drv.wait_status("running")
+        assert all("ack" not in env for env in drv.envelopes)
+        host.live.state["messages"] = [msg("m1")]
+        call.ack()
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert "m1" in lane_and_message_ids(covered_state(drv, seq))
+        call.finish(RunManager.Complete())
+
+
+async def test_parked_send_acks_with_its_queue_insert():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        res = await drv.command("run/enqueue", add("m2"))
+        assert res["type"] == "accepted"
+        assert "m2" in queue_ids(covered_state(drv, res["seq"]), "queue")
+        call.finish(RunManager.Complete())
+
+
+async def test_unacked_run_end_acks_with_the_revert():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        seq = drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.fail(RuntimeError("boom"))
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert "m1" in queue_ids(covered_state(drv, seq), "queue")
+
+
+async def test_rewind_edit_acks_with_the_message_ack_append():
+    script = Script()
+    script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        seq = drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-edit"
+        await drv.wait_status("running")
+        assert all("ack" not in env for env in drv.envelopes)
+        host.live.state["messages"] = [msg("u2")]
+        rerun.ack()
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert "u2" in lane_and_message_ids(covered_state(drv, seq))
+        rerun.finish(RunManager.Complete())

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/tests/test_batches.py

@@ -13,15 +13,13 @@ from harness_sdk import RunManager
 async def test_multi_steer_batch_places_all_and_dispatches_once():
     script = Script()
     async with run_host(script) as (drv, host):
-        first = await drv.batch(
+        first = drv.batch(
             [
                 ("run/steer", add("s1")),
                 ("run/steer", add("s2")),
                 ("run/steer", add("s3")),
             ]
         )
-        for offset in range(3):
-            assert (await drv.res(first + offset, terminal=False))["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.trigger == "message-send"
         assert [m["id"] for m in call.ctx.messages] == ["s1", "s2", "s3"]
@@ -36,9 +34,10 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
 async def test_steer_and_stop_in_one_batch_nets_to_stop():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
+        drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        first = await drv.batch(
+        call.ack()
+        first = drv.batch(
             [("run/steer", add("s1")), ("run/stop", {"runId": await drv.run_id()})]
         )
         assert (await drv.res(first))["type"] == "accepted"
@@ -54,8 +53,9 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
 async def test_stop_settles_only_after_the_run_task_ends():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
+        drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
+        call.ack()
         pending = await drv.stop(terminal=False)
         assert pending["type"] == "pending"
         for _ in range(5):
@@ -79,10 +79,10 @@ class TailScript(Script):
 async def test_handler_tail_staging_decides_in_its_own_envelope():
     script = TailScript()
     async with run_host(script) as (drv, host):
-        res = await drv.command("run/enqueue", add("m1"), terminal=False)
-        assert res["type"] == "pending"
+        seq = drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
         assert [m["id"] for m in call.ctx.messages] == ["m1"]
+        await drv.wait_status("running")
         dispatch_env = next(
             env
             for env in drv.envelopes
@@ -92,6 +92,7 @@ async def test_handler_tail_staging_decides_in_its_own_envelope():
             )
         )
         # The decide ran outside the batch segment: its ops flush in an
-        # envelope of their own, alongside the pending verdict and its ack.
-        assert dispatch_env["res"] == [{"seq": res["seq"], "type": "pending"}]
-        assert dispatch_env["ack"] >= res["seq"]
+        # envelope of their own; the covering ack waits for the message-ack.
+        assert "ack" not in dispatch_env and "res" not in dispatch_env
+        call.ack()
+        assert (await drv.res(seq))["type"] == "accepted"

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/tests/test_branch_anchor.py

@@ -19,9 +19,8 @@ async def test_add_requires_a_branch_anchor():
 async def test_null_anchor_valid_only_on_an_empty_thread():
     script = Script()
     async with run_host(script) as (drv, host):
-        res = await drv.command("run/enqueue", add("m1"), terminal=False)
-        assert res["type"] == "pending"
-        await script.next_call()
+        drv.post("run/enqueue", add("m1"))
+        (await script.next_call()).ack()
         script.thread["m1"] = {
             "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": True
         }
@@ -42,9 +41,8 @@ async def test_active_branch_anchor_accepted_off_branch_and_unknown_rejected():
         }
     )
     async with run_host(script) as (drv, host):
-        res = await drv.command("run/enqueue", add("m1", anchor="a1"), terminal=False)
-        assert res["type"] == "pending"
-        await script.next_call()
+        drv.post("run/enqueue", add("m1", anchor="a1"))
+        (await script.next_call()).ack()
         assert_rejected(
             await drv.command("run/enqueue", add("m2", anchor="old"), terminal=False),
             "wrong-anchor",
@@ -58,8 +56,8 @@ async def test_active_branch_anchor_accepted_off_branch_and_unknown_rejected():
 async def test_queued_item_and_dispatched_ids_are_valid_anchors():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        await script.next_call()
+        drv.post("run/enqueue", add("m1"))
+        (await script.next_call()).ack()
         await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
         await drv.command("run/steer", add("s1", anchor="m2"), terminal=False)
         assert queue_ids(drv.replica, "queue") == ["m2"]
@@ -74,11 +72,8 @@ async def test_replaced_tail_anchor_rejects_after_an_edit_rewrite():
         }
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        res = await drv.command(
-            "run/edit", {"sourceId": "u1", "message": msg("m2")}, terminal=False
-        )
-        assert res["type"] == "pending"
-        await script.next_call()
+        drv.post("run/edit", {"sourceId": "u1", "message": msg("m2")})
+        (await script.next_call()).ack()
         script.thread["u1"] = {
             "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": False
         }
@@ -96,8 +91,8 @@ async def test_replaced_tail_anchor_rejects_after_an_edit_rewrite():
 async def test_anchor_on_the_queued_edit_form_is_validated_never_ignored():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        await script.next_call()
+        drv.post("run/enqueue", add("m1"))
+        (await script.next_call()).ack()
         await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
         assert_rejected(
             await drv.command(
@@ -124,10 +119,10 @@ async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
         }
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        res = await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
-        assert res["type"] == "pending"
+        drv.post("run/reload", {"sourceId": "a1"})
         call = await script.next_call()
         assert call.ctx.trigger == "message-reload"
+        call.ack()
         script.thread["a1"] = {
             "parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False
         }

{harness_sdk_python-0.6.0 → harness_sdk_python-0.7.0}/tests/test_edit_dispatched.py

@@ -10,16 +10,13 @@ from harness_sdk import RunManager
 async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
+        drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
         script.thread["m1"] = {"parentId": "p0", "role": "user", "isLeaf": True}
         call.ack()
-        pending = await drv.command(
-            command, {"message": msg("m1", "edited")}, terminal=False
-        )
-        assert pending["type"] == "pending"
+        seq = drv.post(command, {"message": msg("m1", "edited")})
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
-        assert drv.replica["status"] == "running"
+        await drv.wait_status("running")
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-edit"
@@ -29,7 +26,7 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
         await drv.wait_status("running")
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
-        settled = await drv.res(pending["seq"])
+        settled = await drv.res(seq)
         assert settled["type"] == "accepted"
 
 
@@ -37,8 +34,8 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
 async def test_edit_of_dispatched_item_requires_rewind_during_run(capabilities):
     script = Script()
     async with run_host(script, capabilities=capabilities) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        await script.next_call()
+        drv.post("run/enqueue", add("m1"))
+        (await script.next_call()).ack()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         assert_rejected(
             await drv.command("run/enqueue", {"message": msg("m1", "edited")}, terminal=False),
@@ -50,54 +47,48 @@ async def test_edit_of_dispatched_item_requires_rewind_during_run(capabilities):
 async def test_edit_of_dispatched_non_leaf_stops_and_reruns(command):
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
+        drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": False}
         call.ack()
-        pending = await drv.command(
-            command, {"message": msg("m1", "edited")}, terminal=False
-        )
-        assert pending["type"] == "pending"
+        seq = drv.post(command, {"message": msg("m1", "edited")})
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-edit"
         assert [m["parts"][0]["text"] for m in rerun.ctx.messages] == ["edited"]
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+        assert (await drv.res(seq))["type"] == "accepted"
 
 
 async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
+        drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         call.ack()
         await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
-        pending = await drv.command(
-            "run/enqueue", {"message": msg("m1", "edited")}, terminal=False
-        )
-        assert pending["type"] == "pending"
+        seq = drv.post("run/enqueue", {"message": msg("m1", "edited")})
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-edit"
         rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+        assert (await drv.res(seq))["type"] == "accepted"
         assert [item["id"] for item in drv.run["queue"]] == ["m2"]
 
 
 async def test_edit_of_dispatched_item_in_error_reruns_without_stop():
     script = Script()
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
+        drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        await drv.command("run/enqueue", {"message": msg("m1", "edited")}, terminal=False)
+        drv.post("run/enqueue", {"message": msg("m1", "edited")})
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-edit"
         assert rerun.ctx.rollback_to is None