harness-sdk-python 0.36.4__tar.gz → 0.36.6__tar.gz

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.36.4
+Version: 0.36.6
 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.36.4 → harness_sdk_python-0.36.6}/pyproject.toml

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

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/src/harness_sdk/deepagents.py

@@ -148,6 +148,8 @@ class DeepagentsMessages:
         self._captured: dict[str, Any] | None = None
         self._admission: Any | None = None
         self._input_checkpoint_seen = False
+        self._handle: Any = None
+        self._output_seen = False
         self._ephemeral: dict[str, dict[str, Any]] = {}
         self._write_lock = asyncio.Lock()
 
@@ -208,6 +210,8 @@ class DeepagentsMessages:
         for message in ctx.messages:
             turn.append(self._append_user(message))
         self.admit(ctx.applied())
+        if plan.fork or ctx.input_outcomes:
+            self._handle = None
         if plan.fork:
             if plan.checkpoint_id is not None:
                 config["configurable"]["checkpoint_id"] = plan.checkpoint_id
@@ -223,6 +227,34 @@ class DeepagentsMessages:
         if self._admission is not None:
             raise RuntimeError("previous input admission is still pending")
         self._admission = admission
+        self._handle = admission
+        self._output_seen = False
+
+    @property
+    def retractable(self) -> bool:
+        """Whether the current turn can still be retracted: a tip dispatch's admitted batch before any graph output."""
+        return self._handle is not None and not self._output_seen
+
+    async def retract_turn(self) -> None:
+        """Retract the current turn: ``undo().dur()`` its batch, drop it from the wire, and fork the checkpointer tip back to the pre-turn checkpoint."""
+        if not self.retractable:
+            raise RuntimeError("the turn is not retractable")
+        handle = self._handle
+        self.abandon_turn()
+        handle.undo().dur()
+        self._restamp()
+        async with self._write_lock:
+            latest = await self._store.get(None)
+            if (
+                latest is not None
+                and latest.checkpoint_id != self._thread.checkpoint_id
+            ):
+                checkpoint_id = await self._clone_tip(self._thread.checkpoint_id)
+                await self._thread.ingest(
+                    Snapshot(
+                        checkpoint_id, self._thread.transcript, self._thread.lineage
+                    )
+                )
 
     def checkpoint_saved(self, config: Any, checkpoint: Any, metadata: Any) -> None:
         """Confirm this turn's input from a FrontierCheckpointer checkpoint callback."""
@@ -246,7 +278,10 @@ class DeepagentsMessages:
                 self._captured = event
                 if event["metadata"]["source"] in ("input", "loop"):
                     self._input_checkpoint_seen = True
+                if event["metadata"]["source"] == "loop":
+                    self._output_seen = True
             return
+        self._output_seen = True
         from statewire.langgraph import append_langgraph_event
 
         append_langgraph_event(self._state, namespace, mode, event)
@@ -263,6 +298,7 @@ class DeepagentsMessages:
         """Discard a stream capture and any fork planned for the abandoned turn."""
         self._captured = None
         self._admission = None
+        self._handle = None
         self._input_checkpoint_seen = False
         self._thread.abandon_plan()
 
@@ -329,21 +365,20 @@ class DeepagentsMessages:
             await self._thread.ingest(Snapshot(checkpoint_id, transcript, lineage))
             self._restamp()
 
-    async def _clone_tip(self, checkpoint_id: str) -> str:
+    async def _clone_tip(self, checkpoint_id: str | None) -> str:
+        from langgraph.checkpoint.base import empty_checkpoint
         from langgraph.checkpoint.base.id import uuid6
 
-        parent = {
-            "configurable": {
-                "thread_id": self._thread_id,
-                "checkpoint_ns": "",
-                "checkpoint_id": checkpoint_id,
-            }
-        }
-        saved = await self._checkpointer.aget_tuple(parent)
-        if saved is None:
-            raise LookupError(f"checkpoint {checkpoint_id!r} is not in the checkpointer")
+        parent = {"configurable": {"thread_id": self._thread_id, "checkpoint_ns": ""}}
+        if checkpoint_id is None:
+            saved = None
+        else:
+            parent["configurable"]["checkpoint_id"] = checkpoint_id
+            saved = await self._checkpointer.aget_tuple(parent)
+            if saved is None:
+                raise LookupError(f"checkpoint {checkpoint_id!r} is not in the checkpointer")
         clone = {
-            **saved.checkpoint,
+            **(empty_checkpoint() if saved is None else saved.checkpoint),
             "id": str(uuid6(clock_seq=-2)),
             "ts": datetime.now(timezone.utc).isoformat(),
         }

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/src/harness_sdk/run_manager.py

@@ -36,7 +36,12 @@ durably confirmed redelivers in resume mode instead (``ctx.resume``): the
 input batch must not be re-dispatched (``messages`` and the rollback surface
 raise; meta and input outcomes stay readable) and the run continues from its
 own continuation state (``ctx.state`` or an external checkpointer).
-``Complete`` with an unconfirmed batch settles as an error.
+``Complete`` with an unconfirmed batch settles as an error. ``undo()`` on an
+admission handle retracts its batch and every later one (newest first);
+``dur()`` then publishes the retraction. Retracted items re-present as
+``dispatching`` and return to their lane fronts at settle, the ``run/stop``
+verdict carries them, and the run must end ``Stop``/``Error`` with
+``dispatch_queue=False``.
 
 ``epoch`` counts the entry's dispatches (not redeliveries); a ``run/stop``
 carrying an ``epoch`` other than the live one rejects. A mid-run stop or
@@ -399,6 +404,7 @@ class RunManager(Tray):
         self._batch: list[tuple[str, dict[str, Any]]] = []
         self._pending_takes = 0
         self._admissions: list[RunManager.Admission] = []
+        self._retracted: list[dict[str, Any]] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
         self._run_live: "RunManager.RunContext | None" = None
@@ -455,6 +461,12 @@ class RunManager(Tray):
                 self._replay_settle()
                 self._outcome = settled
         recorded = self.outbox.value
+        if recorded is not None and not recorded["item"].get("durableAdmission", False):
+            self.steerQueue.untake(self.confirmedTakes.value)
+            self.confirmedTakes.value = 0
+            self.batchApplied.value = False
+            recorded = {**recorded, "item": {**recorded["item"], "durableAdmission": True}}
+            self.outbox.value = recorded
         if recorded is not None and not self.batchApplied.value:
             record = recorded["item"]["record"]
             lanes = recorded["item"]["lanes"]
@@ -611,9 +623,10 @@ class RunManager(Tray):
 
     def _resolve_stop_waiters(self) -> None:
         waiters, self._stop_waiters = self._stop_waiters, []
+        retracted, self._retracted = self._retracted, []
         for future in waiters:
             if not future.done():
-                future.set_result(None)
+                future.set_result(retracted)
 
     def _settle_applied(self, fx: _Effects) -> None:
         for future, applied, result in fx.staged_sends:
@@ -681,7 +694,7 @@ class RunManager(Tray):
                 self._stop_staged = True
                 self._stop_waiters.append(entry.future)  # the verdict waits for the settle
             elif not entry.future.done():
-                entry.future.set_result(None)
+                entry.future.set_result([])
             return
         if isinstance(entry, _Continue):
             if not fx.continue_requested:
@@ -801,7 +814,11 @@ class RunManager(Tray):
             root_meta=root_meta,
             input_outcomes=input_outcomes,
         )
-        item = {"record": record, "lanes": [lane for lane, _ in self._batch]}
+        item = {
+            "record": record,
+            "lanes": [lane for lane, _ in self._batch],
+            "durableAdmission": True,
+        }
         self.kick()
         self.stopReason.value = None
         self.epoch.value = self.epoch.value + 1
@@ -918,9 +935,17 @@ class RunManager(Tray):
                     f"{type(outcome).__name__}"
                 )
             if isinstance(outcome, RunManager.Complete) and (
-                self.dispatching.value is not None or self._admissions
+                self.dispatching.value is not None or self._unconsumed()
             ):
                 raise RuntimeError("run returned Complete with an unconfirmed batch")
+            if (
+                isinstance(outcome, (RunManager.Stop, RunManager.Error))
+                and outcome.dispatch_queue
+                and self._undone()
+            ):
+                raise RuntimeError(
+                    "dispatch_queue=True would redispatch an undone batch"
+                )
         except EvictionRequested:
             self._advance()
             if self._stop_staged or ctx._tray_ctx.consumed:
@@ -1033,12 +1058,19 @@ class RunManager(Tray):
     def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._run_live is ctx:
             self._run_live = None
-        takes = self._pending_takes + sum(a._takes for a in self._admissions)
+        unconsumed = self._unconsumed()
+        self._retracted = [
+            _public(message)
+            for admission in self._admissions
+            if admission._undone
+            for _, message in admission._batch
+        ]
+        takes = self._pending_takes + sum(a._takes for a in unconsumed)
         if takes:
             self.steerQueue.untake(takes)
             self._drop_dispatched(
                 message["id"]
-                for admission in self._admissions
+                for admission in unconsumed
                 if admission._takes
                 for _, message in admission._batch
             )
@@ -1046,6 +1078,8 @@ class RunManager(Tray):
                 self._drop_dispatched(message["id"] for _, message in self._batch)
                 self._batch = []
             self._pending_takes = 0
+        if any(not a._takes for a in unconsumed):
+            self.batchApplied.value = False  # an undone dispatch settles unapplied
         self._admissions.clear()
         recorded = self.outbox.value
         if recorded is not None and not self.batchApplied.value:
@@ -1095,7 +1129,15 @@ class RunManager(Tray):
         self.dispatching.value = None
         self._finish_settle()
 
+    def _unconsumed(self) -> list["RunManager.Admission"]:
+        return [a for a in self._admissions if not a._published or a._undone]
+
+    def _undone(self) -> bool:
+        return any(a._undone for a in self._admissions)
+
     def _applied(self, ctx: "RunManager.RunContext") -> "RunManager.Admission":
+        if self._undone():
+            raise RuntimeError("applied() after undo()")
         if self.dispatching.value is None:
             raise RuntimeError("applied() with no unapplied batch")
         admission = RunManager.Admission(ctx, list(self._batch), self._pending_takes)
@@ -1413,7 +1455,8 @@ class RunManager(Tray):
         lane = self._lane_of(e.message_id)
         if lane is None:
             raise _reject("unknown-id", f"message {e.message_id} is not queued")
-        self._check_author(e.message_id, e.principal)
+        if e.principal != self.principal.value or self.principal.value is None:
+            self._check_author(e.message_id, e.principal)
         self._lane(lane).value = [
             item for item in self._lane_items(lane) if item["id"] != e.message_id
         ]
@@ -1603,6 +1646,8 @@ class RunManager(Tray):
             """Drain the steer lane into a fresh dispatch record (deferred durable pops); requires the current batch to be applied."""
             self._ctx._ensure_active()
             manager = self._ctx._manager
+            if manager._undone():
+                raise RuntimeError("take() after undo()")
             if manager.dispatching.value is not None:
                 raise RuntimeError("take before the current batch is applied")
             items = manager.steerQueue.take_now()
@@ -1628,26 +1673,72 @@ class RunManager(Tray):
 
     @dataclass(eq=False)
     class Admission:
-        """One visibly applied batch; ``dur()`` orders its consumption behind enlisted checkpoint writes."""
+        """One visibly applied batch; ``dur()`` publishes its intent (consumed, or unconsumed after ``undo()``) behind enlisted checkpoint writes."""
 
         _ctx: "RunManager.RunContext"
         _batch: list[tuple[str, dict[str, Any]]]
         _takes: int
         _confirmed: bool = False
+        _published: bool = False
+        _undone: bool = False
 
         def dur(self) -> None:
-            """Enlist this batch's durable consumption; idempotent until the dispatch settles."""
+            """Publish the current intent durably; idempotent until the dispatch settles."""
             self._ctx._ensure_active()
-            if self._confirmed:
+            manager = self._ctx._manager
+            if self._undone:
+                for admission in reversed(manager._admissions):
+                    if admission._undone and admission._published:
+                        admission._publish(False)
                 return
             self._confirmed = True
+            for admission in manager._admissions:
+                if admission._published:
+                    continue
+                if not admission._confirmed or admission._undone:
+                    break
+                admission._publish(True)
+
+        def undo(self) -> "RunManager.Admission":
+            """Retract this batch and every later one, newest first; ``dur()`` then publishes the retraction. The record re-presents as ``dispatching`` until settle."""
+            self._ctx._ensure_active()
             manager = self._ctx._manager
-            while manager._admissions and manager._admissions[0]._confirmed:
-                admission = manager._admissions.pop(0)
-                if admission._takes:
-                    manager.confirmedTakes.value += admission._takes
-                else:
-                    manager.batchApplied.value = True
+            if not self._takes:
+                record = manager.outbox.value["item"]["record"]
+                if "rollbackTo" in record or "inputOutcomes" in record:
+                    raise RuntimeError(
+                        "undo() of a rewind or input-carrying dispatch is not supported"
+                    )
+            for admission in reversed(manager._admissions):
+                admission._undone = True
+                if admission is self:
+                    break
+            first = next(a for a in manager._admissions if a._undone)
+            retracted = [
+                item
+                for admission in manager._admissions
+                if admission._undone
+                for _, item in admission._batch
+            ] + [item for _, item in manager._batch]
+            trigger = (
+                "steer"
+                if first._takes
+                else manager.outbox.value["item"]["record"]["trigger"]
+            )
+            manager.dispatching.value = _public_record(
+                manager._record_of(trigger, retracted)
+            )
+            return self
+
+        def _publish(self, consumed: bool) -> None:
+            manager = self._ctx._manager
+            self._published = consumed
+            if self._takes:
+                manager.confirmedTakes.value += (
+                    self._takes if consumed else -self._takes
+                )
+            else:
+                manager.batchApplied.value = consumed
 
     @dataclass(frozen=True, eq=False)
     class RunContext:

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/tests/test_deepagents_messages.py

@@ -45,8 +45,10 @@ class Ctx:
     resume: bool = False
     has_rollback: bool = False
     rollback_to: str | None = None
+    input_outcomes: tuple = ()
     applied_count: int = 0
     durable_count: int = 0
+    undo_count: int = 0
 
     def applied(self):
         self.applied_count += 1
@@ -55,6 +57,10 @@ class Ctx:
     def dur(self):
         self.durable_count += 1
 
+    def undo(self):
+        self.undo_count += 1
+        return self
+
 
 def user(id, text):
     return {"id": id, "role": "user", "parts": [{"type": "text", "text": text}]}
@@ -508,3 +514,129 @@ async def test_refetch_before_input_checkpoint_does_not_confirm_new_input():
     await messages.ingest_turn(refetch=True)
     assert ctx.durable_count == 0
     messages.abandon_turn()
+
+
+# ─── Retraction ─────────────────────────────────────────────
+
+
+def _gated_graph(saver, gate: asyncio.Event):
+    from typing import Annotated, TypedDict
+
+    class State(TypedDict):
+        messages: Annotated[list, add_messages]
+
+    async def node(state):
+        await gate.wait()
+        return {"messages": [AIMessage(id="late", content="late")]}
+
+    builder = StateGraph(State)
+    builder.add_node("node", node)
+    builder.add_edge(START, "node")
+    return builder.compile(checkpointer=saver)
+
+
+async def _tip_id(saver):
+    saved = await saver.aget_tuple({"configurable": {"thread_id": THREAD}})
+    return None if saved is None else saved.checkpoint["id"]
+
+
+async def _stop_after_input(saver, messages, ctx):
+    """Start the turn, let the input checkpoint land, then stop the stream."""
+    before = await _tip_id(saver)
+    gate = asyncio.Event()
+    payload, config = await messages.plan_turn(ctx)
+    task = asyncio.create_task(
+        stream(_gated_graph(saver, gate), messages, payload, config)
+    )
+    while await _tip_id(saver) == before:
+        await asyncio.sleep(0)
+    task.cancel()
+    with pytest.raises(asyncio.CancelledError):
+        await task
+    return before
+
+
+async def test_retract_turn_before_output_forks_the_tip_back_and_drops_the_batch():
+    saver, index, graph, messages, state = await seeded()
+    ctx = Ctx("message-send", (user("u3", "three"),))
+    before = await _stop_after_input(saver, messages, ctx)
+    assert ids(state) == ["u1", "a0", "u2", "a1", "u3"]
+    assert messages.retractable
+    await messages.retract_turn()
+    assert (ctx.undo_count, ctx.durable_count) == (1, 1)
+    assert not messages.retractable
+    assert ids(state) == ["u1", "a0", "u2", "a1"]
+    assert await _tip_id(saver) != before
+    await turn(graph, messages, Ctx("message-send", (user("u4", "four"),)))
+    assert ids(state) == ["u1", "a0", "u2", "a1", "u4", "a2"]
+    _, rebooted = await booted(saver, index)
+    assert ids(rebooted) == ["u1", "a0", "u2", "a1", "u4", "a2"]
+
+
+async def test_retract_turn_on_a_fresh_thread_leaves_it_empty():
+    saver, index = InMemorySaver(), MemoryCheckpointIndex()
+    messages, state = await booted(saver, index)
+    ctx = Ctx("message-send", (user("u1", "one"),))
+    await _stop_after_input(saver, messages, ctx)
+    await messages.retract_turn()
+    assert ids(state) == []
+    await turn(_graph(saver), messages, Ctx("message-send", (user("u2", "two"),)))
+    assert ids(state) == ["u2", "a0"]
+    _, rebooted = await booted(saver, index)
+    assert ids(rebooted) == ["u2", "a0"]
+
+
+async def test_retract_turn_without_a_written_checkpoint_only_retracts_the_batch():
+    saver, index, graph, messages, state = await seeded()
+    before = await _tip_id(saver)
+    ctx = Ctx("message-send", (user("u3", "three"),))
+    await messages.plan_turn(ctx)
+    await messages.retract_turn()
+    assert ctx.undo_count == 1
+    assert ids(state) == ["u1", "a0", "u2", "a1"]
+    assert await _tip_id(saver) == before
+
+
+async def test_turns_with_output_resumes_and_forks_are_not_retractable():
+    saver, index, graph, messages, state = await seeded()
+    ctx = Ctx("message-send", (user("u3", "three"),))
+    payload, config = await messages.plan_turn(ctx)
+    await stream(graph, messages, payload, config)
+    assert not messages.retractable
+    with pytest.raises(RuntimeError, match="not retractable"):
+        await messages.retract_turn()
+    await messages.ingest_turn()
+
+    await messages.plan_turn(Ctx("stop-continue", resume=True))
+    assert not messages.retractable
+    messages.abandon_turn()
+
+    await messages.plan_turn(Ctx("message-reload", has_rollback=True, rollback_to="u2"))
+    assert not messages.retractable
+    messages.abandon_turn()
+
+
+async def test_frontier_confirmed_input_is_retracted_with_a_second_dur():
+    from pinned import Frontier, InstanceDurability
+    from pinned.domain import RealDomain
+    from pinned.testing import MemoryStateStore
+
+    from harness_sdk.langgraph import FrontierCheckpointer
+
+    durability = InstanceDurability(
+        MemoryStateStore(), "threads", THREAD, 0, RealDomain()
+    )
+    boundary = Frontier(durability, lambda: None, asyncio.create_task)
+    messages = None
+    wrapper = FrontierCheckpointer(
+        InMemorySaver(),
+        frontier=boundary,
+        on_checkpoint=lambda *args: messages.checkpoint_saved(*args),
+    )
+    messages, state = await booted(wrapper, MemoryCheckpointIndex())
+    ctx = Ctx("message-send", (user("u1", "one"),))
+    await _stop_after_input(wrapper, messages, ctx)
+    assert ctx.durable_count == 1
+    await messages.retract_turn()
+    assert (ctx.undo_count, ctx.durable_count) == (1, 2)
+    assert ids(state) == []

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/tests/test_run_admission.py

@@ -144,3 +144,52 @@ async def test_unconfirmed_rewind_replacement_can_be_enqueued_after_stop():
         assert [m["id"] for m in retry.ctx.messages] == ["m2"]
         retry.applied()
         retry.finish(RunManager.Complete())
+
+
+@pytest.mark.parametrize("takes", [0, 2])
+@pytest.mark.parametrize("checkpoint", [None, {"graph_input_checkpointed": True}])
+async def test_pre_split_records_replay_inputs_and_restore_confirmed_steers(
+    takes, checkpoint
+):
+    store = MemoryStateStore()
+    script = Script()
+    host_type = make_host(script)
+    async with instance(host_type, state_store=store) as host:
+        await host.runs.enqueue(
+            add("m1"), meta={"author": "first"}, applied=lambda: None, auth_result=None
+        )
+        call = await script.next_call()
+        call.ctx.set_state(checkpoint)
+        call.applied()
+        for index in range(takes):
+            await host.runs.steer(
+                add(f"s{index}"),
+                meta={"author": f"author{index}"},
+                applied=lambda: None,
+                auth_result=None,
+            )
+        if takes:
+            call.ctx.steering.take()
+            call.applied()
+        await host.frontier.wait()
+    for _, doc in store.trays.values():
+        if "outbox" in doc:
+            doc["outbox"]["item"].pop("durableAdmission")
+
+    async with instance(host_type, state_store=store) as host:
+        replay = await script.next_call()
+        assert not replay.ctx.resume
+        assert [m["id"] for m in replay.ctx.messages] == ["m1"]
+        assert replay.ctx.meta("m1") == {"author": "first"}
+        replay.applied()
+        if takes:
+            assert [m["id"] for m in replay.ctx.steering.take()] == ["s0", "s1"]
+            assert replay.ctx.meta("s0") == {"author": "author0"}
+            assert replay.ctx.meta("s1") == {"author": "author1"}
+            replay.applied()
+        await host.frontier.wait()
+    async with instance(host_type, state_store=store):
+        confirmed = await script.next_call()
+        assert confirmed.ctx.resume
+        assert confirmed.ctx.steering.take() == ()
+        confirmed.finish(RunManager.Complete())

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/tests/test_run_crash_sweep.py

@@ -48,6 +48,7 @@ class SinglesStore:
             self._inner.trays = dict(seed.trays)
         self.limit = limit
         self.crashed = False
+        self.died = asyncio.Event()
         self.log: list[tuple[Any, ...]] = []
 
     @property
@@ -57,6 +58,7 @@ class SinglesStore:
     def _mutate(self) -> None:
         if self.limit is not None and len(self.log) >= self.limit:
             self.crashed = True
+            self.died.set()
             raise RuntimeError(f"crashed at mutation {self.limit}")
 
     async def set_tray(self, ns, id, tray_ns, tray_id, marked, doc, epoch):
@@ -415,7 +417,14 @@ async def _drive(store, trace: Trace, drive, capabilities) -> None:
         async with instance(
             make_host(script, capabilities=capabilities), state_store=store
         ) as host:
-            await drive(host.runs, script, trace, spawn)
+            # A crashed process stops driving: don't wait out the drive's timeouts.
+            driving = spawn(drive(host.runs, script, trace, spawn))
+            await asyncio.wait(
+                {driving, spawn(store.died.wait())},
+                return_when=asyncio.FIRST_COMPLETED,
+            )
+            if driving.done():
+                driving.result()
     finally:
         for task in tasks:
             task.cancel()

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/tests/test_settle.py

@@ -237,7 +237,7 @@ async def test_task_cancellation_settles_staged_intake():
         # The staged send merges into the cancelled run and settles with its id;
         # the staged stop settles accepted; the unconfirmed batch requeues ahead.
         assert await asyncio.wait_for(send2, 1) == {"runId": run_id}
-        assert await asyncio.wait_for(stop, 1) is None
+        assert await asyncio.wait_for(stop, 1) == []
         await drv.wait_status("stopped")
         assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
         assert runs.idle.is_set()

{harness_sdk_python-0.36.4 → harness_sdk_python-0.36.6}/tests/test_stop_continue.py

@@ -228,7 +228,7 @@ async def test_stop_verdict_awaits_the_settle_and_the_checkpoint_drain():
         await asyncio.sleep(0.02)
         assert not verdict.done()  # the checkpoint drain is still open
         release.set()
-        assert await asyncio.wait_for(verdict, 5) is None
+        assert await asyncio.wait_for(verdict, 5) == []
         assert durable.is_set()  # every enlisted checkpoint durable before the verdict
 
 

harness_sdk_python-0.36.6/tests/test_undo.py

@@ -0,0 +1,301 @@
+"""Contract: retraction of an applied batch. ``handle.undo()`` retracts a
+visibly applied batch and every later one, newest first; ``dur()`` publishes
+the retraction the way it publishes consumption. Settle returns retracted
+items to the front of their lanes, the ``run/stop`` verdict carries them, and
+the record re-presents as ``dispatching`` until the settle."""
+
+import asyncio
+
+import pytest
+from pinned.testing import MemoryStateStore
+from run_helpers import (
+    Script,
+    add,
+    assert_rejected,
+    edit_params,
+    msg,
+    queue_ids,
+    run_host,
+)
+from test_durability import flush, survivors
+from test_run_ownership import ALICE, authorize, side
+
+from harness_sdk import RunManager
+
+
+def ids(record):
+    return [m["id"] for m in record["messages"]]
+
+
+async def steer_and_take(drv, call, *message_ids):
+    for message_id in message_ids:
+        await drv.command("run/steer", add(message_id), terminal=False)
+    await drv.wait(lambda s: queue_ids(s, "steerQueue") == list(message_ids))
+    assert [m["id"] for m in call.ctx.steering.take()] == list(message_ids)
+    return call.ctx.applied()
+
+
+async def test_undo_returns_the_dispatch_batch_to_the_queue_and_rides_the_stop_verdict():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        handle = call.ctx.applied()
+        handle.dur()
+        await drv.wait(lambda s: s["runs"] and s["runs"][0]["dispatching"] is None)
+        seq = drv.post("run/stop", {"runId": await drv.run_id()})
+        await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
+        handle.undo().dur()
+        await drv.wait(lambda s: s["runs"][0]["dispatching"] is not None)
+        assert ids(drv.run["dispatching"]) == ["m1"]
+        assert drv.run["dispatching"]["trigger"] == "message-send"
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        verdict = await drv.res(seq)
+        assert verdict["type"] == "accepted"
+        assert [m["id"] for m in verdict["payload"]] == ["m1"]
+        await drv.wait_status("stopped")
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert drv.run["dispatching"] is None
+        script.no_call()
+
+
+async def test_undo_cascades_over_later_takes_newest_first():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        first = call.ctx.applied()
+        first.dur()
+        second = await steer_and_take(drv, call, "s1")
+        second.dur()
+        third = await steer_and_take(drv, call, "s2")
+        third.dur()
+        await drv.command("run/steer", add("s3"), terminal=False)
+        first.undo().dur()
+        await drv.wait(lambda s: s["runs"][0]["dispatching"] is not None)
+        assert ids(drv.run["dispatching"]) == ["m1", "s1", "s2"]
+        seq = drv.post("run/stop", {"runId": await drv.run_id()})
+        await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        assert [m["id"] for m in (await drv.res(seq))["payload"]] == ["m1", "s1", "s2"]
+        await drv.wait_status("stopped")
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert queue_ids(drv.replica, "steerQueue") == ["s1", "s2", "s3"]
+
+
+async def test_undo_of_a_take_keeps_the_dispatch_and_frees_the_lane_for_a_continue():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.applied()
+        second = await steer_and_take(drv, call, "s1")
+        second.dur()
+        second.undo().dur()
+        await drv.wait(lambda s: s["runs"][0]["dispatching"] is not None)
+        assert drv.run["dispatching"]["trigger"] == "steer"
+        assert ids(drv.run["dispatching"]) == ["s1"]
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        await drv.wait_status("stopped")
+        assert queue_ids(drv.replica, "queue") == []
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        await drv.command("run/steer", add("s2"), terminal=False)
+        resumed = await script.next_call()
+        assert resumed.ctx.trigger == "stop-continue"
+        resumed.applied()
+        assert [m["id"] for m in resumed.ctx.steering.take()] == ["s1", "s2"]
+        resumed.applied()
+        resumed.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_an_undone_handle_settles_unconsumed_without_dur():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        handle = call.ctx.applied()
+        handle.dur()
+        handle.undo()
+        call.finish(RunManager.Error(dispatch_queue=False))
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+
+
+async def test_after_undo_applied_take_complete_and_dispatch_queue_raise():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        handle = call.ctx.applied()
+        handle.dur()
+        await drv.command("run/steer", add("s1"), terminal=False)
+        handle.undo().dur()
+        with pytest.raises(RuntimeError, match="undo"):
+            call.ctx.steering.take()
+        with pytest.raises(RuntimeError, match="undo"):
+            call.ctx.applied()
+        call.finish(RunManager.Stop(dispatch_queue=True))
+        await drv.wait_status("error")
+        assert drv.run["error"]["message"].startswith("dispatch_queue=True")
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        handle = call.ctx.applied()
+        handle.dur()
+        handle.undo().dur()
+        call.finish(RunManager.Complete())
+        await drv.wait_status("error")
+        assert queue_ids(drv.replica, "queue") == ["m1"]
+
+
+async def test_undo_rejects_rewind_and_input_carrying_dispatches():
+    script = Script()
+    script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
+        rerun = await script.next_call()
+        handle = rerun.ctx.applied()
+        with pytest.raises(RuntimeError, match="rewind"):
+            handle.undo()
+        handle.dur()
+        rerun.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.applied()
+        call.finish(
+            RunManager.InputRequired(
+                ({"id": "r1", "type": "tool-approval", "toolCallId": "tc1"},)
+            )
+        )
+        await drv.wait_status("input-required")
+        await drv.command("run/steer", add("s1"), terminal=False)
+        resumed = await script.next_call()
+        assert resumed.ctx.trigger == "message-send"
+        handle = resumed.ctx.applied()
+        with pytest.raises(RuntimeError, match="input"):
+            handle.undo()
+        handle.dur()
+        resumed.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_a_published_full_retraction_redispatches_fresh_after_a_crash():
+    store = MemoryStateStore()
+    script = Script()
+    async with run_host(script, store=store) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        first = call.ctx.applied()
+        first.dur()
+        second = await steer_and_take(drv, call, "s1")
+        second.dur()
+        first.undo().dur()
+        await flush(host)
+        crashed = survivors(store)
+
+    script2 = Script()
+    async with run_host(script2, store=crashed) as (drv2, host2):
+        redelivered = await script2.next_call()
+        assert redelivered.ctx.resume is False
+        assert [m["id"] for m in redelivered.ctx.messages] == ["m1"]
+        await drv2.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
+        redelivered.applied()
+        assert [m["id"] for m in redelivered.ctx.steering.take()] == ["s1"]
+        redelivered.applied()
+        redelivered.finish(RunManager.Complete())
+        await drv2.wait_status("ready")
+
+
+async def test_a_published_partial_retraction_resumes_with_the_take_re_presented():
+    store = MemoryStateStore()
+    script = Script()
+    async with run_host(script, store=store) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.applied()
+        second = await steer_and_take(drv, call, "s1")
+        second.dur()
+        second.undo().dur()
+        await flush(host)
+        crashed = survivors(store)
+
+    script2 = Script()
+    async with run_host(script2, store=crashed) as (drv2, host2):
+        redelivered = await script2.next_call()
+        assert redelivered.ctx.resume is True
+        await drv2.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
+        assert [m["id"] for m in redelivered.ctx.steering.take()] == ["s1"]
+        redelivered.applied()
+        redelivered.finish(RunManager.Complete())
+        await drv2.wait_status("ready")
+
+
+async def test_a_retracted_id_is_queued_again_for_dequeue_and_resend():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        handle = call.ctx.applied()
+        handle.dur()
+        handle.undo().dur()
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        await drv.wait_status("stopped")
+        run_id = drv.run["runId"]
+        assert (await drv.command("run/dequeue", {"runId": run_id, "messageId": "m1"}))[
+            "type"
+        ] == "accepted"
+        assert queue_ids(drv.replica, "queue") == []
+        await drv.command("run/enqueue", add("m1", run_id=run_id), terminal=False)
+        resent = await script.next_call()
+        assert resent.ctx.trigger == "stop-continue"
+        assert [m["id"] for m in resent.ctx.messages] == ["m1"]
+        resent.applied()
+        resent.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_the_run_principal_may_dequeue_another_authors_retracted_item():
+    script = Script()
+    async with run_host(script, authorize=authorize, headers=ALICE) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.applied()
+        run_id = await drv.run_id()
+        rsp = await side(
+            drv._app,
+            drv._client,
+            "run/steer",
+            {"runId": run_id, "message": msg("s1")},
+            user="bob",
+        )
+        assert rsp["type"] == "result", rsp
+        await drv.wait(lambda s: queue_ids(s, "steerQueue") == ["s1"])
+        assert [m["id"] for m in call.ctx.steering.take()] == ["s1"]
+        take = call.ctx.applied()
+        take.dur()
+        take.undo().dur()
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        await drv.wait_status("stopped")
+        assert_rejected(
+            await side(
+                drv._app,
+                drv._client,
+                "run/dequeue",
+                {"runId": run_id, "messageId": "s1"},
+                user="mallory",
+            ),
+            "not-owner",
+        )
+        assert (await drv.command("run/dequeue", {"runId": run_id, "messageId": "s1"}))[
+            "type"
+        ] == "accepted"
+        assert queue_ids(drv.replica, "steerQueue") == []