harness-sdk-python 0.7.2__tar.gz → 0.8.0__tar.gz

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.7.2
+Version: 0.8.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.7.2 → harness_sdk_python-0.8.0}/pyproject.toml

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

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/src/harness_sdk/run_manager.py

@@ -14,10 +14,12 @@ and settle when their run ends — accepted once the run has acked its
 messages, rejected otherwise; ``run/stop`` awaits a future the drain resolves
 once the in-flight run has ended.
 
-``ctx.ack_messages()`` is bookkeeping: it clears ``dispatching`` and confirms
-``runLeafMessageId``. A run that ends with entries still in ``dispatching``
-reverts them by provenance: lane items to the front of their lane, direct
-dispatches to the front of the queue, rewind replacements dropped.
+``entry["dispatching"]`` is the dispatch record (or None): the payload the
+run callback receives. ``ctx.ack()`` clears it and confirms
+``runLeafMessageId``; ``steering.take()`` may refill it — at most one unacked
+batch ever exists. A run that ends with an unacked record reverts its items
+by provenance: lane items to the front of their lane, direct dispatches to
+the front of the queue, rewind replacements dropped.
 """
 
 import asyncio
@@ -51,6 +53,7 @@ _TRIGGERS = (
     "input-resume",
     "error-continue",
     "stop-continue",
+    "steer",
 )
 
 _DECISIONS = ("approve", "reject", "edit", "respond")
@@ -242,7 +245,7 @@ class RunManager:
                     "status": "ready",
                     "queue": [],
                     "steerQueue": [],
-                    "dispatching": [],
+                    "dispatching": None,
                     "error": None,
                     "runLeafMessageId": None,
                 }
@@ -435,28 +438,30 @@ class RunManager:
         if self._task is not None:
             raise RuntimeError("a run is already in flight")
         message_meta = {m["id"]: m.get("meta") for m in messages}
-        dispatching = list(messages)
+        items = list(messages)
         messages = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
-        record: dict[str, Any] = {"trigger": trigger, "messages": list(messages)}
+        record: dict[str, Any] = {"trigger": trigger, "messages": items}
         if rollback_to is not _ABSENT:
             record["rollbackTo"] = rollback_to
         if input_outcomes:
-            record["inputOutcomes"] = input_outcomes
-        self._dispatch_record = record
+            record["inputOutcomes"] = [
+                {"request": request, "response": response, "meta": meta}
+                for request, response, meta in input_outcomes
+            ]
+        self._dispatch_record = dict(record)
         self._stop_reason = None
         self._run_acked = False
         entry = self._ensure_entry()
         self._leaf_confirmed = plain(entry["runLeafMessageId"])
-        entry["dispatching"] = dispatching
+        entry["dispatching"] = record
         entry["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
         if rollback_to is not _ABSENT:
-            entry["runLeafMessageId"] = rollback_to
-        if messages:
-            entry["runLeafMessageId"] = messages[-1]["id"]
+            # The true leaf is the not-yet-created message; ack records it.
+            entry["runLeafMessageId"] = None
         entry["runId"] = uuid.uuid4().hex
         self._set_status("running")
         ctx = RunManager.RunContext(
@@ -523,7 +528,7 @@ class RunManager:
         elif isinstance(outcome, RunManager.Error):
             error = _reject("run-error", "run ended in error")
         elif isinstance(outcome, RunManager.Stop):
-            error = _reject("stopped", "run stopped before the messages-ack")
+            error = _reject("stopped", "run stopped before the ack")
         else:
             error = None
         self._settle_initiators(error)
@@ -532,8 +537,8 @@ class RunManager:
         self._drain()
 
     async def _pull_leaf(self) -> None:
-        # An end with unacked messages reverts instead of recording a leaf.
-        if plain(self._entry()["dispatching"]):
+        # An end with an unacked batch reverts instead of recording a leaf.
+        if plain(self._entry()["dispatching"]) is not None:
             return
         self._entry()["runLeafMessageId"] = await self._thread.get_leaf_message_id()
 
@@ -553,16 +558,25 @@ class RunManager:
             else:
                 future.set_exception(error)
 
-    def _ack_messages(self) -> None:
+    def _ack(self) -> None:
+        entry = self._entry()
+        record = plain(entry["dispatching"])
+        if record is None:
+            raise RuntimeError("ack() with no unacked batch")
         self._dispatching = []
-        self._entry()["dispatching"] = []
+        entry["dispatching"] = None
         self._run_acked = True
-        self._leaf_confirmed = plain(self._entry()["runLeafMessageId"])
+        if record["messages"]:
+            entry["runLeafMessageId"] = record["messages"][-1]["id"]
+        self._leaf_confirmed = plain(entry["runLeafMessageId"])
 
     def _revert_dispatching(self) -> None:
         taken, self._dispatching = self._dispatching, []
         entry = self._ensure_entry()
-        entry["dispatching"] = []
+        record = plain(entry["dispatching"])
+        entry["dispatching"] = None
+        if record is not None and "rollbackTo" in record:
+            entry["runLeafMessageId"] = self._leaf_confirmed
         if not taken:
             return
         for lane in ("steerQueue", "queue"):
@@ -571,8 +585,6 @@ class RunManager:
                 entry[lane] = front + self._lane_items(lane)
         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:
-            entry["runLeafMessageId"] = self._leaf_confirmed
 
     def _dispatchable(self, lane: str) -> bool:
         if self._task is not None or self._staged_rewinds:
@@ -600,8 +612,11 @@ class RunManager:
         if steer:
             self._entry()["steerQueue"] = []
             self._dispatching.extend(("steerQueue", item) for item in steer)
-        self._dispatching.append(("queue", self._stamped(e.message, e.meta)))
-        self._ensure_entry()["dispatching"] = [item for _, item in self._dispatching]
+        self._dispatching.append((e.lane, self._stamped(e.message, e.meta)))
+        self._ensure_entry()["dispatching"] = {
+            "trigger": "message-send",
+            "messages": [item for _, item in self._dispatching],
+        }
 
     def _dispatch_staged(
         self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
@@ -1233,16 +1248,18 @@ class RunManager:
         _ctx: "RunManager.RunContext"
 
         def take(self) -> tuple[dict[str, Any], ...]:
-            """Drain the steer lane into this run; items leave the projection, retained until the ack."""
+            """Drain the steer lane into a fresh dispatch record; requires the current batch to be acked."""
             self._ctx._ensure_active()
             manager = self._ctx._manager
-            items = manager._lane_items("steerQueue")
             entry = manager._entry()
+            if plain(entry["dispatching"]) is not None:
+                raise RuntimeError("take before the current batch is acked")
+            items = manager._lane_items("steerQueue")
+            if not items:
+                return ()
             entry["steerQueue"] = []
             manager._dispatching.extend(("steerQueue", item) for item in items)
-            entry["dispatching"] = list(plain(entry["dispatching"])) + items
-            if items:
-                entry["runLeafMessageId"] = items[-1]["id"]
+            entry["dispatching"] = {"trigger": "steer", "messages": items}
             self._ctx._message_meta.update(
                 {item["id"]: item.get("meta") for item in items}
             )
@@ -1301,9 +1318,10 @@ class RunManager:
             if self._manager._ctx is not self:
                 raise RuntimeError("this run has already settled")
 
-        def ack_messages(self) -> None:
+        def ack(self) -> None:
+            """Ack the current batch: clears the dispatch record and confirms the run leaf."""
             self._ensure_active()
-            self._manager._ack_messages()
+            self._manager._ack()
 
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/run_helpers.py

@@ -16,7 +16,7 @@ class Call:
     outcome: "asyncio.Future[Any]"
 
     def ack(self) -> None:
-        self.ctx.ack_messages()
+        self.ctx.ack()
 
     def finish(self, outcome: Any) -> None:
         self.outcome.set_result(outcome)

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_ack_visibility.py

@@ -24,7 +24,8 @@ def covered_state(drv, seq):
 
 def dispatching_ids(state):
     runs = state.get("runs") or [{}]
-    return [item["id"] for item in runs[0].get("dispatching", [])]
+    record = runs[0].get("dispatching")
+    return [item["id"] for item in record["messages"]] if record else []
 
 
 def assert_never_queued(drv, message_id):
@@ -71,6 +72,19 @@ async def test_unacked_run_end_reverts_the_direct_dispatch_to_the_queue():
         assert queue_ids(drv.replica, "queue") == ["m1"]
 
 
+async def test_unacked_run_end_reverts_the_direct_steer_send_to_the_steer_lane():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        seq = drv.post("run/steer", add("s1"))
+        call = await script.next_call()
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert dispatching_ids(covered_state(drv, seq)) == ["s1"]
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        assert queue_ids(drv.replica, "queue") == []
+
+
 async def test_rewind_edit_acks_with_its_dispatch():
     script = Script()
     script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_dispatching.py

@@ -1,13 +1,14 @@
-"""Contract: replicated dispatch limbo. ``dispatching`` on the run entry is
-the current dispatch's unacked messages — queue pops, steer-lane takes, and
-rewind dispatches alike. A message item lives in exactly one of the lanes,
-``dispatching``, or the thread, and every transition is single-envelope
-atomic: dispatch moves it lane → ``dispatching``, the messages-ack clears
-``dispatching`` as the canonical message appears, and an unacked run end
-returns lane items to the front of their lane."""
+"""Contract: the replicated dispatch record. ``dispatching`` on the run entry
+is the current unacked batch — a record ``{trigger, messages, rollbackTo?,
+inputOutcomes?}`` or None. A message item lives in exactly one of the lanes,
+the record's ``messages``, or the thread, and every transition is
+single-envelope atomic: dispatch fills the record, ``ctx.ack()`` clears it as
+the canonical message appears, a steer take refills it, and an unacked run
+end returns lane items to the front of their lane."""
 
 import copy
 
+import pytest
 from run_helpers import Script, add, msg, queue_ids, run_host
 
 from harness_sdk import RunManager
@@ -16,16 +17,20 @@ from statewire_helpers import apply_ops
 
 def dispatching_ids(replica):
     runs = replica["runs"]
-    return [item["id"] for item in runs[0]["dispatching"]] if runs else []
+    record = runs[0]["dispatching"] if runs else None
+    return [item["id"] for item in record["messages"]] if record else []
 
 
 def places(state, message_id):
     entry = (state.get("runs") or [{}])[0]
     found = {
         name
-        for name in ("queue", "steerQueue", "dispatching")
+        for name in ("queue", "steerQueue")
         if any(item["id"] == message_id for item in entry.get(name, []))
     }
+    record = entry.get("dispatching")
+    if record and any(item["id"] == message_id for item in record["messages"]):
+        found.add("dispatching")
     if any(m["id"] == message_id for m in state.get("messages", [])):
         found.add("messages")
     return found
@@ -53,6 +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 dispatching_ids(drv.replica) == ["m1"]
         assert queue_ids(drv.replica, "queue") == []
         assert residence(drv, "m1") == ["dispatching"]
@@ -97,6 +103,7 @@ async def test_steering_take_moves_the_lane_into_dispatching():
         await drv.command("run/steer", add("s1"), terminal=False)
         call.ctx.steering.take()
         await drv.wait(lambda s: dispatching_ids(s) == ["s1"])
+        assert drv.run["dispatching"]["trigger"] == "steer"
         assert queue_ids(drv.replica, "steerQueue") == []
         assert residence(drv, "s1") == ["steerQueue", "dispatching"]
         host.live.state["messages"] = [msg("m1"), msg("s1")]
@@ -121,3 +128,46 @@ async def test_edit_replacement_rides_dispatching_until_ack():
         assert residence(drv, "u2") == ["dispatching", "messages"]
         rerun.finish(RunManager.Complete())
         assert (await drv.res(seq))["type"] == "accepted"
+
+
+async def test_take_before_the_ack_raises():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        await drv.side("run/steer", add("s1"))
+        await drv.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
+        with pytest.raises(RuntimeError, match="before the current batch is acked"):
+            call.ctx.steering.take()
+        call.ack()
+        assert [m["id"] for m in call.ctx.steering.take()] == ["s1"]
+        call.ack()
+        call.finish(RunManager.Complete())
+
+
+async def test_ack_with_no_unacked_batch_raises():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        with pytest.raises(RuntimeError, match="no unacked batch"):
+            call.ack()
+        call.finish(RunManager.Complete())
+
+
+async def test_second_take_after_the_reack_drains_the_next_batch():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        await drv.command("run/steer", add("s1"), terminal=False)
+        assert [m["id"] for m in call.ctx.steering.take()] == ["s1"]
+        call.ack()
+        await drv.command("run/steer", add("s2", anchor="m1"), terminal=False)
+        assert [m["id"] for m in call.ctx.steering.take()] == ["s2"]
+        await drv.wait(lambda s: dispatching_ids(s) == ["s2"])
+        assert drv.run["dispatching"]["trigger"] == "steer"
+        call.ack()
+        call.finish(RunManager.Complete())

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_input_required.py

@@ -79,6 +79,36 @@ async def test_completing_answer_resumes_with_ordered_responses():
         await drv.wait_status("ready")
 
 
+async def test_input_outcomes_ride_the_dispatch_record_until_the_ack():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await park(drv, script, [tool_call("r1"), approval("r2")])
+        await drv.command(
+            "run/input", {"requestId": "r2", "response": {"decision": "approve"}}
+        )
+        await drv.command(
+            "run/input", {"requestId": "r1", "response": {"output": "ok"}}
+        )
+        resumed = await script.next_call()
+        await drv.wait(lambda s: run_of(s).get("dispatching") is not None)
+        assert drv.run["dispatching"] == {
+            "trigger": "input-resume",
+            "messages": [],
+            "inputOutcomes": [
+                {"request": tool_call("r1"), "response": {"output": "ok"}, "meta": None},
+                {
+                    "request": approval("r2"),
+                    "response": {"decision": "approve"},
+                    "meta": None,
+                },
+            ],
+        }
+        resumed.ack()
+        await drv.wait(lambda s: run_of(s).get("dispatching") is None)
+        resumed.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
 async def test_completing_batch_resumes_once_in_the_same_envelope():
     script = Script()
     async with run_host(script) as (drv, host):

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_meta.py

@@ -131,10 +131,14 @@ async def test_meta_dies_with_a_dequeued_entry():
 async def test_unacked_run_end_reprojects_entries_with_meta():
     script = Script()
     async with run_host(script) as (drv, _):
-        drv.post("run/enqueue", add("m1", meta={"clientId": "c1"}))
+        drv.batch(
+            [
+                ("run/enqueue", add("m1", meta={"clientId": "c1"})),
+                ("run/steer", add("s1", meta={"clientId": "c2"})),
+            ]
+        )
         call = await script.next_call()
-        await drv.side("run/steer", add("s1", meta={"clientId": "c2"}))
-        call.ctx.steering.take()
+        assert [m["id"] for m in call.ctx.messages] == ["m1", "s1"]
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert drv.run["queue"][0]["meta"] == {"clientId": "c1"}

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_run_leaf.py

@@ -30,15 +30,18 @@ async def test_ready_state_has_no_run_entry():
         assert drv.replica["runs"] == []
 
 
-async def test_enqueue_dispatch_sets_the_leaf():
+async def test_ack_sets_the_leaf_to_the_last_batch_message():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
-        await script.next_call()
+        call = await script.next_call()
+        await drv.wait_status("running")
+        assert drv.run["runLeafMessageId"] is None
+        call.ack()
         await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m1")
 
 
-async def test_steer_dispatch_sets_the_leaf_to_the_last_lane_item():
+async def test_steer_batch_ack_sets_the_leaf_to_the_last_lane_item():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
@@ -49,10 +52,12 @@ async def test_steer_dispatch_sets_the_leaf_to_the_last_lane_item():
         call.finish(RunManager.Complete())
         steered = await script.next_call()
         assert steered.ctx.messages[-1]["id"] == "s2"
+        assert drv.run["runLeafMessageId"] == "m1"
+        steered.ack()
         await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "s2")
 
 
-async def test_steering_take_sets_the_leaf():
+async def test_steering_take_moves_the_leaf_at_its_ack():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
@@ -61,8 +66,9 @@ async def test_steering_take_sets_the_leaf():
         await drv.command("run/steer", add("s1", anchor="m1"), terminal=False)
         await drv.wait(lambda s: len(run_of(s).get("steerQueue", [])) == 1)
         call.ctx.steering.take()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "s1")
+        assert drv.run["runLeafMessageId"] == "m1"
         call.ack()
+        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "s1")
         call.finish(RunManager.Complete())
 
 
@@ -133,30 +139,53 @@ async def test_complete_with_a_queued_item_keeps_the_leaf_flowing():
         script.leaf = "a1"
         call.finish(RunManager.Complete())
         drain = await script.next_call()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m2")
         drain.ack()
+        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m2")
         drain.finish(RunManager.Complete())
         await drv.wait_status("ready")
         assert drv.replica["runs"] == []
 
 
-async def test_edit_dispatch_sets_the_leaf_to_the_replacement():
+async def test_rewind_dispatch_nulls_the_leaf_and_the_ack_records_the_replacement():
     script = Script()
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
-        await script.next_call()
+        call = await script.next_call()
+        await drv.wait_status("running")
+        assert drv.run["runLeafMessageId"] is None
+        call.ack()
         await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "u2")
 
 
-async def test_reload_dispatch_sets_the_leaf_to_the_rollback_target():
+async def test_reload_dispatch_nulls_the_leaf_until_the_settle_pull():
     script = Script()
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         drv.post("run/reload", {"sourceId": "a1"})
         call = await script.next_call()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "u1")
+        await drv.wait_status("running")
+        assert drv.run["runLeafMessageId"] is None
         call.ack()
+        assert drv.run["runLeafMessageId"] is None
         script.leaf = "a2"
         call.finish(RunManager.Stop(dispatch_queue=False))
         await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a2")
+
+
+async def test_unacked_rewind_end_restores_the_previous_leaf():
+    script = Script()
+    thread_with_turn(script)
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        drv.post("run/enqueue", add("m1", anchor="a1"))
+        call = await script.next_call()
+        call.ack()
+        script.leaf = "a2"
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a2")
+        drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
+        rerun = await script.next_call()
+        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") is None)
+        rerun.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert drv.run["runLeafMessageId"] == "a2"

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_settle.py

@@ -105,6 +105,7 @@ async def test_unacked_run_end_reverts_entries_to_the_lane_front():
         await drv.command("run/steer", {"messageId": "m1"}, terminal=False)
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
+        continued.ack()
         assert [m["id"] for m in continued.ctx.steering.take()] == ["m1"]
 
 
@@ -113,12 +114,14 @@ async def test_unacked_run_end_reverts_taken_steered_items():
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
+        call.ack()
         await drv.side("run/steer", add("s1"))
+        await drv.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
         call.ctx.steering.take()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
-        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert queue_ids(drv.replica, "queue") == []
 
 
 async def test_ack_removes_the_entries_for_good():

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_steer.py

@@ -55,6 +55,7 @@ async def test_steer_add_continues_in_error_and_stop(end, continue_type):
         assert continued.ctx.messages == ()
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
         assert continued.ctx.steering.available.is_set()
+        continued.ack()
         assert [m["id"] for m in continued.ctx.steering.take()] == ["s1"]
 
 
@@ -86,6 +87,7 @@ async def test_steer_edit_continues_in_error_with_replacement():
         await drv.command("run/steer", {"message": msg("m2", "edited")}, terminal=False)
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
+        continued.ack()
         taken = continued.ctx.steering.take()
         assert [m["parts"][0]["text"] for m in taken] == ["edited"]
 

{harness_sdk_python-0.7.2 → harness_sdk_python-0.8.0}/tests/test_stop_continue.py

@@ -234,6 +234,7 @@ async def test_continue_with_steer_lane_needs_no_capability():
         assert res["type"] == "pending"
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
+        continued.ack()
         assert [m["id"] for m in continued.ctx.steering.take()] == ["s1"]
         continued.ack()
         continued.finish(RunManager.Complete())