harness-sdk-python 0.13.2__tar.gz → 0.14.0__tar.gz

{harness_sdk_python-0.13.2 → harness_sdk_python-0.14.0}/PKG-INFO

@@ -1,11 +1,11 @@
-Metadata-Version: 2.4
+Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.13.2
+Version: 0.14.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.11
-Requires-Dist: statewire<0.7,>=0.6.0
+Requires-Dist: statewire<0.8,>=0.7.0
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.13.2 → harness_sdk_python-0.14.0}/examples/runs_app.py

@@ -107,7 +107,7 @@ class RunsHost(Statewire):
                         "content": user_text(message),
                     }
                 )
-            ctx.ack()
+            ctx.applied()
             outcome = await self.stream_turn(ctx)
             if outcome is not None:
                 return outcome
@@ -158,11 +158,11 @@ class RunsHost(Statewire):
 
     @command("run/enqueue")
     async def run_enqueue(self, params, *, ctx):
-        return await self.runs.enqueue(params, ack=ctx.ack)
+        return await self.runs.enqueue(params, applied=ctx.applied)
 
     @command("run/steer")
     async def run_steer(self, params, *, ctx):
-        return await self.runs.steer(params, ack=ctx.ack)
+        return await self.runs.steer(params, applied=ctx.applied)
 
     @command("run/dequeue")
     async def run_dequeue(self, params):
@@ -170,19 +170,19 @@ class RunsHost(Statewire):
 
     @command("run/edit")
     async def run_edit(self, params, *, ctx):
-        return await self.runs.edit(params, ack=ctx.ack)
+        return await self.runs.edit(params, applied=ctx.applied)
 
     @command("run/reload")
     async def run_reload(self, params, *, ctx):
-        return await self.runs.reload(params, ack=ctx.ack)
+        return await self.runs.reload(params, applied=ctx.applied)
 
     @command("run/stop")
     async def run_stop(self, params=None, *, ctx):
-        return await self.runs.stop(params, ack=ctx.ack)
+        return await self.runs.stop(params, applied=ctx.applied)
 
     @command("run/continue")
     async def run_continue(self, params=None, *, ctx):
-        return await self.runs.continue_run(ack=ctx.ack)
+        return await self.runs.continue_run(applied=ctx.applied)
 
     @command("run/input")
     async def run_input(self, params):

{harness_sdk_python-0.13.2 → harness_sdk_python-0.14.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.13.2"
+version = "0.14.0"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11,<4.0"
-dependencies = ["statewire>=0.6.0,<0.7"]
+dependencies = ["statewire>=0.7.0,<0.8"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.13.2 → harness_sdk_python-0.14.0}/src/harness_sdk/run_manager.py

@@ -10,16 +10,22 @@ 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:
+initiator applies and settles accepted with its state-visible application:
 the verdict certifies the admission write — sends with their insert (lane
 or ``dispatching``), mid-run edit/reload with the stopping window,
 ``run/stop`` with ``stopping`` — never future execution.
 
-``entry["dispatching"]`` is the dispatch record (absent between an ack and
+``entry["dispatching"]`` is the dispatch record (absent between an applied 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.
+``ctx.applied()`` confirms it; ``steering.take()`` may refill it — 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. ``Complete``
+with an unconfirmed batch settles as an error. Steer entries still
+undelivered in the lane stay queued for the next run.
+
+``entry["epoch"]`` counts the entry's dispatches; a ``run/stop`` carrying an
+``epoch`` other than the live one rejects, so a replayed stop never ends a
+later leg of the same ``runId``.
 
 A mid-run stop or rewind opens a stopping window on the entry:
 ``stopping: {reason}`` plus, for rewinds, the staged dispatch as
@@ -87,7 +93,7 @@ class _Send:
     message_id: str
     source_meta: dict[str, Any] | None
     meta: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     run_id: str = ""
     anchor: Any = _ABSENT
     anchor_meta: dict[str, Any] | None = None
@@ -107,7 +113,7 @@ class _Edit:
     source_meta: dict[str, Any]
     message: dict[str, Any]
     meta: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     run_id: str
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
@@ -116,7 +122,7 @@ class _Edit:
 class _Reload:
     source_meta: dict[str, Any]
     meta: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     run_id: str
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
@@ -145,11 +151,11 @@ class _Rewind:
     type: str
     messages: list[dict[str, Any]]
     rollback_to: Any
-    ack: Callable[[], None]
+    applied: Callable[[], None]
     future: "asyncio.Future[Any]"
     run_id: str
     root_meta: Any = None
-    acked: bool = False
+    applied_sent: bool = False
 
 
 @dataclass
@@ -373,8 +379,8 @@ class RunManager:
                     rollback_to=rewind.rollback_to,
                     root_meta=rewind.root_meta,
                 )
-                if not rewind.acked:
-                    rewind.ack()
+                if not rewind.applied_sent:
+                    rewind.applied()
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
@@ -384,8 +390,8 @@ class RunManager:
         ):
             assert self._ctx is not None
             self._ctx.stop_requested.set()
-        for future, ack, result in fx.staged_sends:
-            ack()
+        for future, applied, result in fx.staged_sends:
+            applied()
             if not future.done():
                 future.set_result(result)
         for future in fx.continues:
@@ -534,6 +540,7 @@ class RunManager:
         self._dispatch_record = dict(record)
         self._stop_reason = None
         entry = self._ensure_entry()
+        entry["epoch"] = (plain(entry.get("epoch")) or 0) + 1
         entry["dispatching"] = record
         entry.pop("error", None)
         if messages:
@@ -570,6 +577,8 @@ class RunManager:
                     "run must return a RunManager outcome, got "
                     f"{type(outcome).__name__}"
                 )
+            if isinstance(outcome, RunManager.Complete) and self._dispatching:
+                raise RuntimeError("run returned Complete with an unconfirmed batch")
         except asyncio.CancelledError:
             self._settle(ctx)
             self._set_status("stopped")
@@ -593,19 +602,25 @@ class RunManager:
             self._ctx = None
             self._task = None
         self._dispatch_record = None
-        self._dispatching = []
         entry = self._ensure_entry()
-        record = plain(entry.get("dispatching"))
-        if record is not None and record["trigger"] != "steer" and record["messages"]:
-            self._dispatched_ids = ()
-        entry.pop("dispatching", None)
+        if self._dispatching:
+            self._unstage_dispatching()
+        else:
+            record = plain(entry.get("dispatching"))
+            if (
+                record is not None
+                and record["trigger"] != "steer"
+                and record["messages"]
+            ):
+                self._dispatched_ids = ()
+            entry.pop("dispatching", None)
         entry.pop("stopping", None)
 
-    def _ack(self) -> None:
+    def _applied(self) -> None:
         entry = self._entry()
         record = plain(entry.get("dispatching"))
         if record is None:
-            raise RuntimeError("ack() with no unacked batch")
+            raise RuntimeError("applied() with no unapplied batch")
         self._dispatching = []
         entry.pop("dispatching", None)
 
@@ -691,8 +706,8 @@ class RunManager:
                 rollback_to=rewind.rollback_to,
                 root_meta=rewind.root_meta,
             )
-            rewind.ack()
-            rewind.acked = True
+            rewind.applied()
+            rewind.applied_sent = True
         if not rewind.future.done():
             rewind.future.set_result(None)
 
@@ -941,7 +956,7 @@ class RunManager:
             if live_run_id is not None and e.anchor is not _ABSENT
             else None
         )
-        fx.staged_sends.append((e.future, e.ack, result))
+        fx.staged_sends.append((e.future, e.applied, result))
         return _PARKED
 
     def _apply_move(self, e: _Send, fx: _Effects) -> Any:
@@ -981,7 +996,7 @@ class RunManager:
                 "message-edit",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
-                e.ack,
+                e.applied,
                 e.future,
                 e.run_id,
             )
@@ -1036,7 +1051,7 @@ class RunManager:
                 "message-edit",
                 [self._stamped(e.message, e.meta)],
                 e.source_meta["parentId"],
-                e.ack,
+                e.applied,
                 e.future,
                 e.run_id,
             )
@@ -1049,7 +1064,7 @@ class RunManager:
                 "message-reload",
                 [],
                 e.source_meta["parentId"],
-                e.ack,
+                e.applied,
                 e.future,
                 e.run_id,
                 root_meta=e.meta,
@@ -1064,7 +1079,7 @@ class RunManager:
         lane: str,
         params: Any,
         meta: Any,
-        ack: Callable[[], None],
+        applied: Callable[[], None],
     ) -> Any:
         if not isinstance(params, dict):
             raise _reject("invalid-message", "params must be an object")
@@ -1100,7 +1115,7 @@ class RunManager:
                     message_id,
                     None,
                     None,
-                    ack,
+                    applied,
                     run_id=run_id,
                     anchor=anchor,
                     anchor_meta=anchor_meta,
@@ -1117,7 +1132,7 @@ class RunManager:
                 message["id"],
                 source_meta,
                 meta,
-                ack,
+                applied,
                 run_id=run_id,
                 anchor=anchor,
                 anchor_meta=anchor_meta,
@@ -1126,14 +1141,14 @@ class RunManager:
         )
 
     async def enqueue(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
-        return await self._send("queue", params, meta, ack)
+        return await self._send("queue", params, meta, applied)
 
     async def steer(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
-        return await self._send("steerQueue", params, meta, ack)
+        return await self._send("steerQueue", params, meta, applied)
 
     async def dequeue(self, params: Any) -> None:
         message_id = params.get("messageId") if isinstance(params, dict) else None
@@ -1152,7 +1167,7 @@ class RunManager:
             raise _reject("capability-missing", "the rewind capability is not enabled")
 
     async def edit(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
         self._check_rewind_gate("run/edit")
         run_id = _run_id_of(params)
@@ -1176,11 +1191,11 @@ class RunManager:
         ):
             raise _reject("duplicate-id", f"message id {message['id']} is already used")
         return await self._stage(
-            _Edit(source_id, source_meta, message, meta, ack, run_id)
+            _Edit(source_id, source_meta, message, meta, applied, run_id)
         )
 
     async def reload(
-        self, params: Any, *, meta: Any = None, ack: Callable[[], None]
+        self, params: Any, *, meta: Any = None, applied: Callable[[], None]
     ) -> Any:
         self._check_rewind_gate("run/reload")
         run_id = _run_id_of(params)
@@ -1204,14 +1219,17 @@ class RunManager:
                     "capability-missing",
                     "the assistant-continuation capability is not enabled",
                 )
-        return await self._stage(_Reload(source_meta, meta, ack, run_id))
+        return await self._stage(_Reload(source_meta, meta, applied, run_id))
 
-    async def stop(self, params: Any = None, *, ack: Callable[[], None]) -> Any:
+    async def stop(self, params: Any = None, *, applied: Callable[[], None]) -> Any:
         if params is not None and not isinstance(params, dict):
             raise _reject("invalid-message", "params must be an object")
         reason = (params or {}).get("reason", _ABSENT)
         if reason is not _ABSENT and not isinstance(reason, str):
             raise _reject("invalid-message", "reason must be a string")
+        epoch = (params or {}).get("epoch", _ABSENT)
+        if epoch is not _ABSENT and (isinstance(epoch, bool) or not isinstance(epoch, int)):
+            raise _reject("invalid-message", "epoch must be an integer")
         status = self._status()
         if status != "running":
             raise _reject("wrong-state", f"run/stop is rejected in {status}")
@@ -1220,11 +1238,15 @@ class RunManager:
             raise _reject(
                 "wrong-state", f"runId {run_id!r} does not name the live run"
             )
+        if epoch is not _ABSENT and epoch != plain(self._entry()["epoch"]):
+            raise _reject(
+                "wrong-state", f"epoch {epoch} does not name the live dispatch"
+            )
         if reason is not _ABSENT:
             self._stop_reason = reason
         entry = _Stop()
         self._intake.append(entry)
-        ack()
+        applied()
         self._schedule(self._drain)
         return await entry.future
 
@@ -1274,7 +1296,7 @@ class RunManager:
         response = self._validated_response(request["type"], params["response"])
         return await self._stage(_Input(request_id, response, meta))
 
-    async def continue_run(self, *, meta: Any = None, ack: Callable[[], None]) -> Any:
+    async def continue_run(self, *, meta: Any = None, applied: Callable[[], None]) -> Any:
         status = self._status()
         if status not in ("error", "stopped"):
             raise _reject("wrong-state", f"run/continue is rejected in {status}")
@@ -1287,7 +1309,7 @@ class RunManager:
             )
         entry = _Continue(meta)
         self._intake.append(entry)
-        ack()
+        applied()
         self._schedule(self._drain)
         return await entry.future
 
@@ -1340,12 +1362,12 @@ class RunManager:
         _ctx: "RunManager.RunContext"
 
         def take(self) -> tuple[dict[str, Any], ...]:
-            """Drain the steer lane into a fresh dispatch record; requires the current batch to be acked."""
+            """Drain the steer lane into a fresh dispatch record; requires the current batch to be applied."""
             self._ctx._ensure_active()
             manager = self._ctx._manager
             entry = manager._entry()
             if plain(entry.get("dispatching")) is not None:
-                raise RuntimeError("take before the current batch is acked")
+                raise RuntimeError("take before the current batch is applied")
             items = manager._lane_items("steerQueue")
             if not items:
                 return ()
@@ -1410,10 +1432,10 @@ class RunManager:
             if self._manager._ctx is not self:
                 raise RuntimeError("this run has already settled")
 
-        def ack(self) -> None:
-            """Ack the current batch: clears the dispatch record."""
+        def applied(self) -> None:
+            """Confirms the current batch durable: clears the dispatch record so settle consumes it."""
             self._ensure_active()
-            self._manager._ack()
+            self._manager._applied()
 
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()

{harness_sdk_python-0.13.2 → harness_sdk_python-0.14.0}/tests/run_helpers.py

@@ -16,8 +16,8 @@ class Call:
     ctx: RunManager.RunContext
     outcome: "asyncio.Future[Any]"
 
-    def ack(self) -> None:
-        self.ctx.ack()
+    def applied(self) -> None:
+        self.ctx.applied()
 
     def finish(self, outcome: Any) -> None:
         self.outcome.set_result(outcome)
@@ -87,11 +87,11 @@ def make_host(
 
         @command("run/enqueue")
         async def run_enqueue(self, params, *, ctx):
-            return await self.runs.enqueue(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.enqueue(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/steer")
         async def run_steer(self, params, *, ctx):
-            return await self.runs.steer(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.steer(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/dequeue")
         async def run_dequeue(self, params):
@@ -99,19 +99,19 @@ def make_host(
 
         @command("run/edit")
         async def run_edit(self, params, *, ctx):
-            return await self.runs.edit(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.edit(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/reload")
         async def run_reload(self, params, *, ctx):
-            return await self.runs.reload(params, meta=_meta(params), ack=ctx.ack)
+            return await self.runs.reload(params, meta=_meta(params), applied=ctx.applied)
 
         @command("run/stop")
         async def run_stop(self, params=None, *, ctx):
-            return await self.runs.stop(params, ack=ctx.ack)
+            return await self.runs.stop(params, applied=ctx.applied)
 
         @command("run/continue")
         async def run_continue(self, params=None, *, ctx):
-            return await self.runs.continue_run(meta=_meta(params), ack=ctx.ack)
+            return await self.runs.continue_run(meta=_meta(params), applied=ctx.applied)
 
         @command("run/input")
         async def run_input(self, params):
@@ -205,7 +205,7 @@ class RunDriver:
         return await self.res(self._seq)
 
     async def res(self, seq: int, *, terminal: bool = True) -> dict[str, Any]:
-        # A payload-less accept rides only the ack; rejections and late
+        # A payload-less accept rides only the legacy ack; rejections and late
         # settles ride res.
         while True:
             entries = self._res.get(seq, [])

harness_sdk_python-0.13.2/tests/test_ack_visibility.py → harness_sdk_python-0.14.0/tests/test_applied_visibility.py

@@ -1,8 +1,8 @@
-"""Contract: acks ride visibility. A send's covering ack only rides an
+"""Contract: applied rides visibility. A send's covering applied only rides an
 envelope whose state carries the command's effect — the item in a published
 queue lane or in ``dispatching``. An idle send's insert lands in
-``dispatching`` directly, so its ack rides the dispatch envelope and the queue
-lane never holds the item; a rewind's ack rides its dispatch the same way."""
+``dispatching`` directly, so its applied rides the dispatch envelope and the queue
+lane never holds the item; a rewind's applied rides its dispatch the same way."""
 
 import copy
 
@@ -35,7 +35,7 @@ def assert_never_queued(drv, message_id):
         assert message_id not in queue_ids(state, "queue")
 
 
-async def test_idle_send_acks_with_its_dispatching_insert():
+async def test_idle_send_applies_with_its_dispatching_insert():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
@@ -44,23 +44,23 @@ async def test_idle_send_acks_with_its_dispatching_insert():
         assert dispatching_ids(covered_state(drv, seq)) == ["m1"]
         assert_never_queued(drv, "m1")
         host.live.state["messages"] = [msg("m1")]
-        call.ack()
+        call.applied()
         call.finish(RunManager.Complete())
 
 
-async def test_parked_send_acks_with_its_queue_insert():
+async def test_parked_send_applies_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()
+        call.applied()
         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_consumes_the_direct_dispatch():
+async def test_unconfirmed_run_end_requeues_the_direct_dispatch():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
@@ -69,10 +69,10 @@ async def test_unacked_run_end_consumes_the_direct_dispatch():
         assert dispatching_ids(covered_state(drv, seq)) == ["m1"]
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        assert queue_ids(drv.replica, "queue") == []
+        assert queue_ids(drv.replica, "queue") == ["m1"]
 
 
-async def test_unacked_run_end_consumes_the_direct_steer_send():
+async def test_unconfirmed_run_end_requeues_the_direct_steer_send():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/steer", add("s1"))
@@ -81,11 +81,11 @@ async def test_unacked_run_end_consumes_the_direct_steer_send():
         assert dispatching_ids(covered_state(drv, seq)) == ["s1"]
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        assert queue_ids(drv.replica, "steerQueue") == []
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
         assert queue_ids(drv.replica, "queue") == []
 
 
-async def test_rewind_edit_acks_with_its_dispatch():
+async def test_rewind_edit_applies_with_its_dispatch():
     script = Script()
     script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
@@ -95,6 +95,6 @@ async def test_rewind_edit_acks_with_its_dispatch():
         await drv.wait_status("running")
         assert dispatching_ids(covered_state(drv, seq)) == ["u2"]
         host.live.state["messages"] = [msg("u2")]
-        rerun.ack()
+        rerun.applied()
         rerun.finish(RunManager.Complete())
         assert (await drv.res(seq))["type"] == "accepted"

{harness_sdk_python-0.13.2 → harness_sdk_python-0.14.0}/tests/test_batches.py

@@ -25,7 +25,7 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
         assert [m["id"] for m in call.ctx.messages] == ["s1", "s2", "s3"]
         script.no_call()
         assert queue_ids(drv.replica, "steerQueue") == []
-        call.ack()
+        call.applied()
         call.finish(RunManager.Complete())
         for offset in range(3):
             assert (await drv.res(first + offset))["type"] == "accepted"
@@ -45,7 +45,7 @@ async def test_same_tick_sends_dispatch_as_one_run():
         merged = await drv.res(first + 1)
         assert merged["type"] == "accepted"
         assert merged["payload"] == {"runId": mint["runId"]}
-        call.ack()
+        call.applied()
         call.finish(RunManager.Complete())
 
 
@@ -54,7 +54,7 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         first = drv.batch(
             [("run/steer", add("s1")), ("run/stop", {"runId": await drv.run_id()})]
         )
@@ -72,7 +72,7 @@ async def test_stop_settles_at_the_stopping_write():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         settled = await drv.stop()
         assert settled["type"] == "accepted"
         assert drv.replica["status"] == "running"
@@ -104,10 +104,10 @@ 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, carrying the send's covering ack.
+        # envelope of their own, carrying the send's covering applied.
         assert dispatch_env.get("ack", 0) >= seq
         assert (await drv.res(seq))["type"] == "accepted"
-        call.ack()
+        call.applied()
 
 
 async def test_rewind_outranks_send_and_continue_in_one_batch():
@@ -129,7 +129,7 @@ async def test_rewind_outranks_send_and_continue_in_one_batch():
             "isLeaf": True,
             "onActiveBranch": True,
         }
-        call.ack()
+        call.applied()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         first = drv.batch(
@@ -147,7 +147,7 @@ async def test_rewind_outranks_send_and_continue_in_one_batch():
         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.applied()
         rerun.finish(RunManager.Complete())
 
 
@@ -156,7 +156,7 @@ async def test_send_outranks_the_completing_input_answer():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
-        call.ack()
+        call.applied()
         request = {"type": "tool-call", "id": "r1", "toolCallId": "tc1"}
         call.finish(RunManager.InputRequired((request,)))
         await drv.wait_status("input-required")
@@ -173,6 +173,6 @@ async def test_send_outranks_the_completing_input_answer():
         script.no_call()
         assert (await drv.res(first))["type"] == "accepted"
         assert (await drv.res(first + 1))["type"] == "accepted"
-        run.ack()
+        run.applied()
         run.finish(RunManager.Complete())
         await drv.wait_status("ready")