harness-sdk-python 0.4.1__tar.gz → 0.4.2__tar.gz

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/PKG-INFO

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

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

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/src/harness_sdk/run_manager.py

@@ -6,8 +6,14 @@ 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 into the lanes in order (pure placement), then takes
 exactly one action based on status and net effect (interrupt, dispatch, or
-continue). Late-settling commands (rewinds, stop) await a future the drain
+continue). A parked send settles at staging; run-starting commands settle at
+the executor's ``ctx.ack_messages()``; ``run/stop`` awaits a future the drain
 resolves once the in-flight run has ended.
+
+Dispatched entries leave the queue projection but are retained until the
+executor acks. A run that ends before the ack puts them back at the front of
+their lane and settles their sends accepted; edit, reload, and continue
+initiators settle rejected (``stopped`` or the failure).
 """
 
 import asyncio
@@ -101,7 +107,7 @@ class _Stop:
 
 @dataclass
 class _Continue:
-    pass
+    future: "asyncio.Future[Any]" = field(default_factory=_future)
 
 
 @dataclass
@@ -126,6 +132,8 @@ class _Effects:
     steer_added: bool = False
     new_added: bool = False
     continue_requested: bool = False
+    staged_sends: list[tuple[str, "asyncio.Future[Any]"]] = field(default_factory=list)
+    continues: list["asyncio.Future[Any]"] = field(default_factory=list)
 
 
 class RunManager:
@@ -170,7 +178,10 @@ class RunManager:
         self._staged_stops: list["asyncio.Future[Any]"] = []
         self._stop_reason: str | None = None
         self._staged_rewinds: list[_Rewind] = []
-        self._entity_futures: dict[str, "asyncio.Future[Any]"] = {}
+        self._dispatching: list[tuple[str, dict[str, Any]]] = []
+        self._run_acked = True
+        self._leaf_confirmed = leaf_message_id
+        self._send_futures: list["asyncio.Future[Any]"] = []
         self._run_futures: list["asyncio.Future[Any]"] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
@@ -203,6 +214,9 @@ class RunManager:
     def _continue_type(self) -> str:
         return "error-continue" if self._status() == "error" else "stop-continue"
 
+    def _is_dispatching(self, message_id: str) -> bool:
+        return any(item["id"] == message_id for _, item in self._dispatching)
+
     # ─── Staging and drain ──────────────────────────────────
 
     async def _stage(self, entry: Any) -> Any:
@@ -231,6 +245,8 @@ class RunManager:
                     rewind.messages,
                     rollback_to=rewind.rollback_to,
                 )
+                for message in rewind.messages:
+                    self._callers.pop(message["id"], None)
                 rewind.ack()
                 if not rewind.future.done():
                     self._run_futures.append(rewind.future)
@@ -245,6 +261,15 @@ class RunManager:
                 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:
+            if message_id in dispatching:
+                self._send_futures.append(future)
+            elif not future.done():
+                future.set_result(None)
+        for future in fx.continues:
+            if not future.done():
+                future.set_result(None)
 
     def _apply(self, entry: Any, fx: _Effects) -> None:
         if isinstance(entry, _Stop):
@@ -252,6 +277,7 @@ class RunManager:
             return
         if isinstance(entry, _Continue):
             fx.continue_requested = True
+            fx.continues.append(entry.future)
             return
         try:
             if isinstance(entry, _Send):
@@ -278,6 +304,8 @@ class RunManager:
         elif status in ("error", "stopped"):
             if fx.continue_requested or fx.steer_added:
                 self._dispatch(self._continue_type(), [])
+                self._run_futures.extend(fx.continues)
+                fx.continues.clear()
             elif fx.new_added and pre_empty:
                 self._pop_dispatchable()
         elif status == "input-required" and self._input_requests and len(
@@ -331,9 +359,6 @@ class RunManager:
         messages = [
             {k: v for k, v in message.items() if k != "caller"} for message in messages
         ]
-        for message in messages:
-            self._callers.pop(message["id"], None)
-        self._adopt_entities(message["id"] for message in messages)
         record: dict[str, Any] = {"type": type, "messages": list(messages)}
         if rollback_to is not _ABSENT:
             record["rollbackTo"] = rollback_to
@@ -341,6 +366,8 @@ class RunManager:
             record["responses"] = responses
         self._dispatch_record = record
         self._stop_reason = None
+        self._run_acked = False
+        self._leaf_confirmed = plain(self._state["runLeafMessageId"])
         self._state["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
@@ -377,23 +404,34 @@ class RunManager:
                     "start must return a RunManager outcome, got "
                     f"{type(outcome).__name__}"
                 )
+            if isinstance(
+                outcome, (RunManager.Complete, RunManager.InputRequired)
+            ) and (self._dispatching or not self._run_acked):
+                raise RuntimeError(
+                    "run settled without acking its messages"
+                    " (call ctx.ack_messages())"
+                )
         except Exception as exc:
             self._settle(ctx)
             message = str(exc) or type(exc).__name__
             if isinstance(exc, StatewireReject):
                 self._freeze(exc.message, exc.payload)
-                self._settle_entities(exc)
+                self._settle_initiators(exc)
             else:
                 self._freeze(message)
-                self._settle_entities(_reject("run-error", message))
+                self._settle_initiators(_reject("run-error", message))
+            self._revert_dispatching()
             self._drain()
             return
         self._settle(ctx)
-        self._settle_entities(
-            _reject("run-error", "run ended in error")
-            if isinstance(outcome, RunManager.Error)
-            else None
-        )
+        if 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")
+        else:
+            error = None
+        self._settle_initiators(error)
+        self._revert_dispatching()
         self._outcome = outcome
         self._drain()
 
@@ -403,7 +441,7 @@ class RunManager:
             self._task = None
         self._dispatch_record = None
 
-    def _settle_entities(self, error: StatewireReject | None) -> None:
+    def _settle_initiators(self, error: StatewireReject | None) -> None:
         futures, self._run_futures = self._run_futures, []
         for future in futures:
             if future.done():
@@ -413,21 +451,48 @@ class RunManager:
             else:
                 future.set_exception(error)
 
-    def _adopt_entities(self, ids: Iterable[str]) -> None:
-        for id in ids:
-            future = self._entity_futures.pop(id, None)
-            if future is not None:
-                self._run_futures.append(future)
+    def _settle_sends(self) -> None:
+        futures, self._send_futures = self._send_futures, []
+        for future in futures:
+            if not future.done():
+                future.set_result(None)
+
+    def _ack_messages(self) -> None:
+        taken, self._dispatching = self._dispatching, []
+        self._run_acked = True
+        for _, item in taken:
+            self._callers.pop(item["id"], None)
+        self._leaf_confirmed = plain(self._state["runLeafMessageId"])
+        self._settle_sends()
+        self._settle_initiators(None)
+
+    def _revert_dispatching(self) -> None:
+        self._settle_sends()
+        taken, self._dispatching = self._dispatching, []
+        if not taken:
+            return
+        for lane in ("steerQueue", "queue"):
+            front = [item for l, item in taken if l == lane]
+            if front:
+                self._state[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(self._state["runLeafMessageId"]) in ids:
+            self._state["runLeafMessageId"] = self._leaf_confirmed
 
     def _pop_dispatchable(self) -> bool:
         steer = self._lane_items("steerQueue")
         if steer:
             self._state["steerQueue"] = []
+            self._dispatching = [("steerQueue", item) for item in steer]
             self._dispatch("message-send", steer)
             return True
         queue = self._lane_items("queue")
         if queue:
             self._state["queue"].pop(0)
+            self._dispatching = [("queue", queue[0])]
             self._dispatch("message-send", [queue[0]])
             return True
         return False
@@ -619,7 +684,7 @@ class RunManager:
             if e.lane == "steerQueue":
                 fx.steer_added = True
             return None
-        if e.message_id in self._dispatched_ids:
+        if e.message_id in self._dispatched_ids or self._is_dispatching(e.message_id):
             return self._park_dispatched_edit(e)
         if e.meta is not None:
             raise _reject(
@@ -630,7 +695,7 @@ class RunManager:
         self._check_anchor(e)
         with self._caller_stamp(e.message_id, e.caller):
             self._insert_new(e.lane, e.message, e.params)
-        self._entity_futures[e.message_id] = e.future
+        fx.staged_sends.append((e.message_id, e.future))
         e.ack()
         fx.new_added = True
         if e.lane == "steerQueue":
@@ -640,7 +705,9 @@ class RunManager:
     def _apply_move(self, e: _Send, fx: _Effects) -> Any:
         current = self._lane_of(e.message_id)
         if current is None:
-            if e.message_id in self._dispatched_ids:
+            if e.message_id in self._dispatched_ids or self._is_dispatching(
+                e.message_id
+            ):
                 if e.lane == "steerQueue":
                     return None
                 raise _reject(
@@ -685,11 +752,6 @@ class RunManager:
         self._state[lane] = [
             item for item in self._lane_items(lane) if item["id"] != e.message_id
         ]
-        entity = self._entity_futures.pop(e.message_id, None)
-        if entity is not None and not entity.done():
-            entity.set_exception(
-                _reject("removed", f"message {e.message_id} was removed from the queue")
-            )
         return None
 
     def _apply_input(self, e: _Input) -> Any:
@@ -972,7 +1034,7 @@ class RunManager:
         response = self._validated_response(request["type"], params["response"])
         return await self._stage(_Input(request_id, response))
 
-    def continue_run(self) -> None:
+    async def continue_run(self, *, ack: Callable[[], None]) -> Any:
         status = self._status()
         if status not in ("error", "stopped"):
             raise _reject("wrong-state", f"run/continue is rejected in {status}")
@@ -983,8 +1045,11 @@ class RunManager:
                 "capability-missing",
                 "bare continue requires the incomplete-continuation capability",
             )
-        self._intake.append(_Continue())
+        entry = _Continue()
+        self._intake.append(entry)
+        ack()
         self._schedule(self._drain)
+        return await entry.future
 
     # ─── Outcomes and context ───────────────────────────────
 
@@ -1075,19 +1140,25 @@ class RunManager:
             self._ensure_active()
             items = self._manager._lane_items("steerQueue")
             self._manager._state["steerQueue"] = []
-            for item in items:
-                self._manager._callers.pop(item["id"], None)
-            self._manager._adopt_entities(item["id"] for item in items)
+            self._manager._dispatching.extend(("steerQueue", item) for item in items)
             if items:
                 self._manager._state["runLeafMessageId"] = items[-1]["id"]
             return tuple(
                 {k: v for k, v in item.items() if k != "caller"} for item in items
             )
 
+        def ack_messages(self) -> None:
+            self._ensure_active()
+            self._manager._ack_messages()
+
         def set_leaf_message_id(self, message_id: str) -> None:
             self._ensure_active()
             if not isinstance(message_id, str) or message_id == "":
                 raise ValueError("message_id must be a non-empty string")
+            if self._manager._dispatching or not self._manager._run_acked:
+                raise RuntimeError(
+                    "ack_messages must precede set_leaf_message_id"
+                )
             self._manager._state["runLeafMessageId"] = message_id
 
         def set_recovery_state(self, value: Any) -> None:

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/run_helpers.py

@@ -15,6 +15,9 @@ class Call:
     ctx: RunManager.StartContext
     outcome: "asyncio.Future[Any]"
 
+    def ack(self) -> None:
+        self.ctx.ack_messages()
+
     def finish(self, outcome: Any) -> None:
         self.outcome.set_result(outcome)
 
@@ -103,8 +106,8 @@ def make_host(script: Script, capabilities=(), initial_runs=None, max_queued=50)
             return await self.runs.stop(params, ack=ctx.ack)
 
         @command("run/continue")
-        async def run_continue(self):
-            self.runs.continue_run()
+        async def run_continue(self, *, ctx):
+            return await self.runs.continue_run(ack=ctx.ack)
 
         @command("run/input")
         async def run_input(self, params):

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_batches.py

@@ -27,6 +27,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.finish(RunManager.Complete())
         for offset in range(3):
             assert (await drv.res(first + offset))["type"] == "accepted"
@@ -40,7 +41,7 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
         first = await drv.batch(
             [("run/steer", add("s1")), ("run/stop", None)]
         )
-        assert (await drv.res(first, terminal=False))["type"] == "pending"
+        assert (await drv.res(first))["type"] == "accepted"
         assert (await drv.res(first + 1, terminal=False))["type"] == "pending"
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_caller.py

@@ -13,6 +13,7 @@ async def test_immediate_dispatch_carries_caller():
         call = await script.next_call()
         assert call.ctx.caller is not None
         assert call.ctx.caller.client_id == "c1"
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -24,6 +25,7 @@ async def test_queue_entry_projects_caller_client_id():
         await drv.command("run/enqueue", add("m2"), terminal=False)
         await drv.wait(lambda s: len(s["queue"]) == 1)
         assert drv.replica["queue"][0]["caller"] == {"clientId": "c1"}
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -34,12 +36,14 @@ async def test_caller_context_is_read_at_dispatch_time():
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
         assert (await drv.context({"user": "simon"}))["type"] == "accepted"
+        call.ack()
         call.finish(RunManager.Complete())
         dispatched = await script.next_call()
         assert dispatched.ctx.caller is not None
         assert dispatched.ctx.caller.context == {"user": "simon"}
         assert dispatched.ctx.messages[0]["id"] == "m2"
         assert "caller" not in dispatched.ctx.messages[0]
+        dispatched.ack()
         dispatched.finish(RunManager.Complete())
 
 
@@ -52,6 +56,7 @@ async def test_dispatch_without_queue_entry_has_no_caller():
         ] == "pending"
         call = await script.next_call()
         assert call.ctx.caller is None
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -65,6 +70,7 @@ async def test_take_steered_strips_the_caller_stamp():
         assert drv.replica["steerQueue"][0]["caller"] == {"clientId": "c1"}
         [taken] = call.ctx.take_steered()
         assert "caller" not in taken
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -85,6 +91,7 @@ async def test_max_queued_caps_each_lane():
         ] == "pending"
         steer_full = await drv.command("run/steer", add("s2"), terminal=False)
         assert steer_full["payload"] == {"reason": "queue-full"}
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -97,6 +104,7 @@ async def test_lane_change_into_a_full_lane_rejects():
         await drv.command("run/steer", add("s1"), terminal=False)
         moved = await drv.command("run/steer", {"messageId": "m2"}, terminal=False)
         assert moved["payload"] == {"reason": "queue-full"}
+        call.ack()
         call.finish(RunManager.Complete())
 
 

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_edit_dispatched.py

@@ -13,6 +13,7 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
         await drv.command("run/enqueue", add("m1"), terminal=False)
         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
         )
@@ -26,6 +27,7 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
         assert rerun.ctx.has_rollback
         assert rerun.ctx.rollback_to == "p0"
         await drv.wait_status("running")
+        rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         settled = await drv.res(pending["seq"])
         assert settled["type"] == "accepted"
@@ -62,6 +64,7 @@ async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         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
@@ -70,6 +73,7 @@ async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
         assert rerun.ctx.type == "message-edit"
+        rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(pending["seq"]))["type"] == "accepted"
         assert [item["id"] for item in drv.replica["queue"]] == ["m2"]
@@ -81,6 +85,7 @@ async def test_edit_of_dispatched_item_in_error_reruns_without_stop():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         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)

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_edit_reload.py

@@ -56,6 +56,7 @@ async def test_deep_edit_rejected_while_queue_non_empty():
         await drv.command("run/enqueue", add("m1", anchor="a1"), terminal=False)
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2", anchor="a1"), terminal=False)
+        call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert_rejected(
@@ -75,6 +76,7 @@ async def test_leaf_edit_in_error_accepted_with_queue_non_empty():
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
+        call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         res = await drv.command("run/edit", {"sourceId": "m1", "message": msg("u2")}, terminal=False)
@@ -131,6 +133,7 @@ async def test_reload_dispatches_with_empty_messages():
         assert call.ctx.type == "message-reload"
         assert call.ctx.messages == ()
         assert call.ctx.rollback_to == "u1"
+        call.ack()
         call.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -175,6 +178,7 @@ async def test_reload_leaf_only_while_queue_non_empty():
         script.thread["m1"] = {"parentId": "a0", "role": "user", "isLeaf": False, "onActiveBranch": True}
         script.thread["a1"] = {"parentId": "m1", "role": "assistant", "isLeaf": True, "onActiveBranch": True}
         await drv.command("run/enqueue", add("m2", anchor="a1"), terminal=False)
+        call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert_rejected(

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_enqueue.py

@@ -15,6 +15,7 @@ async def test_ready_add_dispatches_message_send():
         assert not call.ctx.has_rollback
         await drv.wait_status("running")
         assert "dispatch" not in drv.replica
+        call.ack()
         call.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -27,10 +28,12 @@ async def test_running_add_becomes_queue_item():
         await drv.command("run/enqueue", add("m2"), terminal=False)
         assert queue_ids(drv.replica, "queue") == ["m2"]
         script.no_call()
+        call.ack()
         call.finish(RunManager.Complete())
         drain = await script.next_call()
         assert drain.ctx.type == "message-send"
         assert [m["id"] for m in drain.ctx.messages] == ["m2"]
+        drain.ack()
         drain.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -42,12 +45,15 @@ async def test_queue_drains_fifo_one_item_per_run():
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
         await drv.command("run/enqueue", add("m3"), terminal=False)
+        call.ack()
         call.finish(RunManager.Complete())
         second = await script.next_call()
         assert [m["id"] for m in second.ctx.messages] == ["m2"]
+        second.ack()
         second.finish(RunManager.Complete())
         third = await script.next_call()
         assert [m["id"] for m in third.ctx.messages] == ["m3"]
+        third.ack()
         third.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -60,13 +66,16 @@ async def test_steer_lane_drains_first_and_whole():
         await drv.command("run/enqueue", add("q1"), terminal=False)
         await drv.command("run/steer", add("s1"), terminal=False)
         await drv.command("run/steer", add("s2"), terminal=False)
+        call.ack()
         call.finish(RunManager.Complete())
         steered = await script.next_call()
         assert steered.ctx.type == "message-send"
         assert [m["id"] for m in steered.ctx.messages] == ["s1", "s2"]
+        steered.ack()
         steered.finish(RunManager.Complete())
         regular = await script.next_call()
         assert [m["id"] for m in regular.ctx.messages] == ["q1"]
+        regular.ack()
         regular.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -75,7 +84,9 @@ async def test_error_add_with_empty_lanes_dispatches_immediately():
     script = Script()
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
-        (await script.next_call()).fail(RuntimeError("boom"))
+        call = await script.next_call()
+        call.ack()
+        call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         await drv.command("run/enqueue", add("m2"), terminal=False)
         call = await script.next_call()
@@ -90,6 +101,7 @@ async def test_error_add_with_queued_items_stays_queued():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
+        call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         await drv.command("run/enqueue", add("m3"), terminal=False)

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_facade.py

@@ -1,6 +1,7 @@
-"""Contract: entity-lifetime settle composed with the legacy facade. The
-``/chat`` response stays open while the steer entity is pending and EOFs once
-its run settles; a run rejection is a single error frame then EOF.
+"""Contract: run lifetime composed with the legacy facade. The ``/chat``
+response stays open through the run — past the send settling at the ack —
+and EOFs once the run task ends; a run rejection is a single error frame
+then EOF.
 """
 
 import asyncio
@@ -63,6 +64,7 @@ async def test_chat_holds_until_the_entity_run_settles_then_eofs():
             assert stream.status == 200
             call = await script.next_call()
             assert call.ctx.type == "message-send"
+            call.ack()
             await asyncio.sleep(0.05)
             assert stream._task is not None and not stream._task.done()
             call.finish(RunManager.Complete())

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_input_required.py

@@ -18,7 +18,9 @@ def approval(id: str, tool_call_id: str = "tc1") -> dict:
 
 async def park(drv, script, requests, *, anchor=None):
     await drv.command("run/enqueue", add("m1", anchor=anchor), terminal=False)
-    (await script.next_call()).finish(RunManager.InputRequired(requests))
+    call = await script.next_call()
+    call.ack()
+    call.finish(RunManager.InputRequired(requests))
     await drv.wait_status("input-required")
 
 
@@ -70,6 +72,7 @@ async def test_completing_answer_resumes_with_ordered_responses():
             (approval("r2"), {"decision": "approve"}),
         )
         assert "inputRequests" not in drv.replica
+        resumed.ack()
         resumed.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -94,6 +97,7 @@ async def test_completing_batch_resumes_once_in_the_same_envelope():
         assert resumed.ctx.type == "input-resume"
         assert [r["id"] for r, _ in resumed.ctx.responses] == ["r1", "r2"]
         script.no_call()
+        resumed.ack()
         resumed.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -113,6 +117,7 @@ async def test_same_batch_duplicate_first_applies_second_rejects():
         resumed = await script.next_call()
         assert resumed.ctx.responses == ((tool_call("r1"), {"output": "a"}),)
         script.no_call()
+        resumed.ack()
         resumed.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -134,6 +139,7 @@ async def test_input_rejections():
             ),
             "wrong-state",
         )
+        call.ack()
         call.finish(RunManager.InputRequired([tool_call("r1"), tool_call("r2")]))
         await drv.wait_status("input-required")
         assert_rejected(await drv.command("run/input", "nope"), "invalid-message")
@@ -196,6 +202,7 @@ async def test_custom_request_type_passes_through():
         )["type"] == "accepted"
         resumed = await script.next_call()
         assert resumed.ctx.responses == ((request, response),)
+        resumed.ack()
         resumed.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -241,9 +248,11 @@ async def test_queue_while_parked_dispatches_after_resume():
         )
         resumed = await script.next_call()
         assert resumed.ctx.type == "input-resume"
+        resumed.ack()
         resumed.finish(RunManager.Complete())
         drain = await script.next_call()
         assert [m["id"] for m in drain.ctx.messages] == ["m2"]
+        drain.ack()
         drain.finish(RunManager.Complete())
         await drv.wait_status("ready")
 

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_outcomes.py

@@ -33,6 +33,7 @@ async def test_set_recovery_state_stays_out_of_replicated_state():
         call = await script.next_call()
         call.ctx.set_recovery_state({"checkpoint": 7})
         assert "dispatch" not in drv.replica
+        call.ack()
         call.finish(RunManager.Complete())
         await drv.wait_status("ready")
         with pytest.raises(RuntimeError, match="already settled"):
@@ -45,6 +46,7 @@ async def test_uncaught_raise_freezes_and_sets_state_error():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
+        call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert drv.replica["error"] == {"message": "boom"}
@@ -57,7 +59,9 @@ async def test_state_error_cleared_by_next_user_initiated_entry():
     script = Script()
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
-        (await script.next_call()).fail(RuntimeError("boom"))
+        call = await script.next_call()
+        call.ack()
+        call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         await drv.command("run/enqueue", add("m2"), terminal=False)
         await script.next_call()
@@ -81,6 +85,7 @@ async def test_error_outcome_freezes_without_state_error():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
+        call.ack()
         call.finish(RunManager.Error(dispatch_queue=False))
         await drv.wait_status("error")
         assert drv.replica["error"] is None
@@ -94,9 +99,11 @@ async def test_error_outcome_with_dispatch_queue_drains():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
+        call.ack()
         call.finish(RunManager.Error(dispatch_queue=True))
         drain = await script.next_call()
         assert [m["id"] for m in drain.ctx.messages] == ["m2"]
+        drain.ack()
         drain.finish(RunManager.Complete())
         await drv.wait_status("ready")
 
@@ -105,7 +112,9 @@ async def test_error_outcome_with_dispatch_queue_and_empty_lanes_freezes():
     script = Script()
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
-        (await script.next_call()).finish(RunManager.Error(dispatch_queue=True))
+        call = await script.next_call()
+        call.ack()
+        call.finish(RunManager.Error(dispatch_queue=True))
         await drv.wait_status("error")
         script.no_call()
 

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_rewind_during_run.py

@@ -11,6 +11,7 @@ async def start_run(drv, script, *, leaf=True):
     call = await script.next_call()
     script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": leaf, "onActiveBranch": True}
     script.thread["a1"] = {"parentId": "m1", "role": "assistant", "isLeaf": leaf, "onActiveBranch": True}
+    call.ack()
     return call
 
 
@@ -29,6 +30,7 @@ async def test_running_leaf_edit_stops_settles_then_rewinds():
         assert rerun.ctx.type == "message-edit"
         assert [m["id"] for m in rerun.ctx.messages] == ["m2"]
         assert rerun.ctx.rollback_to is None
+        rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(pending["seq"]))["type"] == "accepted"
 
@@ -46,6 +48,7 @@ async def test_running_leaf_edit_accepted_with_non_empty_queues():
         call.finish(RunManager.Stop(dispatch_queue=False))
         rerun = await script.next_call()
         assert rerun.ctx.type == "message-edit"
+        rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(pending["seq"]))["type"] == "accepted"
         assert queue_ids(drv.replica, "queue") == ["q1"]
@@ -66,6 +69,7 @@ async def test_running_leaf_reload_stops_settles_then_rewinds():
         rerun = await script.next_call()
         assert rerun.ctx.type == "message-reload"
         assert rerun.ctx.rollback_to == "m1"
+        rerun.ack()
         rerun.finish(RunManager.Stop(dispatch_queue=False))
         assert (await drv.res(pending["seq"]))["type"] == "accepted"
         assert queue_ids(drv.replica, "queue") == ["q1"]

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_run_leaf.py

@@ -41,6 +41,7 @@ async def test_steer_dispatch_sets_the_leaf_to_the_last_lane_item():
         call = await script.next_call()
         await drv.command("run/steer", add("s1", anchor="m1"), terminal=False)
         await drv.command("run/steer", add("s2", anchor="s1"), terminal=False)
+        call.ack()
         call.finish(RunManager.Complete())
         steered = await script.next_call()
         assert steered.ctx.messages[-1]["id"] == "s2"
@@ -56,6 +57,7 @@ async def test_take_steered_sets_the_leaf():
         await drv.wait(lambda s: len(s["steerQueue"]) == 1)
         call.ctx.take_steered()
         await drv.wait(lambda s: s["runLeafMessageId"] == "s1")
+        call.ack()
         call.finish(RunManager.Complete())
 
 
@@ -64,6 +66,7 @@ async def test_executor_report_sets_the_leaf():
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
+        call.ack()
         call.ctx.set_leaf_message_id("a1")
         await drv.wait(lambda s: s["runLeafMessageId"] == "a1")
         call.finish(RunManager.Complete())
@@ -89,6 +92,7 @@ async def test_reload_dispatch_sets_the_leaf_to_the_rollback_target():
         await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
         call = await script.next_call()
         await drv.wait(lambda s: s["runLeafMessageId"] == "u1")
+        call.ack()
         call.ctx.set_leaf_message_id("a2")
         await drv.wait(lambda s: s["runLeafMessageId"] == "a2")
 
@@ -100,6 +104,7 @@ async def test_report_rejects_an_empty_id():
         call = await script.next_call()
         with pytest.raises(ValueError, match="non-empty"):
             call.ctx.set_leaf_message_id("")
+        call.ack()
         call.finish(RunManager.Complete())
 
 

harness_sdk_python-0.4.2/tests/test_settle.py

@@ -0,0 +1,218 @@
+"""Contract: command settlement. A parked send settles accepted at staging and
+stays projected in its lane; a run-starting command answers pending at
+placement and settles at the executor's ``ctx.ack_messages()``. A run that
+ends before the ack settles then: enqueue/steer accepted, their entries back
+at the front of their lane and ``state.error`` carrying any failure;
+edit/reload/continue rejected (``stopped`` or the failure)."""
+
+import asyncio
+
+import pytest
+from run_helpers import Script, add, msg, queue_ids, run_host
+
+from statewire import StatewireReject
+
+from harness_sdk import RunManager
+
+
+async def test_enqueue_settles_accepted_at_the_ack():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        pending = await drv.command("run/enqueue", add("m1"), terminal=False)
+        assert pending["type"] == "pending"
+        call = await script.next_call()
+        call.ack()
+        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+        call.finish(RunManager.Complete())
+
+
+async def test_parked_send_settles_accepted_at_staging():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        assert (await drv.command("run/enqueue", add("m2")))["type"] == "accepted"
+        assert (await drv.command("run/steer", add("s1")))["type"] == "accepted"
+        assert queue_ids(drv.replica, "queue") == ["m2"]
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        call.ack()
+        call.finish(RunManager.Complete())
+
+
+async def test_run_reject_lands_the_payload_on_state_error():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        pending = await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        call.fail(
+            StatewireReject(
+                "payment required",
+                payload={"reason": "payment-required", "url": "https://pay.example"},
+            )
+        )
+        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert drv.replica["error"] == {
+            "message": "payment required",
+            "reason": "payment-required",
+            "url": "https://pay.example",
+        }
+
+
+async def test_unacked_run_end_settles_the_send_accepted():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        for outcome in [
+            lambda call: call.fail(RuntimeError("boom")),
+            lambda call: call.finish(RunManager.Error(dispatch_queue=False)),
+        ]:
+            pending = await drv.command("run/enqueue", add("m1"), terminal=False)
+            outcome(await script.next_call())
+            assert (await drv.res(pending["seq"]))["type"] == "accepted"
+            await drv.wait_status("error")
+            assert queue_ids(drv.replica, "queue") == ["m1"]
+            await drv.command("run/dequeue", {"messageId": "m1"})
+
+
+async def test_unacked_run_end_rejects_a_rewind_initiator():
+    for end, reason in [("crash", "run-error"), ("stop", "stopped")]:
+        script = Script()
+        script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
+        async with run_host(script, capabilities=("rewind",)) as (drv, host):
+            pending = await drv.command(
+                "run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False
+            )
+            rerun = await script.next_call()
+            if end == "crash":
+                rerun.fail(RuntimeError("boom"))
+            else:
+                await drv.command("run/stop", terminal=False)
+                rerun.finish(RunManager.Stop(dispatch_queue=False))
+            settled = await drv.res(pending["seq"])
+            assert settled["type"] == "rejected"
+            assert settled["payload"] == {"reason": reason}
+
+
+async def test_unacked_run_end_reverts_entries_to_the_lane_front():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        await drv.command("run/enqueue", add("m2"))
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
+        assert drv.replica["error"] == {"message": "boom"}
+        assert drv.replica["queue"][0]["caller"] == {"clientId": "c1"}
+        assert drv.replica["runLeafMessageId"] is None
+        await drv.command("run/steer", {"messageId": "m1"}, terminal=False)
+        continued = await script.next_call()
+        assert continued.ctx.type == "error-continue"
+        assert [m["id"] for m in continued.ctx.take_steered()] == ["m1"]
+
+
+async def test_unacked_run_end_reverts_taken_steered_items():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        await drv.command("run/steer", add("s1"))
+        call.ctx.take_steered()
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+
+
+async def test_ack_removes_the_entries_for_good():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        call.ack()
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "queue") == []
+
+
+async def test_complete_without_ack_is_a_run_error():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        pending = await drv.command("run/enqueue", add("m1"), terminal=False)
+        (await script.next_call()).finish(RunManager.Complete())
+        await drv.wait_status("error")
+        assert "ack_messages" in drv.replica["error"]["message"]
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+
+
+async def test_set_leaf_before_ack_raises():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        with pytest.raises(RuntimeError, match="ack_messages"):
+            call.ctx.set_leaf_message_id("a1")
+        call.ack()
+        call.finish(RunManager.Complete())
+
+
+async def test_dequeue_removes_a_parked_entry():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        await drv.command("run/enqueue", add("m2"))
+        assert (await drv.command("run/dequeue", {"messageId": "m2"}))[
+            "type"
+        ] == "accepted"
+        assert queue_ids(drv.replica, "queue") == []
+        call.ack()
+        call.finish(RunManager.Complete())
+
+
+async def test_stop_lands_while_a_steer_is_parked():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        assert (await drv.command("run/steer", add("s1")))["type"] == "accepted"
+        stop = await drv.command("run/stop", terminal=False)
+        assert stop["type"] == "pending"
+        await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        assert (await drv.res(stop["seq"]))["type"] == "accepted"
+        await drv.wait_status("stopped")
+        # The unconsumed steer stays parked; the unacked dispatch reverts.
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+
+
+async def test_rewind_edit_settles_at_the_reruns_ack():
+    script = Script()
+    script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        pending = await drv.command(
+            "run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False
+        )
+        assert pending["type"] == "pending"
+        rerun = await script.next_call()
+        assert rerun.ctx.type == "message-edit"
+        rerun.ack()
+        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+        rerun.finish(RunManager.Complete())
+
+
+async def test_rewind_edit_failure_settles_with_the_payload():
+    script = Script()
+    script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        pending = await drv.command(
+            "run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False
+        )
+        rerun = await script.next_call()
+        rerun.fail(StatewireReject("payment required", payload={"code": 402}))
+        settled = await drv.res(pending["seq"])
+        assert settled["type"] == "rejected"
+        assert settled["payload"] == {"code": 402}

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_steer.py

@@ -26,6 +26,7 @@ async def test_running_steer_parks_until_take_steered():
         taken = call.ctx.take_steered()
         assert [m["id"] for m in taken] == ["s1", "s2"]
         assert call.ctx.has_steered() is False
+        call.ack()
         call.finish(RunManager.Complete())
         await drv.wait_status("ready")
         assert queue_ids(drv.replica, "steerQueue") == []
@@ -40,6 +41,7 @@ async def test_steer_add_continues_in_error_and_stop(end, continue_type):
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
+        call.ack()
         if end == "error":
             call.fail(RuntimeError("boom"))
         else:
@@ -60,6 +62,7 @@ async def test_steer_move_continues_in_error():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
+        call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         await drv.command("run/steer", {"messageId": "m2"}, terminal=False)
@@ -75,6 +78,7 @@ async def test_steer_edit_continues_in_error_with_replacement():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
+        call.ack()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         await drv.command("run/steer", {"message": msg("m2", "edited")}, terminal=False)
@@ -101,6 +105,7 @@ async def test_stale_context_steer_access_raises():
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
+        call.ack()
         call.finish(RunManager.Complete())
         await drv.wait_status("ready")
         with pytest.raises(RuntimeError, match="already settled"):

{harness_sdk_python-0.4.1 → harness_sdk_python-0.4.2}/tests/test_stop_continue.py

@@ -29,6 +29,7 @@ async def test_stop_outcome_can_keep_the_queue_draining():
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
         await drv.command("run/stop", terminal=False)
+        call.ack()
         call.finish(RunManager.Stop(dispatch_queue=True))
         drain = await script.next_call()
         assert drain.ctx.type == "message-send"
@@ -59,6 +60,7 @@ async def test_stop_reason_resets_for_the_next_run():
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2"), terminal=False)
         await drv.command("run/stop", {"reason": "user-stop"}, terminal=False)
+        call.ack()
         call.finish(RunManager.Stop(dispatch_queue=True))
         drain = await script.next_call()
         assert drain.ctx.stop_reason is None
@@ -91,9 +93,9 @@ async def test_stop_in_input_required_cancels_the_parked_run():
     script = Script()
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
-        (await script.next_call()).finish(
-            RunManager.InputRequired([{"type": "free-form", "id": "r1"}])
-        )
+        call = await script.next_call()
+        call.ack()
+        call.finish(RunManager.InputRequired([{"type": "free-form", "id": "r1"}]))
         await drv.wait_status("input-required")
         assert (await drv.command("run/stop"))["type"] == "accepted"
         await drv.wait_status("stopped")
@@ -105,6 +107,7 @@ async def test_stop_settles_even_when_the_run_completes_normally():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         pending = await drv.command("run/stop", terminal=False)
+        call.ack()
         call.finish(RunManager.Complete())
         assert (await drv.res(pending["seq"]))["type"] == "accepted"
         await drv.wait_status("ready")
@@ -128,11 +131,14 @@ async def test_bare_continue_with_incomplete_continuation(end, continue_type):
             await drv.command("run/stop", terminal=False)
             call.finish(RunManager.Stop(dispatch_queue=False))
         await drv.wait_status(end)
-        assert (await drv.command("run/continue"))["type"] == "accepted"
+        res = await drv.command("run/continue", terminal=False)
+        assert res["type"] == "pending"
         continued = await script.next_call()
         assert continued.ctx.type == continue_type
         assert continued.ctx.messages == ()
         assert not continued.ctx.has_rollback
+        continued.ack()
+        assert (await drv.res(res["seq"]))["type"] == "accepted"
 
 
 async def test_bare_continue_without_capability_rejects():
@@ -152,10 +158,13 @@ async def test_continue_with_steer_lane_needs_no_capability():
         await drv.command("run/steer", add("s1"), terminal=False)
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        assert (await drv.command("run/continue"))["type"] == "accepted"
+        res = await drv.command("run/continue", terminal=False)
+        assert res["type"] == "pending"
         continued = await script.next_call()
         assert continued.ctx.type == "error-continue"
         assert [m["id"] for m in continued.ctx.take_steered()] == ["s1"]
+        continued.ack()
+        assert (await drv.res(res["seq"]))["type"] == "accepted"
 
 
 @pytest.mark.parametrize("state", ["ready", "running"])
@@ -166,3 +175,21 @@ async def test_continue_rejected_outside_error_stop(state):
             await drv.command("run/enqueue", add("m1"), terminal=False)
             await script.next_call()
         assert_rejected(await drv.command("run/continue"), "wrong-state")
+
+
+async def test_unacked_continued_run_end_rejects_the_continue():
+    script = Script()
+    async with run_host(script, capabilities=("incomplete-continuation",)) as (
+        drv,
+        host,
+    ):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        call.ack()
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        res = await drv.command("run/continue", terminal=False)
+        (await script.next_call()).fail(RuntimeError("boom again"))
+        settled = await drv.res(res["seq"])
+        assert settled["type"] == "rejected"
+        assert settled["payload"] == {"reason": "run-error"}

harness_sdk_python-0.4.1/tests/test_settle.py

@@ -1,131 +0,0 @@
-"""Contract: entity-lifetime settle. A run-creating command answers pending at
-placement and settles when its entity's run reaches a terminal state; discard
-before dispatch rejects with ``removed``.
-"""
-
-import asyncio
-
-from run_helpers import Script, add, msg, run_host
-
-from statewire import StatewireReject
-
-from harness_sdk import RunManager
-
-
-async def test_enqueue_settles_accepted_when_its_run_completes():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        pending = await drv.command("run/enqueue", add("m1"), terminal=False)
-        assert pending["type"] == "pending"
-        call = await script.next_call()
-        call.finish(RunManager.Complete())
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
-
-
-async def test_run_reject_settles_the_entity_with_the_payload():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        pending = await drv.command("run/enqueue", add("m1"), terminal=False)
-        call = await script.next_call()
-        call.fail(
-            StatewireReject(
-                "payment required",
-                payload={"reason": "payment-required", "url": "https://pay.example"},
-            )
-        )
-        settled = await drv.res(pending["seq"])
-        assert settled["type"] == "rejected"
-        assert settled["message"] == "payment required"
-        assert settled["payload"] == {
-            "reason": "payment-required",
-            "url": "https://pay.example",
-        }
-        await drv.wait_status("error")
-        assert drv.replica["error"] == {
-            "message": "payment required",
-            "reason": "payment-required",
-            "url": "https://pay.example",
-        }
-
-
-async def test_run_crash_settles_the_entity_as_run_error():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        pending = await drv.command("run/enqueue", add("m1"), terminal=False)
-        (await script.next_call()).fail(RuntimeError("boom"))
-        settled = await drv.res(pending["seq"])
-        assert settled["type"] == "rejected"
-        assert settled["message"] == "boom"
-        assert settled["payload"] == {"reason": "run-error"}
-
-
-async def test_error_outcome_settles_the_entity_as_run_error():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        pending = await drv.command("run/enqueue", add("m1"), terminal=False)
-        (await script.next_call()).finish(RunManager.Error(dispatch_queue=False))
-        settled = await drv.res(pending["seq"])
-        assert settled["type"] == "rejected"
-        assert settled["payload"] == {"reason": "run-error"}
-
-
-async def test_steer_settles_with_the_run_that_consumed_it():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        call = await script.next_call()
-        pending = await drv.command("run/steer", add("s1"), terminal=False)
-        assert pending["type"] == "pending"
-        call.ctx.take_steered()
-        call.finish(RunManager.Complete())
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
-
-
-async def test_dequeue_settles_the_queued_entity_as_removed():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        call = await script.next_call()
-        pending = await drv.command("run/enqueue", add("m2"), terminal=False)
-        assert pending["type"] == "pending"
-        assert (await drv.command("run/dequeue", {"messageId": "m2"}))["type"] == "accepted"
-        settled = await drv.res(pending["seq"])
-        assert settled["type"] == "rejected"
-        assert settled["payload"] == {"reason": "removed"}
-        call.finish(RunManager.Complete())
-
-
-async def test_stop_lands_while_a_steer_is_parked():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        call = await script.next_call()
-        steer = await drv.command("run/steer", add("s1"), terminal=False)
-        assert steer["type"] == "pending"
-        stop = await drv.command("run/stop", terminal=False)
-        assert stop["type"] == "pending"
-        await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
-        call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(stop["seq"]))["type"] == "accepted"
-        await drv.wait_status("stopped")
-        # The unconsumed steer entity stays parked in its lane.
-        assert [item["id"] for item in drv.replica["steerQueue"]] == ["s1"]
-        assert all(
-            rsp["type"] == "pending" for rsp in drv._res.get(steer["seq"], [])
-        )
-
-
-async def test_rewind_edit_settles_when_the_rerun_ends():
-    script = Script()
-    script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
-    async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        pending = await drv.command(
-            "run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False
-        )
-        assert pending["type"] == "pending"
-        rerun = await script.next_call()
-        assert rerun.ctx.type == "message-edit"
-        rerun.fail(StatewireReject("payment required", payload={"code": 402}))
-        settled = await drv.res(pending["seq"])
-        assert settled["type"] == "rejected"
-        assert settled["payload"] == {"code": 402}