harness-sdk-python 0.7.0__tar.gz → 0.7.1__tar.gz

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.1}/.gitignore

@@ -21,3 +21,4 @@ __pycache__
 /d[0-9]*.md
 /doc_*.md
 apps/docs/.docs
+/.agentdoc/

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.1}/PKG-INFO

@@ -1,11 +1,16 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.7.0
+Version: 0.7.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.5,>=0.4.0
+Provides-Extra: deepagents
+Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
+Requires-Dist: langchain-core>=0.3; extra == 'deepagents'
+Requires-Dist: langgraph>=1.0.0; extra == 'deepagents'
+Requires-Dist: uvicorn[standard]>=0.30.0; extra == 'deepagents'
 Provides-Extra: postgres
 Requires-Dist: langgraph-checkpoint-postgres>=2.0.0; extra == 'postgres'
 Description-Content-Type: text/markdown

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "harness-sdk-python"
-version = "0.7.0"
+version = "0.7.1"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
@@ -9,6 +9,12 @@ dependencies = ["statewire>=0.4.0,<0.5"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]
+deepagents = [
+    "deepagents>=0.6.12",
+    "langgraph>=1.0.0",
+    "langchain-core>=0.3",
+    "uvicorn[standard]>=0.30.0",
+]
 
 [project.urls]
 Repository = "https://github.com/assistant-ui/harness-sdk"

{harness_sdk_python-0.7.0 → harness_sdk_python-0.7.1}/src/harness_sdk/run_manager.py

@@ -244,6 +244,7 @@ class RunManager:
                     "status": "ready",
                     "queue": [],
                     "steerQueue": [],
+                    "dispatching": [],
                     "error": None,
                     "runLeafMessageId": None,
                 }
@@ -437,6 +438,7 @@ class RunManager:
         if self._task is not None:
             raise RuntimeError("a run is already in flight")
         message_meta = {m["id"]: m.get("meta") for m in messages}
+        dispatching = list(messages)
         messages = [
             {k: v for k, v in message.items() if k != "meta"} for message in messages
         ]
@@ -450,6 +452,7 @@ class RunManager:
         self._run_acked = False
         entry = self._ensure_entry()
         self._leaf_confirmed = plain(entry["runLeafMessageId"])
+        entry["dispatching"] = dispatching
         entry["error"] = None
         if messages:
             self._dispatched_ids = tuple(m["id"] for m in messages)
@@ -569,6 +572,7 @@ class RunManager:
             if ack is not None:
                 ack()
         self._dispatching = []
+        self._entry()["dispatching"] = []
         self._run_acked = True
         self._leaf_confirmed = plain(self._entry()["runLeafMessageId"])
         self._settle_sends()
@@ -577,9 +581,10 @@ class RunManager:
     def _revert_dispatching(self) -> None:
         self._settle_sends()
         taken, self._dispatching = self._dispatching, []
+        entry = self._ensure_entry()
+        entry["dispatching"] = []
         if not taken:
             return
-        entry = self._ensure_entry()
         for lane in ("steerQueue", "queue"):
             front = [item for taken_lane, item in taken if taken_lane == lane]
             if front:
@@ -1219,6 +1224,7 @@ class RunManager:
             entry = manager._entry()
             entry["steerQueue"] = []
             manager._dispatching.extend(("steerQueue", item) for item in items)
+            entry["dispatching"] = list(plain(entry["dispatching"])) + items
             if items:
                 entry["runLeafMessageId"] = items[-1]["id"]
             self._ctx._message_meta.update(

harness_sdk_python-0.7.1/tests/test_dispatching.py

@@ -0,0 +1,123 @@
+"""Contract: replicated dispatch limbo. ``dispatching`` on the run entry is
+the current dispatch's unacked messages — queue pops, steer-lane takes, and
+rewind dispatches alike. A message item lives in exactly one of the lanes,
+``dispatching``, or the thread, and every transition is single-envelope
+atomic: dispatch moves it lane → ``dispatching``, the messages-ack clears
+``dispatching`` as the canonical message appears, and an unacked run end
+returns lane items to the front of their lane."""
+
+import copy
+
+from run_helpers import Script, add, msg, queue_ids, run_host
+
+from harness_sdk import RunManager
+from statewire_helpers import apply_ops
+
+
+def dispatching_ids(replica):
+    runs = replica["runs"]
+    return [item["id"] for item in runs[0]["dispatching"]] if runs else []
+
+
+def places(state, message_id):
+    entry = (state.get("runs") or [{}])[0]
+    found = {
+        name
+        for name in ("queue", "steerQueue", "dispatching")
+        if any(item["id"] == message_id for item in entry.get(name, []))
+    }
+    if any(m["id"] == message_id for m in state.get("messages", [])):
+        found.add("messages")
+    return found
+
+
+def residence(drv, message_id):
+    """The item's place after each envelope, deduped: exactly one place per
+    envelope once it exists — the one-of-three invariant."""
+    state: dict = {}
+    trail: list[str] = []
+    for env in copy.deepcopy(drv.envelopes):
+        apply_ops(state, env)
+        found = places(state, message_id)
+        assert len(found) <= 1, found
+        if trail:
+            assert found, "item vanished between envelopes"
+        if found and (not trail or trail[-1] != next(iter(found))):
+            trail.append(next(iter(found)))
+    return trail
+
+
+async def test_idle_send_dispatches_straight_into_dispatching():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        await script.next_call()
+        await drv.wait_status("running")
+        assert dispatching_ids(drv.replica) == ["m1"]
+        assert queue_ids(drv.replica, "queue") == []
+        assert residence(drv, "m1") == ["dispatching"]
+
+
+async def test_ack_clears_dispatching_with_the_message_append():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        seq = drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        await drv.wait_status("running")
+        host.live.state["messages"] = [msg("m1")]
+        call.ack()
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert dispatching_ids(drv.replica) == []
+        assert residence(drv, "m1") == ["dispatching", "messages"]
+        call.finish(RunManager.Complete())
+
+
+async def test_unacked_run_end_returns_the_item_to_the_lane_front():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        await drv.side("run/enqueue", add("m2"))
+        await drv.wait(lambda s: queue_ids(s, "queue") == ["m2"])
+        await drv.side("run/stop", {"runId": await drv.run_id()})
+        call.finish(RunManager.Stop(dispatch_queue=False))
+        await drv.wait_status("stopped")
+        assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
+        assert dispatching_ids(drv.replica) == []
+        assert residence(drv, "m1") == ["dispatching", "queue"]
+
+
+async def test_steering_take_moves_the_lane_into_dispatching():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        host.live.state["messages"] = [msg("m1")]
+        call.ack()
+        await drv.command("run/steer", add("s1"), terminal=False)
+        call.ctx.steering.take()
+        await drv.wait(lambda s: dispatching_ids(s) == ["s1"])
+        assert queue_ids(drv.replica, "steerQueue") == []
+        assert residence(drv, "s1") == ["steerQueue", "dispatching"]
+        host.live.state["messages"] = [msg("m1"), msg("s1")]
+        call.ack()
+        await drv.wait(lambda s: dispatching_ids(s) == [])
+        assert residence(drv, "s1") == ["steerQueue", "dispatching", "messages"]
+        call.finish(RunManager.Complete())
+
+
+async def test_edit_replacement_rides_dispatching_until_ack():
+    script = Script()
+    script.thread["u1"] = {"parentId": None, "role": "user", "isLeaf": True}
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        seq = drv.post("run/edit", {"sourceId": "u1", "message": msg("u2")})
+        rerun = await script.next_call()
+        assert rerun.ctx.trigger == "message-edit"
+        await drv.wait_status("running")
+        assert dispatching_ids(drv.replica) == ["u2"]
+        host.live.state["messages"] = [msg("u2")]
+        rerun.ack()
+        assert (await drv.res(seq))["type"] == "accepted"
+        assert dispatching_ids(drv.replica) == []
+        assert residence(drv, "u2") == ["dispatching", "messages"]
+        rerun.finish(RunManager.Complete())