harness-sdk-python 0.8.0__tar.gz → 0.9.0__tar.gz

{harness_sdk_python-0.8.0 → harness_sdk_python-0.9.0}/PKG-INFO

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

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

{harness_sdk_python-0.8.0 → harness_sdk_python-0.9.0}/src/harness_sdk/linear_thread.py

@@ -21,10 +21,6 @@ class LinearThread:
                 }
         return None
 
-    async def get_leaf_message_id(self) -> str | None:
-        items = self._messages()
-        return items[-1].get("id") if items else None
-
     async def get_message_child_id(self, parent_id: str) -> str | None:
         """The id of the first non-tool message after parent_id; None when parent_id is unknown or only tools follow."""
         items = self._messages()

{harness_sdk_python-0.8.0 → harness_sdk_python-0.9.0}/src/harness_sdk/run_manager.py

@@ -15,9 +15,9 @@ messages, rejected otherwise; ``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 and confirms
-``runLeafMessageId``; ``steering.take()`` may refill it — at most one unacked
-batch ever exists. A run that ends with an unacked record reverts its items
+run callback receives. ``ctx.ack()`` clears it; ``steering.take()`` may
+refill it — at most one unacked batch ever exists. A run that ends with an
+unacked record reverts its items
 by provenance: lane items to the front of their lane, direct dispatches to
 the front of the queue, rewind replacements dropped.
 """
@@ -155,10 +155,6 @@ class RunManager:
             """Meta for a known id ({parentId, role, isLeaf, onActiveBranch}), None for an unknown one; a None id probes the root ({isLeaf})."""
             ...
 
-        async def get_leaf_message_id(self) -> str | None:
-            """The active branch's current leaf id, None while the thread is empty."""
-            ...
-
     def __init__(
         self,
         *,
@@ -200,7 +196,6 @@ class RunManager:
         self._staged_rewinds: list[_Rewind] = []
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
         self._run_acked = False
-        self._leaf_confirmed: str | None = None
         self._run_futures: list["asyncio.Future[Any]"] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
@@ -222,7 +217,6 @@ class RunManager:
             "queue",
             "steerQueue",
             "runId",
-            "runLeafMessageId",
             "dispatch",
             "inputRequests",
         ):
@@ -247,7 +241,6 @@ class RunManager:
                     "steerQueue": [],
                     "dispatching": None,
                     "error": None,
-                    "runLeafMessageId": None,
                 }
             )
         return self._state["runs"][0]
@@ -454,14 +447,10 @@ class RunManager:
         self._stop_reason = None
         self._run_acked = False
         entry = self._ensure_entry()
-        self._leaf_confirmed = plain(entry["runLeafMessageId"])
         entry["dispatching"] = record
         entry["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
-        if rollback_to is not _ABSENT:
-            # The true leaf is the not-yet-created message; ack records it.
-            entry["runLeafMessageId"] = None
         entry["runId"] = uuid.uuid4().hex
         self._set_status("running")
         ctx = RunManager.RunContext(
@@ -496,7 +485,6 @@ class RunManager:
                     f"{type(outcome).__name__}"
                 )
         except asyncio.CancelledError:
-            await self._pull_leaf()
             self._settle(ctx)
             self._set_status("stopped")
             self._entry()["runId"] = None
@@ -507,7 +495,6 @@ class RunManager:
             self._idle.set()
             raise  # no drain, no freeze
         except Exception as exc:
-            await self._pull_leaf()
             self._settle(ctx)
             message = str(exc) or type(exc).__name__
             if isinstance(exc, StatewireReject):
@@ -521,7 +508,6 @@ class RunManager:
             self._revert_dispatching()
             self._drain()
             return
-        await self._pull_leaf()
         self._settle(ctx)
         if self._run_acked:
             error = None
@@ -536,12 +522,6 @@ class RunManager:
         self._outcome = outcome
         self._drain()
 
-    async def _pull_leaf(self) -> None:
-        # An end with an unacked batch reverts instead of recording a leaf.
-        if plain(self._entry()["dispatching"]) is not None:
-            return
-        self._entry()["runLeafMessageId"] = await self._thread.get_leaf_message_id()
-
     def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._ctx is ctx:
             self._ctx = None
@@ -566,17 +546,11 @@ class RunManager:
         self._dispatching = []
         entry["dispatching"] = None
         self._run_acked = True
-        if record["messages"]:
-            entry["runLeafMessageId"] = record["messages"][-1]["id"]
-        self._leaf_confirmed = plain(entry["runLeafMessageId"])
 
     def _revert_dispatching(self) -> None:
         taken, self._dispatching = self._dispatching, []
         entry = self._ensure_entry()
-        record = plain(entry["dispatching"])
         entry["dispatching"] = None
-        if record is not None and "rollbackTo" in record:
-            entry["runLeafMessageId"] = self._leaf_confirmed
         if not taken:
             return
         for lane in ("steerQueue", "queue"):
@@ -1319,7 +1293,7 @@ class RunManager:
                 raise RuntimeError("this run has already settled")
 
         def ack(self) -> None:
-            """Ack the current batch: clears the dispatch record and confirms the run leaf."""
+            """Ack the current batch: clears the dispatch record."""
             self._ensure_active()
             self._manager._ack()
 

{harness_sdk_python-0.8.0 → harness_sdk_python-0.9.0}/tests/run_helpers.py

@@ -32,7 +32,6 @@ class Script:
     def __init__(self) -> None:
         self.calls: asyncio.Queue[Call] = asyncio.Queue()
         self.thread: dict[str, dict[str, Any]] = {}
-        self.leaf: str | None = None
 
     async def run(self, ctx: RunManager.RunContext) -> Any:
         call = Call(ctx, asyncio.get_running_loop().create_future())
@@ -44,9 +43,6 @@ class Script:
             return {"isLeaf": not self.thread}
         return self.thread.get(message_id)
 
-    async def get_leaf_message_id(self) -> str | None:
-        return self.leaf
-
     async def next_call(self, timeout: float = 5) -> Call:
         return await asyncio.wait_for(self.calls.get(), timeout)
 

{harness_sdk_python-0.8.0 → harness_sdk_python-0.9.0}/tests/test_linear_thread.py

@@ -1,8 +1,8 @@
 """Contract: ``linear_thread`` projects a linear message list for RunManager —
 ``get_message_meta(None)`` probes the root (isLeaf iff empty), a known id gets
 ``{parentId, role, isLeaf, onActiveBranch}`` chained by list order, an unknown
-id gets ``None``; ``get_leaf_message_id`` is the last message's id; the extra
-``get_message_child_id`` resolves the first non-tool successor."""
+id gets ``None``; the extra ``get_message_child_id`` resolves the first
+non-tool successor."""
 
 import pytest
 
@@ -69,14 +69,6 @@ async def test_unknown_id_returns_none():
     assert await thread.get_message_meta("nope") is None
 
 
-async def test_leaf_is_the_last_message_id():
-    assert await _thread_for(THREAD).get_leaf_message_id() == "u2"
-
-
-async def test_leaf_of_an_empty_thread_is_none():
-    assert await _thread_for([]).get_leaf_message_id() is None
-
-
 async def test_child_id_skips_tool_messages():
     thread = _thread_for(
         [
@@ -109,7 +101,6 @@ async def test_reads_the_live_list():
     assert await thread.get_message_meta(None) == {"isLeaf": True}
     messages.append({"id": "u1", "type": "human"})
     assert await thread.get_message_meta(None) == {"isLeaf": False}
-    assert await thread.get_leaf_message_id() == "u1"
 
 
 def test_non_callable_messages_raises():

{harness_sdk_python-0.8.0 → harness_sdk_python-0.9.0}/tests/test_settle.py

@@ -101,7 +101,6 @@ async def test_unacked_run_end_reverts_entries_to_the_lane_front():
         await drv.wait_status("error")
         assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
         assert drv.run["error"] == {"message": "boom"}
-        assert drv.run["runLeafMessageId"] is None
         await drv.command("run/steer", {"messageId": "m1"}, terminal=False)
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
@@ -211,7 +210,6 @@ async def test_task_cancellation_reverts_entries_and_settles_sends():
         assert (await drv.res(seq))["type"] == "accepted"
         await drv.wait_status("stopped")
         assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
-        assert drv.run["runLeafMessageId"] is None
         assert task.cancelled()
 
 

harness_sdk_python-0.8.0/tests/test_run_leaf.py

@@ -1,191 +0,0 @@
-from run_helpers import Script, add, msg, run_host, run_of
-
-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_ready_state_has_no_run_entry():
-    script = Script()
-    thread_with_turn(script)
-    async with run_host(script) as (drv, host):
-        assert drv.replica["status"] == "ready"
-        assert drv.replica["runs"] == []
-
-
-async def test_ack_sets_the_leaf_to_the_last_batch_message():
-    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 drv.run["runLeafMessageId"] is None
-        call.ack()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m1")
-
-
-async def test_steer_batch_ack_sets_the_leaf_to_the_last_lane_item():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        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"
-        assert drv.run["runLeafMessageId"] == "m1"
-        steered.ack()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "s2")
-
-
-async def test_steering_take_moves_the_leaf_at_its_ack():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        await drv.command("run/steer", add("s1", anchor="m1"), terminal=False)
-        await drv.wait(lambda s: len(run_of(s).get("steerQueue", [])) == 1)
-        call.ctx.steering.take()
-        assert drv.run["runLeafMessageId"] == "m1"
-        call.ack()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "s1")
-        call.finish(RunManager.Complete())
-
-
-async def test_settle_pulls_the_thread_leaf():
-    for outcome in [
-        RunManager.Error(dispatch_queue=False),
-        RunManager.Stop(dispatch_queue=False),
-    ]:
-        script = Script()
-        async with run_host(script) as (drv, host):
-            drv.post("run/enqueue", add("m1"))
-            call = await script.next_call()
-            call.ack()
-            script.leaf = "a1"
-            call.finish(outcome)
-            await drv.wait_status("error", "stopped")
-            assert drv.run["runLeafMessageId"] == "a1"
-
-
-async def test_input_required_settle_pulls_the_thread_leaf():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        script.leaf = "a1"
-        call.finish(
-            RunManager.InputRequired(
-                requests=({"id": "r1", "type": "tool-call", "toolCallId": "t1"},)
-            )
-        )
-        await drv.wait_status("input-required")
-        assert drv.run["runLeafMessageId"] == "a1"
-
-
-async def test_unacked_end_reverts_instead_of_pulling():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        script.leaf = "a1"
-        call.fail(RuntimeError("boom"))
-        await drv.wait_status("error")
-        assert drv.run["runLeafMessageId"] is None
-        assert [item["id"] for item in drv.run["queue"]] == ["m1"]
-
-
-async def test_complete_clears_the_leaf_on_ready():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        script.leaf = "a1"
-        await drv.wait_status("running")
-        call.finish(RunManager.Complete())
-        await drv.wait_status("ready")
-        assert drv.replica["runs"] == []
-
-
-async def test_complete_with_a_queued_item_keeps_the_leaf_flowing():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        drv.post("run/enqueue", add("m1"))
-        call = await script.next_call()
-        call.ack()
-        await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
-        script.leaf = "a1"
-        call.finish(RunManager.Complete())
-        drain = await script.next_call()
-        drain.ack()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m2")
-        drain.finish(RunManager.Complete())
-        await drv.wait_status("ready")
-        assert drv.replica["runs"] == []
-
-
-async def test_rewind_dispatch_nulls_the_leaf_and_the_ack_records_the_replacement():
-    script = Script()
-    thread_with_turn(script)
-    async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
-        call = await script.next_call()
-        await drv.wait_status("running")
-        assert drv.run["runLeafMessageId"] is None
-        call.ack()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "u2")
-
-
-async def test_reload_dispatch_nulls_the_leaf_until_the_settle_pull():
-    script = Script()
-    thread_with_turn(script)
-    async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        drv.post("run/reload", {"sourceId": "a1"})
-        call = await script.next_call()
-        await drv.wait_status("running")
-        assert drv.run["runLeafMessageId"] is None
-        call.ack()
-        assert drv.run["runLeafMessageId"] is None
-        script.leaf = "a2"
-        call.finish(RunManager.Stop(dispatch_queue=False))
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a2")
-
-
-async def test_unacked_rewind_end_restores_the_previous_leaf():
-    script = Script()
-    thread_with_turn(script)
-    async with run_host(script, capabilities=("rewind",)) as (drv, host):
-        drv.post("run/enqueue", add("m1", anchor="a1"))
-        call = await script.next_call()
-        call.ack()
-        script.leaf = "a2"
-        call.finish(RunManager.Stop(dispatch_queue=False))
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a2")
-        drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
-        rerun = await script.next_call()
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") is None)
-        rerun.fail(RuntimeError("boom"))
-        await drv.wait_status("error")
-        assert drv.run["runLeafMessageId"] == "a2"