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

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

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.10.2
+Version: 0.12.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
 Requires-Python: <4.0,>=3.11
-Requires-Dist: statewire<0.6,>=0.5.0
+Requires-Dist: statewire<0.7,>=0.6.0
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.10.2 → harness_sdk_python-0.12.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.10.2"
+version = "0.12.0"
 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.5.0,<0.6"]
+dependencies = ["statewire>=0.6.0,<0.7"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

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

@@ -215,18 +215,60 @@ class RunManager:
         return self._idle
 
     def _init_state(self) -> None:
-        # Runs state is write-only and not durable: overwrite whatever is there.
-        self._state["status"] = "ready"
-        self._state["runs"] = []
-        for key in (
-            "error",
-            "queue",
-            "steerQueue",
-            "runId",
-            "dispatch",
-            "inputRequests",
-        ):
-            self._state.pop(key, None)
+        runs = plain(self._state.get("runs"))
+        if runs is None or runs == []:
+            self._state["status"] = "ready"
+            self._state["runs"] = []
+            for key in (
+                "error",
+                "queue",
+                "steerQueue",
+                "runId",
+                "dispatch",
+                "inputRequests",
+            ):
+                self._state.pop(key, None)
+            return
+        self._hydrate(runs)
+
+    def _hydrate(self, runs: Any) -> None:
+        if not isinstance(runs, list) or len(runs) != 1:
+            raise ValueError("state['runs'] must hold exactly one entry to restore")
+        entry = runs[0]
+        if not isinstance(entry, dict):
+            raise ValueError("the restored run entry must be an object")
+        if entry.get("status") != "input-required":
+            raise ValueError(
+                "only an input-required entry restores, "
+                f"got status {entry.get('status')!r}"
+            )
+        run_id = entry.get("runId")
+        if not isinstance(run_id, str) or run_id == "":
+            raise ValueError("the restored runId must be a non-empty string")
+        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")
+        requests = entry.get("inputRequests")
+        if not isinstance(requests, list) or not requests:
+            raise ValueError("the restored inputRequests must be a non-empty list")
+        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"
+                )
+        outcome = RunManager.InputRequired(
+            tuple(
+                {k: v for k, v in request.items() if k != "response"}
+                for request in requests
+            )
+        )
+        self._input_requests = [dict(r) for r in outcome.requests]
+        self._state["status"] = "input-required"
 
     # ─── State access ───────────────────────────────────────
 
@@ -512,7 +554,11 @@ class RunManager:
             self._task = None
         self._dispatch_record = None
         self._dispatching = []
-        self._ensure_entry()["dispatching"] = None
+        entry = self._ensure_entry()
+        record = plain(entry["dispatching"])
+        if record is not None and record["trigger"] != "steer" and record["messages"]:
+            self._dispatched_ids = ()
+        entry["dispatching"] = None
 
     def _ack(self) -> None:
         entry = self._entry()

{harness_sdk_python-0.10.2 → harness_sdk_python-0.12.0}/tests/test_branch_anchor.py

@@ -128,6 +128,41 @@ async def test_replaced_tail_anchor_rejects_after_an_edit_rewrite():
         assert res["type"] == "pending"
 
 
+async def test_unacked_edit_crash_invalidates_the_replacement_anchor():
+    script = Script()
+    script.thread["u1"] = {
+        "parentId": None, "role": "user", "isLeaf": True, "onActiveBranch": True
+    }
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        drv.post("run/edit", edit_params("u1", msg("u2"), anchor=None))
+        (await script.next_call()).fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert_rejected(
+            await drv.command("run/enqueue", add("q1", anchor="u2"), terminal=False),
+            "unknown-id",
+        )
+        drv.post("run/enqueue", add("q1", anchor="u1"))
+        call = await script.next_call()
+        assert [m["id"] for m in call.ctx.messages] == ["q1"]
+
+
+async def test_unacked_recovery_run_keeps_acked_dispatch_anchors():
+    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")
+        await drv.command("run/continue", terminal=False)
+        continued = await script.next_call()
+        assert continued.ctx.trigger == "error-continue"
+        continued.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        res = await drv.command("run/steer", add("s1", anchor="m1"), 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):

harness_sdk_python-0.12.0/tests/test_restore.py

@@ -0,0 +1,136 @@
+"""Contract: restore across eviction. Construction hydrates a pre-existing
+input-required run entry from state — the host writes the parked entry before
+constructing RunManager — and the resume paths (answer all, steer) work as if
+the park never left memory. Empty runs state seeds ready; any other shape
+raises."""
+
+import asyncio
+
+import pytest
+from run_helpers import Script, add, msg, run_host
+
+from harness_sdk import RunManager
+
+
+def tool_call(id: str, tool_call_id: str = "tc1") -> dict:
+    return {"type": "tool-call", "id": id, "toolCallId": tool_call_id}
+
+
+def parked_entry(**overrides) -> dict:
+    return {
+        "runId": "run-1",
+        "status": "input-required",
+        "queue": [],
+        "steerQueue": [],
+        "dispatching": None,
+        "error": None,
+        "inputRequests": [{**tool_call("r1"), "response": None}],
+        **overrides,
+    }
+
+
+def construct(state: dict) -> RunManager:
+    script = Script()
+    return RunManager(
+        state=state,
+        run=script.run,
+        thread=script,
+        create_task=asyncio.ensure_future,
+        schedule=lambda fn: fn(),
+    )
+
+
+async def test_empty_runs_state_seeds_ready():
+    script = Script()
+    stale = {"status": "input-required", "runs": []}
+    async with run_host(script, initial_runs=stale) as (drv, host):
+        assert drv.replica == {"status": "ready", "runs": []}
+        script.no_call()
+
+
+async def test_hydrated_entry_rides_the_attach_snapshot():
+    script = Script()
+    async with run_host(script, initial_runs={"runs": [parked_entry()]}) as (
+        drv,
+        host,
+    ):
+        assert drv.replica["status"] == "input-required"
+        assert drv.run == parked_entry()
+        script.no_call()
+
+
+async def test_answering_all_hydrated_requests_resumes():
+    script = Script()
+    entry = parked_entry(queue=[msg("m2")])
+    async with run_host(script, initial_runs={"runs": [entry]}) as (drv, host):
+        res = await drv.command(
+            "run/input", {"requestId": "r1", "response": {"output": "ok"}}
+        )
+        assert res["type"] == "accepted"
+        resumed = await script.next_call()
+        assert resumed.ctx.trigger == "input-resume"
+        assert resumed.ctx.messages == ()
+        assert resumed.ctx.input_outcomes == (
+            (tool_call("r1"), {"output": "ok"}, None),
+        )
+        assert drv.run["runId"] == "run-1"
+        resumed.ack()
+        resumed.finish(RunManager.Complete())
+        drain = await script.next_call()
+        assert [m["id"] for m in drain.ctx.messages] == ["m2"]
+        drain.ack()
+        drain.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_steer_while_hydrated_abandons_input_and_dispatches():
+    script = Script()
+    async with run_host(script, initial_runs={"runs": [parked_entry()]}) as (
+        drv,
+        host,
+    ):
+        drv.post("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 == ((tool_call("r1"), None, None),)
+        await drv.wait_status("running")
+        assert "inputRequests" not in drv.run
+        run.ack()
+        run.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_malformed_restore_states_raise():
+    for state, match in [
+        ({"runs": "nope"}, "exactly one entry"),
+        ({"runs": [parked_entry(), parked_entry()]}, "exactly one entry"),
+        ({"runs": ["nope"]}, "must be an object"),
+        ({"runs": [parked_entry(status="running")]}, "input-required"),
+        ({"runs": [parked_entry(runId="")]}, "runId"),
+        ({"runs": [parked_entry(runId=None)]}, "runId"),
+        ({"runs": [parked_entry(queue=None)]}, "queue"),
+        ({"runs": [parked_entry(steerQueue=None)]}, "steerQueue"),
+        ({"runs": [parked_entry(dispatching={"trigger": "steer"})]}, "dispatching"),
+        ({"runs": [parked_entry(error={"message": "x"})]}, "error"),
+        ({"runs": [parked_entry(inputRequests=[])]}, "non-empty list"),
+        ({"runs": [parked_entry(inputRequests=["nope"])]}, "objects"),
+        (
+            {
+                "runs": [
+                    parked_entry(
+                        inputRequests=[
+                            {**tool_call("r1"), "response": {"output": "x"}}
+                        ]
+                    )
+                ]
+            },
+            "response",
+        ),
+        (
+            {"runs": [parked_entry(inputRequests=[{"type": "tool-call"}])]},
+            "non-empty string",
+        ),
+    ]:
+        with pytest.raises(ValueError, match=match):
+            construct(state)