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

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.3.1
+Version: 0.4.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
 Requires-Python: <4.0,>=3.11
-Requires-Dist: statewire<0.4,>=0.3.0
+Requires-Dist: statewire<0.5,>=0.4.0
 Provides-Extra: postgres
 Requires-Dist: langgraph-checkpoint-postgres>=2.0.0; extra == 'postgres'
 Description-Content-Type: text/markdown

{harness_sdk_python-0.3.1 → harness_sdk_python-0.4.1}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.3.1"
+version = "0.4.1"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.11,<4.0"
-dependencies = ["statewire>=0.3.0,<0.4"]
+dependencies = ["statewire>=0.4.0,<0.5"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

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

@@ -45,7 +45,8 @@ _ENTRY_TYPES = (
 
 _DECISIONS = ("approve", "reject", "edit", "respond")
 
-GetMessageMeta = Callable[[str], Awaitable[dict[str, Any] | None]]
+# Called with None it answers for the thread root: isLeaf True iff the thread is empty.
+GetMessageMeta = Callable[[str | None], Awaitable[dict[str, Any] | None]]
 
 
 def _reject(reason: str, message: str) -> StatewireReject:
@@ -65,6 +66,9 @@ class _Send:
     meta: dict[str, Any] | None
     caller: StatewireClientHandle | None
     ack: Callable[[], None]
+    anchor: Any = _ABSENT
+    anchor_meta: dict[str, Any] | None = None
+    thread_empty: bool = False
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
 
@@ -133,6 +137,7 @@ class RunManager:
         get_message_meta: GetMessageMeta,
         create_task: Callable[[Any], "asyncio.Task[Any]"],
         schedule: Callable[[Callable[[], None]], None],
+        leaf_message_id: str | None,
         capabilities: Iterable[str] = (),
         max_queued: int = 50,
     ) -> None:
@@ -144,6 +149,10 @@ class RunManager:
             raise ValueError("rewind-during-run requires the rewind capability")
         if max_queued < 1:
             raise ValueError("max_queued must be >= 1")
+        if leaf_message_id is not None and (
+            not isinstance(leaf_message_id, str) or leaf_message_id == ""
+        ):
+            raise ValueError("leaf_message_id must be a non-empty string or None")
         self._state = state
         self._start = start
         self._get_message_meta = get_message_meta
@@ -165,14 +174,15 @@ class RunManager:
         self._run_futures: list["asyncio.Future[Any]"] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
-        self._init_state()
+        self._init_state(leaf_message_id)
 
-    def _init_state(self) -> None:
+    def _init_state(self, leaf_message_id: str | None) -> None:
         # Runs state is write-only and not durable: overwrite whatever is there.
         self._state["status"] = "ready"
         self._state["error"] = None
         self._state["queue"] = []
         self._state["steerQueue"] = []
+        self._state["runLeafMessageId"] = leaf_message_id
         self._state.pop("dispatch", None)
         self._state.pop("inputRequests", None)
 
@@ -217,7 +227,9 @@ class RunManager:
             if self._staged_rewinds:
                 rewind = self._staged_rewinds.pop(0)
                 self._dispatch(
-                    rewind.type, rewind.messages, rollback_to=rewind.rollback_to
+                    rewind.type,
+                    rewind.messages,
+                    rollback_to=rewind.rollback_to,
                 )
                 rewind.ack()
                 if not rewind.future.done():
@@ -332,6 +344,10 @@ class RunManager:
         self._state["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
+        if rollback_to is not _ABSENT:
+            self._state["runLeafMessageId"] = rollback_to
+        if messages:
+            self._state["runLeafMessageId"] = messages[-1]["id"]
         self._state["status"] = "running"
         ctx = RunManager.StartContext(
             type=type,
@@ -504,6 +520,24 @@ class RunManager:
             raise _reject("not-adjacent", "insertAfter and insertBefore are not adjacent")
         return slot
 
+    def _check_anchor(self, e: _Send) -> None:
+        if e.anchor is _ABSENT:
+            return
+        if e.anchor is None:
+            if not e.thread_empty:
+                raise _reject("wrong-anchor", "a null anchor asserts an empty thread")
+            return
+        if self._lane_of(e.anchor) is not None:
+            return
+        if e.anchor in self._dispatched_ids:
+            return
+        if e.anchor_meta is None:
+            raise _reject("unknown-id", f"anchor {e.anchor} names nothing")
+        if not e.anchor_meta["onActiveBranch"]:
+            raise _reject(
+                "wrong-anchor", f"anchor {e.anchor} is off the active branch"
+            )
+
     # ─── Queue mutations ────────────────────────────────────
 
     def _stamped(self, message: dict[str, Any]) -> dict[str, Any]:
@@ -579,6 +613,7 @@ class RunManager:
             return self._apply_move(e, fx)
         current = self._lane_of(e.message_id)
         if current is not None:
+            self._check_anchor(e)
             with self._caller_stamp(e.message_id, e.caller):
                 self._place(e.lane, current, e.message, e.params)
             if e.lane == "steerQueue":
@@ -590,6 +625,9 @@ class RunManager:
             raise _reject(
                 "duplicate-id", f"message id {e.message_id} is already used"
             )
+        if e.anchor is _ABSENT:
+            raise _reject("invalid-message", "anchorMessageId is required")
+        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
@@ -630,6 +668,7 @@ class RunManager:
             raise _reject("unknown-id", f"message {e.message_id} is unknown")
         if self._task is not None and not e.meta["isLeaf"]:
             raise _reject("not-leaf", "only the leaf may be edited during a run")
+        self._check_anchor(e)
         with self._caller_stamp(e.message_id, e.caller):
             self._staged_rewinds.append(
                 _Rewind(
@@ -697,7 +736,13 @@ class RunManager:
     def _apply_reload(self, e: _Reload) -> Any:
         self._check_leaf_lanes(e.source_meta, "run/reload")
         self._staged_rewinds.append(
-            _Rewind("message-reload", [], e.source_meta["parentId"], e.ack, e.future)
+            _Rewind(
+                "message-reload",
+                [],
+                e.source_meta["parentId"],
+                e.ack,
+                e.future,
+            )
         )
         return _PARKED
 
@@ -727,17 +772,50 @@ class RunManager:
             raise _reject(
                 "invalid-message", "exactly one of message and messageId is required"
             )
+        anchor = params.get("anchorMessageId", _ABSENT)
+        anchor_meta: dict[str, Any] | None = None
+        thread_empty = False
+        if anchor is None:
+            root = await self._get_message_meta(None)
+            assert root is not None, "get_message_meta(None) must answer for the root"
+            thread_empty = bool(root["isLeaf"])
+        elif anchor is not _ABSENT:
+            if not isinstance(anchor, str):
+                raise _reject("invalid-message", "anchorMessageId must be an id or null")
+            anchor_meta = await self._get_message_meta(anchor)
         if not has_message:
             message_id = params["messageId"]
             if not isinstance(message_id, str):
                 raise _reject("invalid-message", "messageId must be a string")
             return await self._stage(
-                _Send(lane, params, None, message_id, None, None, ack)
+                _Send(
+                    lane,
+                    params,
+                    None,
+                    message_id,
+                    None,
+                    None,
+                    ack,
+                    anchor=anchor,
+                    anchor_meta=anchor_meta,
+                    thread_empty=thread_empty,
+                )
             )
         message = self._validated_message(params["message"])
         meta = await self._get_message_meta(message["id"])
         return await self._stage(
-            _Send(lane, params, message, message["id"], meta, caller, ack)
+            _Send(
+                lane,
+                params,
+                message,
+                message["id"],
+                meta,
+                caller,
+                ack,
+                anchor=anchor,
+                anchor_meta=anchor_meta,
+                thread_empty=thread_empty,
+            )
         )
 
     async def enqueue(
@@ -1000,10 +1078,18 @@ class RunManager:
             for item in items:
                 self._manager._callers.pop(item["id"], None)
             self._manager._adopt_entities(item["id"] 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 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")
+            self._manager._state["runLeafMessageId"] = message_id
+
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()
             record = self._manager._dispatch_record

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

@@ -35,9 +35,21 @@ class Script:
         self.calls.put_nowait(call)
         return await call.outcome
 
-    async def get_message_meta(self, message_id: str) -> dict[str, Any] | None:
+    async def get_message_meta(self, message_id: str | None) -> dict[str, Any] | None:
+        if message_id is None:
+            return {"isLeaf": not self.thread}
         return self.thread.get(message_id)
 
+    def leaf_id(self) -> str | None:
+        return next(
+            (
+                id
+                for id, meta in self.thread.items()
+                if meta.get("isLeaf") and meta.get("onActiveBranch", True)
+            ),
+            None,
+        )
+
     async def next_call(self, timeout: float = 5) -> Call:
         return await asyncio.wait_for(self.calls.get(), timeout)
 
@@ -60,6 +72,7 @@ def make_host(script: Script, capabilities=(), initial_runs=None, max_queued=50)
                 get_message_meta=script.get_message_meta,
                 create_task=self.create_task,
                 schedule=self.schedule,
+                leaf_message_id=script.leaf_id(),
                 capabilities=capabilities,
                 max_queued=max_queued,
             )
@@ -202,6 +215,11 @@ def msg(id: str, text: str | None = None) -> dict[str, Any]:
     return {"id": id, "role": "user", "parts": [{"type": "text", "text": text or id}]}
 
 
+def add(id: str, text: str | None = None, *, anchor: str | None = None, **fields: Any) -> dict[str, Any]:
+    """Params for an enqueue/steer add: message + the required branch anchor."""
+    return {"message": msg(id, text), "anchorMessageId": anchor, **fields}
+
+
 def assert_rejected(rsp: dict[str, Any], reason: str) -> None:
     assert rsp["type"] == "rejected", rsp
     assert rsp["payload"] == {"reason": reason}, rsp

{harness_sdk_python-0.3.1 → harness_sdk_python-0.4.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, msg, queue_ids, run_host
+from run_helpers import Script, add, queue_ids, run_host
 
 from harness_sdk import RunManager
 
@@ -15,9 +15,9 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
     async with run_host(script) as (drv, host):
         first = await drv.batch(
             [
-                ("run/steer", {"message": msg("s1")}),
-                ("run/steer", {"message": msg("s2")}),
-                ("run/steer", {"message": msg("s3")}),
+                ("run/steer", add("s1")),
+                ("run/steer", add("s2")),
+                ("run/steer", add("s3")),
             ]
         )
         for offset in range(3):
@@ -35,10 +35,10 @@ async def test_multi_steer_batch_places_all_and_dispatches_once():
 async def test_steer_and_stop_in_one_batch_nets_to_stop():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         first = await drv.batch(
-            [("run/steer", {"message": msg("s1")}), ("run/stop", None)]
+            [("run/steer", add("s1")), ("run/stop", None)]
         )
         assert (await drv.res(first, terminal=False))["type"] == "pending"
         assert (await drv.res(first + 1, terminal=False))["type"] == "pending"
@@ -53,7 +53,7 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
 async def test_stop_settles_only_after_the_run_task_ends():
     script = Script()
     async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         pending = await drv.command("run/stop", terminal=False)
         assert pending["type"] == "pending"
@@ -70,15 +70,15 @@ async def test_stop_settles_only_after_the_run_task_ends():
 class TailScript(Script):
     """get_message_meta suspends, pushing staging past the handler prefix."""
 
-    async def get_message_meta(self, message_id: str) -> dict[str, Any] | None:
+    async def get_message_meta(self, message_id: str | None) -> dict[str, Any] | None:
         await asyncio.sleep(0)
-        return self.thread.get(message_id)
+        return await super().get_message_meta(message_id)
 
 
 async def test_handler_tail_staging_decides_in_its_own_envelope():
     script = TailScript()
     async with run_host(script) as (drv, host):
-        res = await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        res = await drv.command("run/enqueue", add("m1"), terminal=False)
         assert res["type"] == "pending"
         call = await script.next_call()
         assert [m["id"] for m in call.ctx.messages] == ["m1"]

harness_sdk_python-0.4.1/tests/test_branch_anchor.py

@@ -0,0 +1,137 @@
+from run_helpers import Script, add, assert_rejected, msg, queue_ids, run_host
+
+from harness_sdk import RunManager
+
+
+async def test_add_requires_a_branch_anchor():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        assert_rejected(
+            await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False),
+            "invalid-message",
+        )
+        assert_rejected(
+            await drv.command("run/steer", {"message": msg("m1")}, terminal=False),
+            "invalid-message",
+        )
+
+
+async def test_null_anchor_valid_only_on_an_empty_thread():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        res = await drv.command("run/enqueue", add("m1"), terminal=False)
+        assert res["type"] == "pending"
+        await script.next_call()
+        script.thread["m1"] = {
+            "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": True
+        }
+        assert_rejected(
+            await drv.command("run/enqueue", add("m2"), terminal=False), "wrong-anchor"
+        )
+        res = await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
+        assert res["type"] == "pending"
+
+
+async def test_active_branch_anchor_accepted_off_branch_and_unknown_rejected():
+    script = Script()
+    script.thread.update(
+        {
+            "u1": {"parentId": None, "role": "user", "isLeaf": False, "onActiveBranch": True},
+            "a1": {"parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": True},
+            "old": {"parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False},
+        }
+    )
+    async with run_host(script) as (drv, host):
+        res = await drv.command("run/enqueue", add("m1", anchor="a1"), terminal=False)
+        assert res["type"] == "pending"
+        await script.next_call()
+        assert_rejected(
+            await drv.command("run/enqueue", add("m2", anchor="old"), terminal=False),
+            "wrong-anchor",
+        )
+        assert_rejected(
+            await drv.command("run/enqueue", add("m2", anchor="zz"), terminal=False),
+            "unknown-id",
+        )
+
+
+async def test_queued_item_and_dispatched_ids_are_valid_anchors():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        await script.next_call()
+        await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
+        await drv.command("run/steer", add("s1", anchor="m2"), terminal=False)
+        assert queue_ids(drv.replica, "queue") == ["m2"]
+        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+
+
+async def test_replaced_tail_anchor_rejects_after_an_edit_rewrite():
+    script = Script()
+    script.thread.update(
+        {
+            "u1": {"parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": True},
+        }
+    )
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        res = await drv.command(
+            "run/edit", {"sourceId": "u1", "message": msg("m2")}, terminal=False
+        )
+        assert res["type"] == "pending"
+        await script.next_call()
+        script.thread["u1"] = {
+            "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": False
+        }
+        script.thread["m2"] = {
+            "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": True
+        }
+        assert_rejected(
+            await drv.command("run/enqueue", add("q1", anchor="u1"), terminal=False),
+            "wrong-anchor",
+        )
+        res = await drv.command("run/enqueue", add("q1", anchor="m2"), terminal=False)
+        assert res["type"] == "pending"
+
+
+async def test_anchor_on_the_queued_edit_form_is_validated_never_ignored():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        await script.next_call()
+        await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
+        assert_rejected(
+            await drv.command(
+                "run/enqueue",
+                {"message": msg("m2", "edited"), "anchorMessageId": "zz"},
+                terminal=False,
+            ),
+            "unknown-id",
+        )
+        await drv.command(
+            "run/enqueue",
+            {"message": msg("m2", "edited"), "anchorMessageId": "m1"},
+            terminal=False,
+        )
+        assert drv.replica["queue"][0]["parts"][0]["text"] == "edited"
+
+
+async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
+    script = Script()
+    script.thread.update(
+        {
+            "u1": {"parentId": None, "role": "user", "isLeaf": False, "onActiveBranch": True},
+            "a1": {"parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": True},
+        }
+    )
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        res = await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
+        assert res["type"] == "pending"
+        call = await script.next_call()
+        assert call.ctx.type == "message-reload"
+        script.thread["a1"] = {
+            "parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False
+        }
+        res = await drv.command("run/enqueue", add("m1", anchor="u1"), terminal=False)
+        assert res["type"] == "pending"
+        call.finish(RunManager.Complete())
+        await drv.wait_status("running")

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

@@ -1,5 +1,5 @@
 import pytest
-from run_helpers import Script, msg, run_host
+from run_helpers import Script, add, run_host
 
 from harness_sdk import RunManager
 
@@ -7,7 +7,7 @@ from harness_sdk import RunManager
 async def test_immediate_dispatch_carries_caller():
     script = Script()
     async with run_host(script) as (drv, _):
-        assert (await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False))[
+        assert (await drv.command("run/enqueue", add("m1"), terminal=False))[
             "type"
         ] == "pending"
         call = await script.next_call()
@@ -19,9 +19,9 @@ async def test_immediate_dispatch_carries_caller():
 async def test_queue_entry_projects_caller_client_id():
     script = Script()
     async with run_host(script) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
-        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
+        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.finish(RunManager.Complete())
@@ -30,9 +30,9 @@ async def test_queue_entry_projects_caller_client_id():
 async def test_caller_context_is_read_at_dispatch_time():
     script = Script()
     async with run_host(script) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
-        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
+        await drv.command("run/enqueue", add("m2"), terminal=False)
         assert (await drv.context({"user": "simon"}))["type"] == "accepted"
         call.finish(RunManager.Complete())
         dispatched = await script.next_call()
@@ -58,9 +58,9 @@ async def test_dispatch_without_queue_entry_has_no_caller():
 async def test_take_steered_strips_the_caller_stamp():
     script = Script()
     async with run_host(script) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
-        await drv.command("run/steer", {"message": msg("s1")}, terminal=False)
+        await drv.command("run/steer", add("s1"), terminal=False)
         await drv.wait(lambda s: len(s["steerQueue"]) == 1)
         assert drv.replica["steerQueue"][0]["caller"] == {"clientId": "c1"}
         [taken] = call.ctx.take_steered()
@@ -71,19 +71,19 @@ async def test_take_steered_strips_the_caller_stamp():
 async def test_max_queued_caps_each_lane():
     script = Script()
     async with run_host(script, max_queued=1) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
-        assert (await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False))[
+        assert (await drv.command("run/enqueue", add("m2"), terminal=False))[
             "type"
         ] == "pending"
-        full = await drv.command("run/enqueue", {"message": msg("m3")}, terminal=False)
+        full = await drv.command("run/enqueue", add("m3"), terminal=False)
         assert full["type"] == "rejected"
         assert full["payload"] == {"reason": "queue-full"}
         # The steer lane has its own budget.
-        assert (await drv.command("run/steer", {"message": msg("s1")}, terminal=False))[
+        assert (await drv.command("run/steer", add("s1"), terminal=False))[
             "type"
         ] == "pending"
-        steer_full = await drv.command("run/steer", {"message": msg("s2")}, terminal=False)
+        steer_full = await drv.command("run/steer", add("s2"), terminal=False)
         assert steer_full["payload"] == {"reason": "queue-full"}
         call.finish(RunManager.Complete())
 
@@ -91,10 +91,10 @@ async def test_max_queued_caps_each_lane():
 async def test_lane_change_into_a_full_lane_rejects():
     script = Script()
     async with run_host(script, max_queued=1) as (drv, _):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
-        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
-        await drv.command("run/steer", {"message": msg("s1")}, terminal=False)
+        await drv.command("run/enqueue", add("m2"), terminal=False)
+        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.finish(RunManager.Complete())
@@ -109,5 +109,6 @@ async def test_max_queued_below_one_rejects_at_construction():
             get_message_meta=script.get_message_meta,
             create_task=lambda coro: None,
             schedule=lambda fn: None,
+            leaf_message_id=None,
             max_queued=0,
         )

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

@@ -1,7 +1,7 @@
 import asyncio
 
 import pytest
-from run_helpers import Script, assert_rejected, msg, run_host
+from run_helpers import Script, add, assert_rejected, msg, run_host
 
 from harness_sdk import RunManager
 
@@ -10,7 +10,7 @@ from harness_sdk import RunManager
 async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": "p0", "role": "user", "isLeaf": True}
         pending = await drv.command(
@@ -35,7 +35,7 @@ async def test_edit_of_dispatched_item_stops_rewinds_reruns(command):
 async def test_edit_of_dispatched_item_requires_rewind_during_run(capabilities):
     script = Script()
     async with run_host(script, capabilities=capabilities) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         assert_rejected(
@@ -48,7 +48,7 @@ async def test_edit_of_dispatched_item_requires_rewind_during_run(capabilities):
 async def test_edit_of_dispatched_non_leaf_rejects(command):
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": False}
         assert_rejected(
@@ -59,10 +59,10 @@ async def test_edit_of_dispatched_non_leaf_rejects(command):
 async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
-        await drv.command("run/enqueue", {"message": msg("m2")}, terminal=False)
+        await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
         pending = await drv.command(
             "run/enqueue", {"message": msg("m1", "edited")}, terminal=False
         )
@@ -78,7 +78,7 @@ async def test_edit_of_dispatched_item_with_queued_items_stops_and_reruns():
 async def test_edit_of_dispatched_item_in_error_reruns_without_stop():
     script = Script()
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        await drv.command("run/enqueue", {"message": msg("m1")}, terminal=False)
+        await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         script.thread["m1"] = {"parentId": None, "role": "user", "isLeaf": True}
         call.fail(RuntimeError("boom"))