harness-sdk-python 0.4.4__tar.gz → 0.4.5__tar.gz

{harness_sdk_python-0.4.4 → harness_sdk_python-0.4.5}/PKG-INFO

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

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

{harness_sdk_python-0.4.4 → harness_sdk_python-0.4.5}/src/harness_sdk/run_manager.py

@@ -326,17 +326,20 @@ class RunManager:
                 fx.continues.clear()
             elif fx.new_added and pre_empty:
                 self._pop_dispatchable()
-        elif (
-            status == "input-required"
-            and self._input_requests
-            and len(self._input_answers) == len(self._input_requests)
-        ):
-            responses = tuple(
-                (request, *self._input_answers[request["id"]])
-                for request in self._input_requests
-            )
-            self._clear_input()
-            self._dispatch("input-resume", [], responses=responses)
+        elif status == "input-required":
+            if fx.steer_added and self._lane_items("steerQueue"):
+                abandoned = tuple(self._input_requests)
+                self._clear_input()
+                self._pop_dispatchable(abandoned_input=abandoned)
+            elif self._input_requests and len(self._input_answers) == len(
+                self._input_requests
+            ):
+                responses = tuple(
+                    (request, *self._input_answers[request["id"]])
+                    for request in self._input_requests
+                )
+                self._clear_input()
+                self._dispatch("input-resume", [], responses=responses)
 
     def _settle_outcome(self, outcome: Any) -> None:
         if isinstance(outcome, RunManager.Complete):
@@ -372,6 +375,7 @@ class RunManager:
         rollback_to: Any = _ABSENT,
         responses: Any = _ABSENT,
         root_meta: Any = None,
+        abandoned_input: tuple[dict[str, Any], ...] = (),
     ) -> None:
         if type not in _ENTRY_TYPES:
             raise ValueError(f"invalid entry type: {type!r}")
@@ -407,6 +411,7 @@ class RunManager:
             _responses=responses,
             _message_meta=message_meta,
             _root_meta=root_meta,
+            _abandoned_input=abandoned_input,
         )
         self._ctx = ctx
         self._sync_steering()
@@ -509,18 +514,20 @@ class RunManager:
         if plain(self._state["runLeafMessageId"]) in ids:
             self._state["runLeafMessageId"] = self._leaf_confirmed
 
-    def _pop_dispatchable(self) -> bool:
+    def _pop_dispatchable(
+        self, *, abandoned_input: tuple[dict[str, Any], ...] = ()
+    ) -> bool:
         steer = self._lane_items("steerQueue")
         if steer:
             self._state["steerQueue"] = []
             self._dispatching = [("steerQueue", item) for item in steer]
-            self._dispatch("message-send", steer)
+            self._dispatch("message-send", steer, abandoned_input=abandoned_input)
             return True
         queue = self._lane_items("queue")
         if queue:
             self._state["queue"].pop(0)
             self._dispatching = [("queue", queue[0])]
-            self._dispatch("message-send", [queue[0]])
+            self._dispatch("message-send", [queue[0]], abandoned_input=abandoned_input)
             return True
         return False
 
@@ -990,10 +997,6 @@ class RunManager:
             ack()
             self._schedule(self._drain)
             return await entry.future
-        if status == "input-required":
-            self._clear_input()
-            self._state["status"] = "stopped"
-            return None
         raise _reject("wrong-state", f"run/stop is rejected in {status}")
 
     def _validated_response(self, request_type: str, response: Any) -> dict[str, Any]:
@@ -1133,6 +1136,7 @@ class RunManager:
         _responses: Any
         _message_meta: dict[str, Any]
         _root_meta: Any
+        _abandoned_input: tuple[dict[str, Any], ...]
         steering: "RunManager.Steering" = field(init=False)
 
         def __post_init__(self) -> None:
@@ -1148,6 +1152,11 @@ class RunManager:
                 raise ValueError(f"message {message_id} was not dispatched to this run")
             return self._message_meta[message_id]
 
+        @property
+        def abandoned_input(self) -> tuple[dict[str, Any], ...]:
+            """Input requests pending when a dispatching send abandoned them; empty on every other start."""
+            return self._abandoned_input
+
         @property
         def stop_reason(self) -> str | None:
             return self._manager._stop_reason

{harness_sdk_python-0.4.4 → harness_sdk_python-0.4.5}/tests/test_input_required.py

@@ -207,20 +207,21 @@ async def test_custom_request_type_passes_through():
         await drv.wait_status("ready")
 
 
-async def test_stop_while_parked_clears_the_pending_set():
+async def test_stop_while_parked_rejects_and_keeps_the_pending_set():
     script = Script()
     async with run_host(script) as (drv, host):
         await park(drv, script, [tool_call("r1")])
-        assert (await drv.command("run/stop"))["type"] == "accepted"
-        await drv.wait_status("stopped")
-        assert "inputRequests" not in drv.replica
-        assert_rejected(
-            await drv.command(
-                "run/input", {"requestId": "r1", "response": {"output": "x"}}
-            ),
-            "wrong-state",
+        assert_rejected(await drv.command("run/stop"), "wrong-state")
+        assert drv.replica["status"] == "input-required"
+        assert drv.replica["inputRequests"] == [{**tool_call("r1"), "response": None}]
+        await drv.command(
+            "run/input", {"requestId": "r1", "response": {"output": "x"}}
         )
-        script.no_call()
+        resumed = await script.next_call()
+        assert resumed.ctx.type == "input-resume"
+        resumed.ack()
+        resumed.finish(RunManager.Complete())
+        await drv.wait_status("ready")
 
 
 async def test_invalid_requests_raise_at_construction():
@@ -307,10 +308,85 @@ async def test_reload_while_parked_clears_requests_and_reruns():
         await drv.wait_status("ready")
 
 
-async def test_steer_while_parked_stays_queued():
+async def test_steer_add_while_parked_abandons_input_and_dispatches():
     script = Script()
     async with run_host(script) as (drv, host):
-        await park(drv, script, [tool_call("r1")])
+        await park(drv, script, [tool_call("r1"), approval("r2")])
+        res = await drv.command("run/steer", add("s1"), terminal=False)
+        assert res["type"] == "pending"
+        run = await script.next_call()
+        assert run.ctx.type == "message-send"
+        assert [m["id"] for m in run.ctx.messages] == ["s1"]
+        assert run.ctx.abandoned_input == (tool_call("r1"), approval("r2"))
+        assert "inputRequests" not in drv.replica
+        run.ack()
+        run.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_steer_add_onto_nonempty_lane_while_parked_dispatches_whole_lane():
+    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"), terminal=False)
+        call.ack()
+        call.finish(RunManager.InputRequired([tool_call("r1")]))
+        await drv.wait_status("input-required")
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        await drv.command("run/steer", add("s2"), terminal=False)
+        run = await script.next_call()
+        assert [m["id"] for m in run.ctx.messages] == ["s1", "s2"]
+        assert run.ctx.abandoned_input == (tool_call("r1"),)
+        assert "inputRequests" not in drv.replica
+        run.ack()
+        run.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_promote_to_steer_while_parked_abandons_input_and_dispatches():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await park(drv, script, [tool_call("r1")])
+        await drv.command("run/enqueue", add("m2"), terminal=False)
+        assert queue_ids(drv.replica, "queue") == ["m2"]
+        script.no_call()
+        await drv.command("run/steer", {"messageId": "m2"})
+        run = await script.next_call()
+        assert run.ctx.type == "message-send"
+        assert [m["id"] for m in run.ctx.messages] == ["m2"]
+        assert run.ctx.abandoned_input == (tool_call("r1"),)
+        assert "inputRequests" not in drv.replica
+        run.ack()
+        run.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+
+
+async def test_enqueue_while_parked_parks_and_keeps_the_pending_set():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await park(drv, script, [tool_call("r1")])
+        await drv.command("run/enqueue", add("m2"), terminal=False)
+        assert queue_ids(drv.replica, "queue") == ["m2"]
+        assert drv.replica["status"] == "input-required"
+        assert drv.replica["inputRequests"] == [{**tool_call("r1"), "response": None}]
         script.no_call()
+
+
+async def test_abandoned_input_is_empty_on_ordinary_starts():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        assert call.ctx.abandoned_input == ()
+        call.ack()
+        call.finish(RunManager.InputRequired([tool_call("r1")]))
+        await drv.wait_status("input-required")
+        await drv.command(
+            "run/input", {"requestId": "r1", "response": {"output": "ok"}}
+        )
+        resumed = await script.next_call()
+        assert resumed.ctx.abandoned_input == ()
+        resumed.ack()
+        resumed.finish(RunManager.Complete())
+        await drv.wait_status("ready")

{harness_sdk_python-0.4.4 → harness_sdk_python-0.4.5}/tests/test_stop_continue.py

@@ -87,7 +87,7 @@ async def test_stop_rejected_outside_active_runs(state):
         assert_rejected(await drv.command("run/stop"), "wrong-state")
 
 
-async def test_stop_in_input_required_cancels_the_parked_run():
+async def test_stop_in_input_required_rejects_wrong_state():
     script = Script()
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
@@ -95,8 +95,8 @@ async def test_stop_in_input_required_cancels_the_parked_run():
         call.ack()
         call.finish(RunManager.InputRequired([{"type": "free-form", "id": "r1"}]))
         await drv.wait_status("input-required")
-        assert (await drv.command("run/stop"))["type"] == "accepted"
-        await drv.wait_status("stopped")
+        assert_rejected(await drv.command("run/stop"), "wrong-state")
+        assert drv.replica["status"] == "input-required"
 
 
 async def test_stop_settles_even_when_the_run_completes_normally():