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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.4.0
+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

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

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

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

@@ -90,7 +90,6 @@ class _Edit:
 @dataclass
 class _Reload:
     source_meta: dict[str, Any]
-    message_id: str
     ack: Callable[[], None]
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
@@ -119,7 +118,6 @@ class _Rewind:
     rollback_to: Any
     ack: Callable[[], None]
     future: "asyncio.Future[Any]"
-    message_id: str | None = None
     acked: bool = False
 
 
@@ -139,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:
@@ -150,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
@@ -160,7 +163,6 @@ class RunManager:
         self._task: "asyncio.Task[Any] | None" = None
         self._ctx: "RunManager.StartContext | None" = None
         self._dispatched_ids: tuple[str, ...] = ()
-        self._reload_message_id: str | None = None
         self._dispatch_record: dict[str, Any] | None = None
         self._callers: dict[str, StatewireClientHandle] = {}
         self._intake: list[Any] = []
@@ -172,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)
 
@@ -221,14 +224,12 @@ class RunManager:
             self._staged_stops.clear()
             if isinstance(outcome, RunManager.Complete):
                 self._dispatched_ids = ()
-                self._reload_message_id = None
             if self._staged_rewinds:
                 rewind = self._staged_rewinds.pop(0)
                 self._dispatch(
                     rewind.type,
                     rewind.messages,
                     rollback_to=rewind.rollback_to,
-                    message_id=rewind.message_id,
                 )
                 rewind.ack()
                 if not rewind.future.done():
@@ -321,7 +322,6 @@ class RunManager:
         *,
         rollback_to: Any = _ABSENT,
         responses: Any = _ABSENT,
-        message_id: str | None = None,
     ) -> None:
         if type not in _ENTRY_TYPES:
             raise ValueError(f"invalid entry type: {type!r}")
@@ -339,14 +339,15 @@ class RunManager:
             record["rollbackTo"] = rollback_to
         if responses is not _ABSENT:
             record["responses"] = responses
-        if message_id is not None:
-            record["messageId"] = message_id
         self._dispatch_record = record
         self._stop_reason = None
         self._state["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
-        self._reload_message_id = message_id
+        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,
@@ -356,7 +357,6 @@ class RunManager:
             _manager=self,
             _rollback_to=rollback_to,
             _responses=responses,
-            _message_id=message_id,
         )
         self._ctx = ctx
         self._task = self._create_task(self._run(ctx))
@@ -529,7 +529,7 @@ class RunManager:
             return
         if self._lane_of(e.anchor) is not None:
             return
-        if e.anchor in self._dispatched_ids or e.anchor == self._reload_message_id:
+        if e.anchor in self._dispatched_ids:
             return
         if e.anchor_meta is None:
             raise _reject("unknown-id", f"anchor {e.anchor} names nothing")
@@ -621,7 +621,7 @@ class RunManager:
             return None
         if e.message_id in self._dispatched_ids:
             return self._park_dispatched_edit(e)
-        if e.meta is not None or e.message_id == self._reload_message_id:
+        if e.meta is not None:
             raise _reject(
                 "duplicate-id", f"message id {e.message_id} is already used"
             )
@@ -735,14 +735,6 @@ class RunManager:
 
     def _apply_reload(self, e: _Reload) -> Any:
         self._check_leaf_lanes(e.source_meta, "run/reload")
-        if (
-            self._lane_of(e.message_id) is not None
-            or e.message_id in self._dispatched_ids
-            or e.message_id == self._reload_message_id
-        ):
-            raise _reject(
-                "duplicate-id", f"message id {e.message_id} is already used"
-            )
         self._staged_rewinds.append(
             _Rewind(
                 "message-reload",
@@ -750,7 +742,6 @@ class RunManager:
                 e.source_meta["parentId"],
                 e.ack,
                 e.future,
-                message_id=e.message_id,
             )
         )
         return _PARKED
@@ -896,11 +887,6 @@ class RunManager:
         source_id = params.get("sourceId") if isinstance(params, dict) else None
         if not isinstance(source_id, str):
             raise _reject("invalid-message", "sourceId must be a string")
-        message_id = params.get("messageId")
-        if not isinstance(message_id, str) or message_id == "":
-            raise _reject("invalid-message", "messageId must be a non-empty string")
-        if await self._get_message_meta(message_id) is not None:
-            raise _reject("duplicate-id", f"message id {message_id} is already used")
         meta = await self._get_message_meta(source_id)
         if meta is None:
             raise _reject("unknown-id", f"message {source_id} is unknown")
@@ -918,7 +904,7 @@ class RunManager:
                     "capability-missing",
                     "the assistant-continuation capability is not enabled",
                 )
-        return await self._stage(_Reload(meta, message_id, ack))
+        return await self._stage(_Reload(meta, ack))
 
     async def stop(self, params: Any = None, *, ack: Callable[[], None]) -> Any:
         if params is not None and not isinstance(params, dict):
@@ -1052,20 +1038,11 @@ class RunManager:
         _manager: "RunManager"
         _rollback_to: Any
         _responses: Any
-        _message_id: str | None
 
         @property
         def stop_reason(self) -> str | None:
             return self._manager._stop_reason
 
-        @property
-        def message_id(self) -> str:
-            if self._message_id is None:
-                raise AttributeError(
-                    "message_id is only present on message-reload entries"
-                )
-            return self._message_id
-
         @property
         def has_rollback(self) -> bool:
             return self._rollback_to is not _ABSENT
@@ -1101,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.4.0 → harness_sdk_python-0.4.1}/tests/run_helpers.py

@@ -40,6 +40,16 @@ class Script:
             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)
 
@@ -62,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,
             )

{harness_sdk_python-0.4.0 → harness_sdk_python-0.4.1}/tests/test_branch_anchor.py

@@ -115,7 +115,7 @@ async def test_anchor_on_the_queued_edit_form_is_validated_never_ignored():
         assert drv.replica["queue"][0]["parts"][0]["text"] == "edited"
 
 
-async def test_reload_requires_a_message_id_and_delivers_it_on_the_start_context():
+async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
     script = Script()
     script.thread.update(
         {
@@ -124,22 +124,14 @@ async def test_reload_requires_a_message_id_and_delivers_it_on_the_start_context
         }
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False),
-            "invalid-message",
-        )
-        assert_rejected(
-            await drv.command(
-                "run/reload", {"sourceId": "a1", "messageId": "u1"}, terminal=False
-            ),
-            "duplicate-id",
-        )
-        res = await drv.command(
-            "run/reload", {"sourceId": "a1", "messageId": "r9"}, terminal=False
-        )
+        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"
-        assert call.ctx.message_id == "r9"
+        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("ready")
+        await drv.wait_status("running")

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

@@ -47,7 +47,7 @@ async def test_dispatch_without_queue_entry_has_no_caller():
     script = Script()
     async with run_host(script, capabilities=("rewind",)) as (drv, _):
         script.thread["a1"] = {"role": "assistant", "parentId": None, "isLeaf": True}
-        assert (await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False))[
+        assert (await drv.command("run/reload", {"sourceId": "a1"}, terminal=False))[
             "type"
         ] == "pending"
         call = await script.next_call()
@@ -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.4.0 → harness_sdk_python-0.4.1}/tests/test_edit_reload.py

@@ -125,7 +125,7 @@ async def test_reload_dispatches_with_empty_messages():
     script = Script()
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        res = await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False)
+        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"
@@ -140,15 +140,15 @@ async def test_reload_rejections():
     thread_with_turn(script)
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "u1", "messageId": "r1"}, terminal=False), "invalid-message"
+            await drv.command("run/reload", {"sourceId": "u1"}, terminal=False), "invalid-message"
         )
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "zz", "messageId": "r1"}, terminal=False), "unknown-id"
+            await drv.command("run/reload", {"sourceId": "zz"}, terminal=False), "unknown-id"
         )
         await drv.command("run/enqueue", add("m1", anchor="a1"), terminal=False)
         await script.next_call()
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False), "capability-missing"
+            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False), "capability-missing"
         )
 
 
@@ -157,7 +157,7 @@ async def test_reload_without_rewind_rejects():
     thread_with_turn(script)
     async with run_host(script) as (drv, host):
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False), "capability-missing"
+            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False), "capability-missing"
         )
 
 
@@ -178,9 +178,9 @@ async def test_reload_leaf_only_while_queue_non_empty():
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a0", "messageId": "r1"}, terminal=False), "not-leaf"
+            await drv.command("run/reload", {"sourceId": "a0"}, terminal=False), "not-leaf"
         )
-        res = await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False)
+        res = await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
         assert res["type"] == "pending"
         call = await script.next_call()
         assert call.ctx.rollback_to == "m1"
@@ -196,12 +196,12 @@ async def test_reload_of_assistant_parented_response_needs_continuation():
     )
     async with run_host(script, capabilities=("rewind",)) as (drv, host):
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a2", "messageId": "r1"}, terminal=False), "capability-missing"
+            await drv.command("run/reload", {"sourceId": "a2"}, terminal=False), "capability-missing"
         )
     async with run_host(script, capabilities=("rewind", "assistant-continuation")) as (
         drv,
         host,
     ):
-        res = await drv.command("run/reload", {"sourceId": "a2", "messageId": "r1"}, terminal=False)
+        res = await drv.command("run/reload", {"sourceId": "a2"}, terminal=False)
         assert res["type"] == "pending"
         assert (await script.next_call()).ctx.rollback_to == "a1"

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

@@ -24,6 +24,7 @@ def make_facade_host(script: Script):
                 get_message_meta=script.get_message_meta,
                 create_task=self.create_task,
                 schedule=self.schedule,
+                leaf_message_id=script.leaf_id(),
             )
             yield
 

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

@@ -264,7 +264,7 @@ async def test_lifecycle_commands_rejected_while_parked():
             "wrong-state",
         )
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False), "wrong-state"
+            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False), "wrong-state"
         )
 
 

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

@@ -21,6 +21,7 @@ async def test_register_overwrites_whatever_is_in_the_state():
             "error": None,
             "queue": [],
             "steerQueue": [],
+            "runLeafMessageId": None,
         }
         script.no_call()
 
@@ -126,5 +127,6 @@ async def test_unknown_capability_rejects_at_construction():
             get_message_meta=None,
             create_task=asyncio.create_task,
             schedule=lambda fn: None,
+            leaf_message_id=None,
             capabilities=("time-travel",),
         )

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

@@ -58,7 +58,7 @@ async def test_running_leaf_reload_stops_settles_then_rewinds():
         call = await start_run(drv, script)
         await drv.command("run/enqueue", add("q1", anchor="a1"), terminal=False)
         pending = await drv.command(
-            "run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False
+            "run/reload", {"sourceId": "a1"}, terminal=False
         )
         assert pending["type"] == "pending"
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
@@ -81,7 +81,7 @@ async def test_running_edit_and_reload_reject_without_capability(capabilities):
             "capability-missing",
         )
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False), "capability-missing"
+            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False), "capability-missing"
         )
 
 
@@ -94,7 +94,7 @@ async def test_running_deeper_than_leaf_edit_and_reload_reject():
             "not-leaf",
         )
         assert_rejected(
-            await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False), "not-leaf"
+            await drv.command("run/reload", {"sourceId": "a1"}, terminal=False), "not-leaf"
         )
 
 
@@ -107,6 +107,7 @@ async def test_rewind_during_run_requires_rewind():
             get_message_meta=script.get_message_meta,
             create_task=asyncio.create_task,
             schedule=lambda fn: None,
+            leaf_message_id=None,
             capabilities=("rewind-during-run",),
         )
 
@@ -118,7 +119,7 @@ async def test_leaf_reload_in_error_accepted_with_non_empty_queue():
         await drv.command("run/enqueue", add("q1", anchor="a1"), terminal=False)
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        res = await drv.command("run/reload", {"sourceId": "a1", "messageId": "r1"}, terminal=False)
+        res = await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
         assert res["type"] == "pending"
         rerun = await script.next_call()
         assert rerun.ctx.type == "message-reload"

harness_sdk_python-0.4.1/tests/test_run_leaf.py

@@ -0,0 +1,116 @@
+import pytest
+from run_helpers import Script, add, msg, run_host
+
+from harness_sdk import RunManager
+
+
+def thread_with_turn(script: Script) -> None:
+    script.thread.update(
+        {
+            "u1": {"parentId": None, "role": "user", "isLeaf": False, "onActiveBranch": True},
+            "a1": {"parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": True},
+        }
+    )
+
+
+async def test_seeds_null_on_an_empty_thread():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        assert drv.replica["runLeafMessageId"] is None
+
+
+async def test_seeds_the_hosts_leaf_on_a_pre_existing_thread():
+    script = Script()
+    thread_with_turn(script)
+    async with run_host(script) as (drv, host):
+        assert drv.replica["runLeafMessageId"] == "a1"
+
+
+async def test_enqueue_dispatch_sets_the_leaf():
+    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.wait(lambda s: s["runLeafMessageId"] == "m1")
+
+
+async def test_steer_dispatch_sets_the_leaf_to_the_last_lane_item():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        await drv.command("run/steer", add("s1", anchor="m1"), terminal=False)
+        await drv.command("run/steer", add("s2", anchor="s1"), terminal=False)
+        call.finish(RunManager.Complete())
+        steered = await script.next_call()
+        assert steered.ctx.messages[-1]["id"] == "s2"
+        await drv.wait(lambda s: s["runLeafMessageId"] == "s2")
+
+
+async def test_take_steered_sets_the_leaf():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        await drv.command("run/steer", add("s1", anchor="m1"), terminal=False)
+        await drv.wait(lambda s: len(s["steerQueue"]) == 1)
+        call.ctx.take_steered()
+        await drv.wait(lambda s: s["runLeafMessageId"] == "s1")
+        call.finish(RunManager.Complete())
+
+
+async def test_executor_report_sets_the_leaf():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        call.ctx.set_leaf_message_id("a1")
+        await drv.wait(lambda s: s["runLeafMessageId"] == "a1")
+        call.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+        assert drv.replica["runLeafMessageId"] == "a1"
+
+
+async def test_edit_dispatch_sets_the_leaf_to_the_replacement():
+    script = Script()
+    thread_with_turn(script)
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        await drv.command(
+            "run/edit", {"sourceId": "u1", "message": msg("u2")}, terminal=False
+        )
+        await script.next_call()
+        await drv.wait(lambda s: s["runLeafMessageId"] == "u2")
+
+
+async def test_reload_dispatch_sets_the_leaf_to_the_rollback_target():
+    script = Script()
+    thread_with_turn(script)
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        await drv.command("run/reload", {"sourceId": "a1"}, terminal=False)
+        call = await script.next_call()
+        await drv.wait(lambda s: s["runLeafMessageId"] == "u1")
+        call.ctx.set_leaf_message_id("a2")
+        await drv.wait(lambda s: s["runLeafMessageId"] == "a2")
+
+
+async def test_report_rejects_an_empty_id():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        with pytest.raises(ValueError, match="non-empty"):
+            call.ctx.set_leaf_message_id("")
+        call.finish(RunManager.Complete())
+
+
+async def test_construction_rejects_an_invalid_leaf_id():
+    script = Script()
+    with pytest.raises(ValueError, match="leaf_message_id"):
+        RunManager(
+            state={},
+            start=script.start,
+            get_message_meta=script.get_message_meta,
+            create_task=lambda coro: None,
+            schedule=lambda fn: None,
+            leaf_message_id="",
+        )