harness-sdk-python 0.12.0__tar.gz → 0.13.1__tar.gz

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/PKG-INFO

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

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

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/src/harness_sdk/run_manager.py

@@ -5,19 +5,28 @@ 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 in order, then takes exactly one action based on
-status and net effect (interrupt, dispatch, or continue). A dispatchable send
-appends straight into ``dispatching`` — it never transits a queue lane — and
-everything staged there by the end of the drain dispatches as one run. Every
+status and net effect (rewind > send-dispatch > continue > input-resume). A
+dispatchable send appends straight into ``dispatching`` — it never transits a
+queue lane — and everything staged there by the end of the drain dispatches
+as one run; in error/stop the dispatch is the continuation
+(``error-continue`` / ``stop-continue``) carrying the send's messages. Every
 initiator acks and settles accepted with its state-visible application —
 sends with their insert (lane or ``dispatching``), edit/reload/continue at
 their dispatch; ``run/stop`` awaits a future the drain resolves once the
 in-flight run has ended.
 
-``entry["dispatching"]`` is the dispatch record (or None): the payload the
-run callback receives. ``ctx.ack()`` clears it; ``steering.take()`` may
-refill it — at most one unacked batch ever exists. Settle consumes the
-delivered batch, acked or not; steer entries still undelivered in the lane
-stay queued for the next run.
+``entry["dispatching"]`` is the dispatch record (absent between an ack and
+the next dispatch or take): the payload the run callback receives.
+``ctx.ack()`` clears it; ``steering.take()`` may refill it — at most one
+unacked batch ever exists. Settle consumes the delivered batch, acked or not;
+steer entries still undelivered in the lane stay queued for the next run.
+
+A mid-run stop or rewind opens a stopping window on the entry:
+``stopping: {reason}`` plus, for rewinds, the staged dispatch as
+``nextDispatch`` — written in the same envelope as the opener's pending
+answer. On run end one envelope promotes ``nextDispatch`` into
+``dispatching`` and clears the window; a later stop/rewind supersedes the
+staged one, which settles rejected (``superseded``).
 """
 
 import asyncio
@@ -140,6 +149,7 @@ class _Rewind:
     future: "asyncio.Future[Any]"
     run_id: str
     root_meta: Any = None
+    acked: bool = False
 
 
 @dataclass
@@ -201,7 +211,7 @@ class RunManager:
         self._outcome: Any = None
         self._staged_stops: list["asyncio.Future[Any]"] = []
         self._stop_reason: str | None = None
-        self._staged_rewinds: list[_Rewind] = []
+        self._staged_rewind: _Rewind | None = None
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
@@ -248,26 +258,33 @@ class RunManager:
         for lane in ("queue", "steerQueue"):
             if not isinstance(entry.get(lane), list):
                 raise ValueError(f"the restored {lane} must be a list")
-        for key in ("dispatching", "error"):
-            if entry.get(key, _ABSENT) is not None:
-                raise ValueError(f"the restored entry must carry {key}: None")
+        for key in ("dispatching", "error", "stopping", "nextDispatch"):
+            if key in entry:
+                raise ValueError(f"the restored entry must not carry {key}")
         requests = entry.get("inputRequests")
         if not isinstance(requests, list) or not requests:
             raise ValueError("the restored inputRequests must be a non-empty list")
+        answers: dict[str, Any] = {}
         for request in requests:
             if not isinstance(request, dict):
                 raise ValueError("restored input requests must be objects")
-            if request.get("response") is not None:
-                raise ValueError(
-                    "restored input requests must carry response: None"
+            if "response" in request:
+                if not isinstance(request["response"], dict):
+                    raise ValueError("a restored response must be an object")
+                answers[request.get("id")] = (
+                    request["response"],
+                    request.get("meta"),
                 )
         outcome = RunManager.InputRequired(
             tuple(
-                {k: v for k, v in request.items() if k != "response"}
+                {k: v for k, v in request.items() if k not in ("response", "meta")}
                 for request in requests
             )
         )
+        if len(answers) == len(requests):
+            raise ValueError("a fully answered pending set cannot restore")
         self._input_requests = [dict(r) for r in outcome.requests]
+        self._input_answers = answers
         self._state["status"] = "input-required"
 
     # ─── State access ───────────────────────────────────────
@@ -287,8 +304,6 @@ class RunManager:
                     "status": "ready",
                     "queue": [],
                     "steerQueue": [],
-                    "dispatching": None,
-                    "error": None,
                 }
             )
         return self._state["runs"][0]
@@ -345,12 +360,14 @@ class RunManager:
             self._staged_stops.clear()
             if isinstance(outcome, RunManager.Complete):
                 self._dispatched_ids = ()
-            if self._staged_rewinds:
-                rewind = self._staged_rewinds.pop(0)
+            if self._staged_rewind is not None:
+                rewind, self._staged_rewind = self._staged_rewind, None
                 self._clear_input()
                 if self._dispatching:
                     self._unstage_dispatching()
                 entry = self._ensure_entry()
+                entry.pop("stopping", None)
+                entry.pop("nextDispatch", None)
                 if entry["runId"] is None:
                     entry["runId"] = rewind.run_id
                 self._dispatch(
@@ -359,14 +376,17 @@ class RunManager:
                     rollback_to=rewind.rollback_to,
                     root_meta=rewind.root_meta,
                 )
-                rewind.ack()
+                if not rewind.acked:
+                    rewind.ack()
                 if not rewind.future.done():
                     rewind.future.set_result(None)
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
                 self._idle_action(fx)
-        if self._task is not None and (self._staged_stops or self._staged_rewinds):
+        if self._task is not None and (
+            self._staged_stops or self._staged_rewind is not None
+        ):
             assert self._ctx is not None
             self._ctx.stop_requested.set()
         for future, ack, result in fx.staged_sends:
@@ -382,6 +402,11 @@ class RunManager:
     def _apply(self, entry: Any, fx: _Effects) -> None:
         if isinstance(entry, _Stop):
             self._staged_stops.append(entry.future)
+            if self._task is not None:
+                if self._staged_rewind is not None:
+                    self._supersede()
+                    self._entry().pop("nextDispatch", None)
+                self._entry()["stopping"] = {"reason": "stop"}
             return
         if isinstance(entry, _Continue):
             if not fx.continue_requested:
@@ -413,10 +438,10 @@ class RunManager:
             if self._dispatching:
                 self._dispatch_staged()
         elif status in ("error", "stopped"):
-            if fx.continue_requested or fx.steer_added:
-                self._dispatch(self._continue_type(), [], root_meta=fx.continue_meta)
-            elif self._dispatching:
+            if self._dispatching:
                 self._dispatch_staged()
+            elif fx.continue_requested or fx.steer_added:
+                self._dispatch(self._continue_type(), [], root_meta=fx.continue_meta)
         elif status == "input-required":
             if self._dispatching:
                 self._dispatch_staged(input_outcomes=self._take_input_outcomes())
@@ -438,9 +463,7 @@ class RunManager:
             self._input_requests = [dict(r) for r in outcome.requests]
             self._input_answers = {}
             entry = self._entry()
-            entry["inputRequests"] = [
-                {**r, "response": None} for r in outcome.requests
-            ]
+            entry["inputRequests"] = [dict(r) for r in outcome.requests]
             self._set_status("input-required")
             return
         status = "error" if isinstance(outcome, RunManager.Error) else "stopped"
@@ -465,6 +488,27 @@ class RunManager:
         self._clear_input()
         return outcomes
 
+    def _record_of(
+        self,
+        trigger: str,
+        items: list[dict[str, Any]],
+        *,
+        rollback_to: Any = _ABSENT,
+        root_meta: Any = None,
+        input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = (),
+    ) -> dict[str, Any]:
+        record: dict[str, Any] = {"trigger": trigger, "messages": items}
+        if rollback_to is not _ABSENT:
+            record["rollbackTo"] = rollback_to
+        if root_meta is not None:
+            record["rootMeta"] = root_meta
+        if input_outcomes:
+            record["inputOutcomes"] = [
+                {"request": request, "response": response, "meta": meta}
+                for request, response, meta in input_outcomes
+            ]
+        return record
+
     def _dispatch(
         self,
         trigger: str,
@@ -483,19 +527,18 @@ class RunManager:
         messages = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
-        record: dict[str, Any] = {"trigger": trigger, "messages": items}
-        if rollback_to is not _ABSENT:
-            record["rollbackTo"] = rollback_to
-        if input_outcomes:
-            record["inputOutcomes"] = [
-                {"request": request, "response": response, "meta": meta}
-                for request, response, meta in input_outcomes
-            ]
+        record = self._record_of(
+            trigger,
+            items,
+            rollback_to=rollback_to,
+            root_meta=root_meta,
+            input_outcomes=input_outcomes,
+        )
         self._dispatch_record = dict(record)
         self._stop_reason = None
         entry = self._ensure_entry()
         entry["dispatching"] = record
-        entry["error"] = None
+        entry.pop("error", None)
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
         self._set_status("running")
@@ -555,30 +598,31 @@ class RunManager:
         self._dispatch_record = None
         self._dispatching = []
         entry = self._ensure_entry()
-        record = plain(entry["dispatching"])
+        record = plain(entry.get("dispatching"))
         if record is not None and record["trigger"] != "steer" and record["messages"]:
             self._dispatched_ids = ()
-        entry["dispatching"] = None
+        entry.pop("dispatching", None)
+        entry.pop("stopping", None)
 
     def _ack(self) -> None:
         entry = self._entry()
-        record = plain(entry["dispatching"])
+        record = plain(entry.get("dispatching"))
         if record is None:
             raise RuntimeError("ack() with no unacked batch")
         self._dispatching = []
-        entry["dispatching"] = None
+        entry.pop("dispatching", None)
 
     def _unstage_dispatching(self) -> None:
         taken, self._dispatching = self._dispatching, []
         entry = self._ensure_entry()
-        entry["dispatching"] = None
+        entry.pop("dispatching", None)
         for lane in ("steerQueue", "queue"):
             front = [item for taken_lane, item in taken if taken_lane == lane]
             if front:
                 entry[lane] = front + self._lane_items(lane)
 
     def _dispatchable(self, lane: str) -> bool:
-        if self._task is not None or self._staged_rewinds:
+        if self._task is not None or self._staged_rewind is not None:
             return False
         if self._dispatching:
             return True
@@ -595,6 +639,10 @@ class RunManager:
             )
         return False
 
+    def _send_trigger(self) -> str:
+        status = self._status()
+        return self._continue_type() if status in ("error", "stopped") else "message-send"
+
     def _stage_dispatch(self, e: _Send) -> None:
         assert e.message is not None
         steer = self._lane_items("steerQueue") if e.lane == "steerQueue" else []
@@ -605,7 +653,7 @@ class RunManager:
             self._dispatching.extend(("steerQueue", item) for item in steer)
         self._dispatching.append((e.lane, self._stamped(e.message, e.meta)))
         self._ensure_entry()["dispatching"] = {
-            "trigger": "message-send",
+            "trigger": self._send_trigger(),
             "messages": [item for _, item in self._dispatching],
         }
 
@@ -613,7 +661,7 @@ class RunManager:
         self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
     ) -> None:
         self._dispatch(
-            "message-send",
+            self._send_trigger(),
             [item for _, item in self._dispatching],
             input_outcomes=input_outcomes,
         )
@@ -635,6 +683,30 @@ class RunManager:
             return True
         return False
 
+    def _supersede(self) -> None:
+        rewind, self._staged_rewind = self._staged_rewind, None
+        assert rewind is not None
+        if not rewind.future.done():
+            rewind.future.set_exception(
+                _reject("superseded", "a later stop/rewind replaced this command")
+            )
+
+    def _stage_rewind(self, rewind: _Rewind) -> None:
+        if self._staged_rewind is not None:
+            self._supersede()
+        self._staged_rewind = rewind
+        if self._task is not None:
+            entry = self._entry()
+            entry["stopping"] = {"reason": rewind.type}
+            entry["nextDispatch"] = self._record_of(
+                rewind.type,
+                list(rewind.messages),
+                rollback_to=rewind.rollback_to,
+                root_meta=rewind.root_meta,
+            )
+            rewind.ack()
+            rewind.acked = True
+
     def _freeze(self, message: str, payload: Any = None) -> None:
         self._set_status("error")
         entry = self._entry()
@@ -915,7 +987,7 @@ class RunManager:
         if e.source_meta is None:
             raise _reject("unknown-id", f"message {e.message_id} is unknown")
         self._check_anchor(e)
-        self._staged_rewinds.append(
+        self._stage_rewind(
             _Rewind(
                 "message-edit",
                 [self._stamped(e.message, e.meta)],
@@ -956,7 +1028,10 @@ class RunManager:
                 f"input request {e.request_id} is already answered",
             )
         self._input_answers[e.request_id] = (e.response, e.meta)
-        self._entry()["inputRequests"][index]["response"] = e.response
+        replicated = self._entry()["inputRequests"][index]
+        replicated["response"] = e.response
+        if e.meta is not None:
+            replicated["meta"] = e.meta
         return None
 
     def _apply_edit(self, e: _Edit) -> Any:
@@ -967,7 +1042,7 @@ class RunManager:
             raise _reject(
                 "duplicate-id", f"message id {e.message['id']} is already used"
             )
-        self._staged_rewinds.append(
+        self._stage_rewind(
             _Rewind(
                 "message-edit",
                 [self._stamped(e.message, e.meta)],
@@ -980,7 +1055,7 @@ class RunManager:
         return _PARKED
 
     def _apply_reload(self, e: _Reload) -> Any:
-        self._staged_rewinds.append(
+        self._stage_rewind(
             _Rewind(
                 "message-reload",
                 [],
@@ -1280,7 +1355,7 @@ class RunManager:
             self._ctx._ensure_active()
             manager = self._ctx._manager
             entry = manager._entry()
-            if plain(entry["dispatching"]) is not None:
+            if plain(entry.get("dispatching")) is not None:
                 raise RuntimeError("take before the current batch is acked")
             items = manager._lane_items("steerQueue")
             if not items:

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/tests/test_batches.py

@@ -5,7 +5,7 @@ drain takes exactly one action; late-settling commands ride a later envelope.
 import asyncio
 from typing import Any
 
-from run_helpers import Script, add, queue_ids, run_host
+from run_helpers import Script, add, edit_params, msg, queue_ids, run_host
 
 from harness_sdk import RunManager
 
@@ -114,3 +114,71 @@ async def test_handler_tail_staging_decides_in_its_own_envelope():
         assert dispatch_env.get("ack", 0) >= seq
         assert (await drv.res(seq))["type"] == "accepted"
         call.ack()
+
+
+async def test_rewind_outranks_send_and_continue_in_one_batch():
+    script = Script()
+    async with run_host(
+        script, capabilities=("rewind", "incomplete-continuation")
+    ) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        script.thread["m1"] = {
+            "parentId": None,
+            "role": "user",
+            "isLeaf": True,
+            "onActiveBranch": True,
+        }
+        script.thread["a1"] = {
+            "parentId": "m1",
+            "role": "assistant",
+            "isLeaf": True,
+            "onActiveBranch": True,
+        }
+        call.ack()
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        first = drv.batch(
+            [
+                ("run/enqueue", add("q1", anchor="a1")),
+                ("run/edit", edit_params("m1", msg("m2"), anchor=None)),
+                ("run/continue", None),
+            ]
+        )
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-edit"
+        assert [m["id"] for m in rerun.ctx.messages] == ["m2"]
+        script.no_call()
+        assert (await drv.res(first))["type"] == "accepted"
+        assert (await drv.res(first + 1))["type"] == "accepted"
+        assert (await drv.res(first + 2))["type"] == "accepted"
+        assert queue_ids(drv.replica, "queue") == ["q1"]
+        rerun.ack()
+        rerun.finish(RunManager.Complete())
+
+
+async def test_send_outranks_the_completing_input_answer():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        request = {"type": "tool-call", "id": "r1", "toolCallId": "tc1"}
+        call.finish(RunManager.InputRequired((request,)))
+        await drv.wait_status("input-required")
+        first = drv.batch(
+            [
+                ("run/input", {"requestId": "r1", "response": {"output": "ok"}}),
+                ("run/steer", add("s1")),
+            ]
+        )
+        run = await script.next_call()
+        assert run.ctx.trigger == "message-send"
+        assert [m["id"] for m in run.ctx.messages] == ["s1"]
+        assert run.ctx.input_outcomes == ((request, {"output": "ok"}, None),)
+        script.no_call()
+        assert (await drv.res(first))["type"] == "accepted"
+        assert (await drv.res(first + 1))["type"] == "accepted"
+        run.ack()
+        run.finish(RunManager.Complete())
+        await drv.wait_status("ready")

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/tests/test_dispatching.py

@@ -17,7 +17,7 @@ from statewire_helpers import apply_ops
 
 def dispatching_ids(replica):
     runs = replica["runs"]
-    record = runs[0]["dispatching"] if runs else None
+    record = runs[0].get("dispatching") if runs else None
     return [item["id"] for item in record["messages"]] if record else []
 
 

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/tests/test_enqueue.py

@@ -80,7 +80,7 @@ async def test_steer_lane_drains_first_and_whole():
         await drv.wait_status("ready")
 
 
-async def test_error_add_with_empty_lanes_dispatches_immediately():
+async def test_error_add_with_empty_lanes_dispatches_error_continue_with_messages():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
@@ -90,9 +90,10 @@ async def test_error_add_with_empty_lanes_dispatches_immediately():
         await drv.wait_status("error")
         drv.post("run/enqueue", add("m2"))
         call = await script.next_call()
-        assert call.ctx.trigger == "message-send"
+        assert call.ctx.trigger == "error-continue"
         assert [m["id"] for m in call.ctx.messages] == ["m2"]
-        await drv.wait(lambda s: run_of(s).get("error") is None)
+        await drv.wait(lambda s: "error" not in run_of(s))
+        assert drv.run["dispatching"]["trigger"] == "error-continue"
 
 
 async def test_error_add_with_queued_items_stays_queued():

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/tests/test_input_required.py

@@ -37,15 +37,12 @@ async def park(drv, script, requests, *, anchor=None):
     await drv.wait_status("input-required")
 
 
-async def test_park_replicates_pending_requests_with_null_responses():
+async def test_park_replicates_pending_requests_without_response_keys():
     script = Script()
     async with run_host(script) as (drv, host):
         await park(drv, script, [tool_call("r1"), approval("r2", "tc2")])
         assert "dispatch" not in drv.replica
-        assert drv.run["inputRequests"] == [
-            {**tool_call("r1"), "response": None},
-            {**approval("r2", "tc2"), "response": None},
-        ]
+        assert drv.run["inputRequests"] == [tool_call("r1"), approval("r2", "tc2")]
 
 
 async def test_partial_answer_stays_parked_and_echoes_response():
@@ -57,11 +54,12 @@ async def test_partial_answer_stays_parked_and_echoes_response():
         )
         assert res["type"] == "accepted"
         await drv.wait(
-            lambda s: run_of(s)["inputRequests"][0]["response"] is not None
+            lambda s: "response" in run_of(s)["inputRequests"][0]
         )
         assert drv.replica["status"] == "input-required"
         assert drv.run["inputRequests"][0]["response"] == {"output": "ok"}
-        assert drv.run["inputRequests"][1]["response"] is None
+        assert "meta" not in drv.run["inputRequests"][0]
+        assert "response" not in drv.run["inputRequests"][1]
         script.no_call()
 
 
@@ -238,7 +236,7 @@ async def test_custom_request_type_passes_through():
     async with run_host(script) as (drv, host):
         request = {"type": "free-form", "id": "r1", "prompt": "where to?"}
         await park(drv, script, [request])
-        assert drv.run["inputRequests"] == [{**request, "response": None}]
+        assert drv.run["inputRequests"] == [request]
         response = {"anything": [1, 2], "goes": True}
         assert (
             await drv.command("run/input", {"requestId": "r1", "response": response})
@@ -256,7 +254,7 @@ async def test_stop_while_parked_rejects_and_keeps_the_pending_set():
         await park(drv, script, [tool_call("r1")])
         assert_rejected(await drv.command("run/stop"), "wrong-state")
         assert drv.replica["status"] == "input-required"
-        assert drv.run["inputRequests"] == [{**tool_call("r1"), "response": None}]
+        assert drv.run["inputRequests"] == [tool_call("r1")]
         await drv.command(
             "run/input", {"requestId": "r1", "response": {"output": "x"}}
         )
@@ -412,7 +410,7 @@ async def test_enqueue_while_parked_parks_and_keeps_the_pending_set():
         await drv.command("run/enqueue", add("m2"), terminal=False)
         assert queue_ids(drv.replica, "queue") == ["m2"]
         assert drv.replica["status"] == "input-required"
-        assert drv.run["inputRequests"] == [{**tool_call("r1"), "response": None}]
+        assert drv.run["inputRequests"] == [tool_call("r1")]
         script.no_call()
 
 
@@ -447,3 +445,21 @@ async def test_steer_add_with_partial_answers_hands_over_the_answered_subset():
         run.ack()
         run.finish(RunManager.Complete())
         await drv.wait_status("ready")
+
+
+async def test_answer_meta_replicates_only_when_carried():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await park(drv, script, [tool_call("r1"), approval("r2")])
+        await drv.command(
+            "run/input",
+            {"requestId": "r1", "response": {"output": "ok"}, "meta": {"src": "c1"}},
+        )
+        await drv.wait(lambda s: "response" in run_of(s)["inputRequests"][0])
+        assert drv.run["inputRequests"][0] == {
+            **tool_call("r1"),
+            "response": {"output": "ok"},
+            "meta": {"src": "c1"},
+        }
+        assert drv.run["inputRequests"][1] == approval("r2")
+        script.no_call()

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/tests/test_outcomes.py

@@ -61,7 +61,7 @@ async def test_state_error_cleared_by_next_user_initiated_entry():
         drv.post("run/enqueue", add("m2"))
         await script.next_call()
         await drv.wait(
-            lambda s: s["status"] == "running" and run_of(s)["error"] is None
+            lambda s: s["status"] == "running" and "error" not in run_of(s)
         )
 
 
@@ -83,7 +83,7 @@ async def test_error_outcome_freezes_without_state_error():
         await drv.command("run/enqueue", add("m2"), terminal=False)
         call.finish(RunManager.Error(dispatch_queue=False))
         await drv.wait_status("error")
-        assert drv.run["error"] is None
+        assert "error" not in drv.run
         assert queue_ids(drv.replica, "queue") == ["m2"]
         script.no_call()
 

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/tests/test_restore.py

@@ -7,7 +7,7 @@ raises."""
 import asyncio
 
 import pytest
-from run_helpers import Script, add, msg, run_host
+from run_helpers import Script, add, assert_rejected, msg, run_host
 
 from harness_sdk import RunManager
 
@@ -22,9 +22,7 @@ def parked_entry(**overrides) -> dict:
         "status": "input-required",
         "queue": [],
         "steerQueue": [],
-        "dispatching": None,
-        "error": None,
-        "inputRequests": [{**tool_call("r1"), "response": None}],
+        "inputRequests": [tool_call("r1")],
         **overrides,
     }
 
@@ -112,9 +110,23 @@ async def test_malformed_restore_states_raise():
         ({"runs": [parked_entry(queue=None)]}, "queue"),
         ({"runs": [parked_entry(steerQueue=None)]}, "steerQueue"),
         ({"runs": [parked_entry(dispatching={"trigger": "steer"})]}, "dispatching"),
+        ({"runs": [parked_entry(dispatching=None)]}, "dispatching"),
         ({"runs": [parked_entry(error={"message": "x"})]}, "error"),
+        ({"runs": [parked_entry(error=None)]}, "error"),
+        ({"runs": [parked_entry(stopping={"reason": "stop"})]}, "stopping"),
+        ({"runs": [parked_entry(nextDispatch={"trigger": "message-edit"})]}, "nextDispatch"),
         ({"runs": [parked_entry(inputRequests=[])]}, "non-empty list"),
         ({"runs": [parked_entry(inputRequests=["nope"])]}, "objects"),
+        (
+            {
+                "runs": [
+                    parked_entry(
+                        inputRequests=[{**tool_call("r1"), "response": "nope"}]
+                    )
+                ]
+            },
+            "response",
+        ),
         (
             {
                 "runs": [
@@ -125,7 +137,7 @@ async def test_malformed_restore_states_raise():
                     )
                 ]
             },
-            "response",
+            "fully answered",
         ),
         (
             {"runs": [parked_entry(inputRequests=[{"type": "tool-call"}])]},
@@ -134,3 +146,32 @@ async def test_malformed_restore_states_raise():
     ]:
         with pytest.raises(ValueError, match=match):
             construct(state)
+
+
+async def test_answered_entries_restore_and_the_last_answer_resumes():
+    script = Script()
+    entry = parked_entry(
+        inputRequests=[
+            {**tool_call("r1"), "response": {"output": "a"}, "meta": {"src": "c1"}},
+            tool_call("r2", "tc2"),
+        ]
+    )
+    async with run_host(script, initial_runs={"runs": [entry]}) as (drv, host):
+        assert_rejected(
+            await drv.command(
+                "run/input", {"requestId": "r1", "response": {"output": "again"}}
+            ),
+            "already-answered",
+        )
+        await drv.command(
+            "run/input", {"requestId": "r2", "response": {"output": "b"}}
+        )
+        resumed = await script.next_call()
+        assert resumed.ctx.trigger == "input-resume"
+        assert resumed.ctx.input_outcomes == (
+            (tool_call("r1"), {"output": "a"}, {"src": "c1"}),
+            (tool_call("r2", "tc2"), {"output": "b"}, None),
+        )
+        resumed.ack()
+        resumed.finish(RunManager.Complete())
+        await drv.wait_status("ready")

{harness_sdk_python-0.12.0 → harness_sdk_python-0.13.1}/tests/test_stop_continue.py

@@ -1,7 +1,7 @@
 import asyncio
 
 import pytest
-from run_helpers import Script, add, assert_rejected, run_host, run_of
+from run_helpers import Script, add, assert_rejected, queue_ids, run_host, run_of
 
 from harness_sdk import RunManager
 
@@ -20,7 +20,7 @@ async def test_stop_is_not_optimistic():
         settled = await drv.res(pending["seq"])
         assert settled["type"] == "accepted"
         await drv.wait_status("stopped")
-        assert drv.run["error"] is None
+        assert "error" not in drv.run
 
 
 async def test_stop_outcome_can_keep_the_queue_draining():
@@ -279,3 +279,60 @@ async def test_continue_settles_before_the_continued_run_ends():
         continued.fail(RuntimeError("boom again"))
         await drv.wait_status("error")
         assert drv.run["error"] == {"message": "boom again"}
+
+
+@pytest.mark.parametrize(
+    "end,continue_type",
+    [("error", "error-continue"), ("stopped", "stop-continue")],
+)
+async def test_enqueue_send_in_error_stop_dispatches_continue_with_messages(
+    end, continue_type
+):
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        if end == "error":
+            call.fail(RuntimeError("boom"))
+        else:
+            await drv.stop(terminal=False)
+            call.finish(RunManager.Stop(dispatch_queue=False))
+        await drv.wait_status(end)
+        seq = drv.post("run/enqueue", add("m2"))
+        continued = await script.next_call()
+        assert continued.ctx.trigger == continue_type
+        assert [m["id"] for m in continued.ctx.messages] == ["m2"]
+        await drv.wait(
+            lambda s: (run_of(s).get("dispatching") or {}).get("trigger")
+            == continue_type
+        )
+        continued.ack()
+        assert (await drv.res(seq))["type"] == "accepted"
+        continued.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_same_tick_send_and_continue_dispatch_one_run_with_messages():
+    script = Script()
+    async with run_host(script, capabilities=("incomplete-continuation",)) as (
+        drv,
+        host,
+    ):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.ack()
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        first = drv.batch(
+            [("run/continue", None), ("run/enqueue", add("m2"))]
+        )
+        continued = await script.next_call()
+        assert continued.ctx.trigger == "error-continue"
+        assert [m["id"] for m in continued.ctx.messages] == ["m2"]
+        script.no_call()
+        assert (await drv.res(first))["type"] == "accepted"
+        assert (await drv.res(first + 1))["type"] == "accepted"
+        continued.ack()
+        continued.finish(RunManager.Complete())
+        await drv.wait_status("ready")

harness_sdk_python-0.13.1/tests/test_stopping_window.py

@@ -0,0 +1,263 @@
+"""Contract: the stopping window. Three openers — run/stop, mid-run
+edit/reload, and the enqueue/steer edit-of-dispatched form — write
+``stopping: {reason}`` (plus the staged rewind as ``nextDispatch``) in the
+same envelope as the opener's pending answer, ``status`` staying "running".
+On run end one envelope promotes ``nextDispatch`` into ``dispatching`` and
+clears the window; a later stop/rewind supersedes the staged command, which
+settles rejected (``superseded``)."""
+
+import asyncio
+import copy
+
+import pytest
+from run_helpers import (
+    Script,
+    add,
+    assert_rejected,
+    edit_params,
+    msg,
+    queue_ids,
+    reload_params,
+    run_host,
+    target,
+)
+
+from harness_sdk import RunManager
+from statewire_helpers import apply_ops
+
+
+def states(drv):
+    state: dict = {}
+    for env in copy.deepcopy(drv.envelopes):
+        apply_ops(state, env)
+        yield env, copy.deepcopy(state)
+
+
+def window_of(state):
+    runs = state.get("runs") or [{}]
+    return runs[0].get("stopping"), runs[0].get("nextDispatch")
+
+
+async def start_run(drv, script, *, parent="p0"):
+    drv.post("run/enqueue", add("m1"))
+    call = await script.next_call()
+    script.thread["m1"] = {
+        "parentId": parent,
+        "role": "user",
+        "isLeaf": True,
+        "onActiveBranch": True,
+    }
+    script.thread["a1"] = {
+        "parentId": "m1",
+        "role": "assistant",
+        "isLeaf": True,
+        "onActiveBranch": True,
+    }
+    call.ack()
+    return call
+
+
+async def test_stop_opens_the_window_with_the_pending_answer():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        call = await start_run(drv, script)
+        pending = await drv.stop(terminal=False)
+        assert pending["type"] == "pending"
+        assert drv.replica["status"] == "running"
+        assert drv.run["stopping"] == {"reason": "stop"}
+        assert "nextDispatch" not in drv.run
+        opened = next(
+            state
+            for env, state in states(drv)
+            if any(r["seq"] == pending["seq"] for r in env.get("res", []))
+        )
+        assert window_of(opened) == ({"reason": "stop"}, None)
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+        await drv.wait_status("stopped")
+        assert "stopping" not in drv.run
+
+
+async def test_mid_run_edit_stages_the_window_and_promotes_in_one_envelope():
+    script = Script()
+    async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
+        drv,
+        host,
+    ):
+        call = await start_run(drv, script)
+        seq = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
+        await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
+        await drv.wait(lambda s: "stopping" in (s["runs"] or [{}])[0])
+        assert drv.replica["status"] == "running"
+        assert drv.run["stopping"] == {"reason": "message-edit"}
+        staged = drv.run["nextDispatch"]
+        assert staged == {
+            "trigger": "message-edit",
+            "messages": [msg("m2")],
+            "rollbackTo": "p0",
+        }
+        opened = next(
+            state
+            for env, state in states(drv)
+            if any(r["seq"] == seq for r in env.get("res", []))
+        )
+        assert window_of(opened) == ({"reason": "message-edit"}, staged)
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.rollback_to == "p0"
+        await drv.wait(lambda s: (s["runs"][0].get("dispatching") or {}).get("trigger") == "message-edit")
+        trail = [
+            (window_of(state), (state["runs"] or [{}])[0].get("dispatching"))
+            for _, state in states(drv)
+        ]
+        promoted = next(
+            i
+            for i, (_, record) in enumerate(trail)
+            if record is not None and record["trigger"] == "message-edit"
+        )
+        assert trail[promoted][0] == (None, None)
+        assert trail[promoted][1] == staged
+        assert trail[promoted - 1][0] == ({"reason": "message-edit"}, staged)
+        assert (await drv.res(seq))["type"] == "accepted"
+        rerun.ack()
+        rerun.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_mid_run_reload_stages_reason_and_empty_messages():
+    script = Script()
+    async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
+        drv,
+        host,
+    ):
+        call = await start_run(drv, script)
+        seq = drv.post("run/reload", reload_params("a1", anchor="m1", meta={"retry": 1}))
+        await drv.wait(lambda s: "stopping" in (s["runs"] or [{}])[0])
+        assert drv.run["stopping"] == {"reason": "message-reload"}
+        assert drv.run["nextDispatch"] == {
+            "trigger": "message-reload",
+            "messages": [],
+            "rollbackTo": "m1",
+            "rootMeta": {"retry": 1},
+        }
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-reload"
+        assert rerun.ctx.meta() == {"retry": 1}
+        await drv.wait(lambda s: "stopping" not in (s["runs"] or [{}])[0])
+        assert drv.run["dispatching"]["rootMeta"] == {"retry": 1}
+        assert (await drv.res(seq))["type"] == "accepted"
+        rerun.ack()
+        rerun.finish(RunManager.Complete())
+
+
+@pytest.mark.parametrize("command", ["run/enqueue", "run/steer"])
+async def test_edit_of_dispatched_message_opens_the_window(command):
+    script = Script()
+    async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
+        drv,
+        host,
+    ):
+        call = await start_run(drv, script)
+        seq = drv.post(command, target(message=msg("m1", "edited")))
+        await drv.wait(lambda s: "stopping" in (s["runs"] or [{}])[0])
+        assert drv.replica["status"] == "running"
+        assert drv.run["stopping"] == {"reason": "message-edit"}
+        assert drv.run["nextDispatch"] == {
+            "trigger": "message-edit",
+            "messages": [msg("m1", "edited")],
+            "rollbackTo": "p0",
+        }
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-edit"
+        assert rerun.ctx.rollback_to == "p0"
+        assert (await drv.res(seq))["type"] == "accepted"
+        rerun.ack()
+        rerun.finish(RunManager.Complete())
+
+
+async def test_later_rewind_supersedes_the_staged_one():
+    script = Script()
+    async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
+        drv,
+        host,
+    ):
+        call = await start_run(drv, script)
+        first = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
+        await drv.wait(lambda s: "nextDispatch" in (s["runs"] or [{}])[0])
+        second = drv.post("run/reload", reload_params("a1", anchor="m1"))
+        assert_rejected(await drv.res(first), "superseded")
+        await drv.wait(
+            lambda s: s["runs"][0]["nextDispatch"]["trigger"] == "message-reload"
+        )
+        assert drv.run["stopping"] == {"reason": "message-reload"}
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-reload"
+        assert (await drv.res(second))["type"] == "accepted"
+        rerun.ack()
+        rerun.finish(RunManager.Complete())
+
+
+async def test_stop_supersedes_a_staged_rewind():
+    script = Script()
+    async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
+        drv,
+        host,
+    ):
+        call = await start_run(drv, script)
+        seq = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
+        await drv.wait(lambda s: "nextDispatch" in (s["runs"] or [{}])[0])
+        pending = await drv.stop(terminal=False)
+        assert_rejected(await drv.res(seq), "superseded")
+        await drv.wait(lambda s: (s["runs"] or [{}])[0].get("stopping") == {"reason": "stop"})
+        assert "nextDispatch" not in drv.run
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        assert (await drv.res(pending["seq"]))["type"] == "accepted"
+        await drv.wait_status("stopped")
+        script.no_call()
+
+
+async def test_sends_during_the_window_park_in_their_lanes():
+    script = Script()
+    async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
+        drv,
+        host,
+    ):
+        call = await start_run(drv, script)
+        seq = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
+        await drv.wait(lambda s: "nextDispatch" in (s["runs"] or [{}])[0])
+        await drv.command("run/enqueue", add("q1", anchor="a1"), terminal=False)
+        await drv.command("run/steer", add("s1", anchor="a1"), terminal=False)
+        assert queue_ids(drv.replica, "queue") == ["q1"]
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-edit"
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert queue_ids(drv.replica, "queue") == ["q1"]
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        rerun.ack()
+        rerun.finish(RunManager.Stop(dispatch_queue=False))
+
+
+async def test_entry_keys_are_absent_when_empty():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        await drv.wait_status("running")
+        assert set(drv.run.keys()) == {
+            "runId",
+            "status",
+            "queue",
+            "steerQueue",
+            "dispatching",
+        }
+        call.ack()
+        await drv.wait(lambda s: "dispatching" not in s["runs"][0])
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert set(drv.run.keys()) == {"runId", "status", "queue", "steerQueue", "error"}