harness-sdk-python 0.10.1__tar.gz → 0.11.0__tar.gz

{harness_sdk_python-0.10.1 → harness_sdk_python-0.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.10.1
+Version: 0.11.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.10.1 → harness_sdk_python-0.11.0}/examples/runs_app.py

@@ -6,7 +6,7 @@ Run from python/harness-sdk-python:
 
 State is ``{"messages": [...]}`` in langchain format; rewind truncates the
 list. Threads live at /threads/{id}: ``GET .../stream`` (SSE), ``.../ws``,
-``POST .../commands``, and ``POST .../assistant-transport/api/chat``.
+``POST .../commands``.
 
 Set PINBOARD_URL, PINBOARD_TOKEN, and ADVERTISE_URL to register with a
 pinboard control plane instead of local placement.
@@ -20,7 +20,7 @@ from typing import Any
 from fastapi import FastAPI
 from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
 from pinned import PinnedHost
-from statewire import AssistantTransport, command, plain
+from statewire import Statewire, command, plain
 from statewire.langgraph import append_langgraph_event
 
 from harness_sdk import RunManager, linear_thread
@@ -72,9 +72,7 @@ def user_text(message: dict[str, Any]) -> str:
     )
 
 
-class RunsHost(AssistantTransport):
-    assistant_transport_protocol = "assistant-transport"
-
+class RunsHost(Statewire):
     async def lifespan(self):
         self.agent = build_agent()
         self.state = {"messages": []}

{harness_sdk_python-0.10.1 → harness_sdk_python-0.11.0}/pyproject.toml

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

{harness_sdk_python-0.10.1 → harness_sdk_python-0.11.0}/src/harness_sdk/run_manager.py

@@ -15,10 +15,9 @@ in-flight run has ended.
 
 ``entry["dispatching"]`` is the dispatch record (or None): the payload the
 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.
+refill it — at most one unacked batch ever exists. Settle consumes the
+delivered batch, acked or not; steer entries still undelivered in the lane
+stay queued for the next run.
 """
 
 import asyncio
@@ -216,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 ───────────────────────────────────────
 
@@ -308,7 +349,7 @@ class RunManager:
                 rewind = self._staged_rewinds.pop(0)
                 self._clear_input()
                 if self._dispatching:
-                    self._revert_dispatching()
+                    self._unstage_dispatching()
                 entry = self._ensure_entry()
                 if entry["runId"] is None:
                     entry["runId"] = rewind.run_id
@@ -492,7 +533,6 @@ class RunManager:
         except asyncio.CancelledError:
             self._settle(ctx)
             self._set_status("stopped")
-            self._revert_dispatching()
             self._idle.set()
             raise  # no drain, no freeze
         except Exception as exc:
@@ -502,11 +542,9 @@ class RunManager:
                 self._freeze(exc.message, exc.payload)
             else:
                 self._freeze(message)
-            self._revert_dispatching()
             self._drain()
             return
         self._settle(ctx)
-        self._revert_dispatching()
         self._outcome = outcome
         self._drain()
 
@@ -515,6 +553,12 @@ class RunManager:
             self._ctx = None
             self._task = None
         self._dispatch_record = None
+        self._dispatching = []
+        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()
@@ -524,18 +568,14 @@ class RunManager:
         self._dispatching = []
         entry["dispatching"] = None
 
-    def _revert_dispatching(self) -> None:
+    def _unstage_dispatching(self) -> None:
         taken, self._dispatching = self._dispatching, []
         entry = self._ensure_entry()
         entry["dispatching"] = None
-        if not taken:
-            return
         for lane in ("steerQueue", "queue"):
             front = [item for taken_lane, item in taken if taken_lane == lane]
             if front:
                 entry[lane] = front + self._lane_items(lane)
-        ids = {item["id"] for _, item in taken}
-        self._dispatched_ids = tuple(id for id in self._dispatched_ids if id not in ids)
 
     def _dispatchable(self, lane: str) -> bool:
         if self._task is not None or self._staged_rewinds:

{harness_sdk_python-0.10.1 → harness_sdk_python-0.11.0}/tests/test_ack_visibility.py

@@ -60,7 +60,7 @@ async def test_parked_send_acks_with_its_queue_insert():
         call.finish(RunManager.Complete())
 
 
-async def test_unacked_run_end_reverts_the_direct_dispatch_to_the_queue():
+async def test_unacked_run_end_consumes_the_direct_dispatch():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
@@ -69,10 +69,10 @@ async def test_unacked_run_end_reverts_the_direct_dispatch_to_the_queue():
         assert dispatching_ids(covered_state(drv, seq)) == ["m1"]
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert queue_ids(drv.replica, "queue") == []
 
 
-async def test_unacked_run_end_reverts_the_direct_steer_send_to_the_steer_lane():
+async def test_unacked_run_end_consumes_the_direct_steer_send():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/steer", add("s1"))
@@ -81,7 +81,7 @@ async def test_unacked_run_end_reverts_the_direct_steer_send_to_the_steer_lane()
         assert dispatching_ids(covered_state(drv, seq)) == ["s1"]
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        assert queue_ids(drv.replica, "steerQueue") == []
         assert queue_ids(drv.replica, "queue") == []
 
 

{harness_sdk_python-0.10.1 → harness_sdk_python-0.11.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.10.1 → harness_sdk_python-0.11.0}/tests/test_dispatching.py

@@ -3,8 +3,8 @@ is the current unacked batch — a record ``{trigger, messages, rollbackTo?,
 inputOutcomes?}`` or None. A message item lives in exactly one of the lanes,
 the record's ``messages``, or the thread, and every transition is
 single-envelope atomic: dispatch fills the record, ``ctx.ack()`` clears it as
-the canonical message appears, a steer take refills it, and an unacked run
-end returns lane items to the front of their lane."""
+the canonical message appears, a steer take refills it, and settle consumes
+whatever is still unacked."""
 
 import copy
 
@@ -78,7 +78,7 @@ async def test_ack_clears_dispatching_with_the_message_append():
         call.finish(RunManager.Complete())
 
 
-async def test_unacked_run_end_returns_the_item_to_the_lane_front():
+async def test_unacked_run_end_consumes_the_delivered_item():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
@@ -88,9 +88,9 @@ async def test_unacked_run_end_returns_the_item_to_the_lane_front():
         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 queue_ids(drv.replica, "queue") == ["m2"]
         assert dispatching_ids(drv.replica) == []
-        assert residence(drv, "m1") == ["dispatching", "queue"]
+        assert residence(drv, "m2") == ["queue"]
 
 
 async def test_steering_take_moves_the_lane_into_dispatching():

{harness_sdk_python-0.10.1 → harness_sdk_python-0.11.0}/tests/test_meta.py

@@ -128,23 +128,6 @@ async def test_meta_dies_with_a_dequeued_entry():
         dispatched.finish(RunManager.Complete())
 
 
-async def test_unacked_run_end_reprojects_entries_with_meta():
-    script = Script()
-    async with run_host(script) as (drv, _):
-        drv.batch(
-            [
-                ("run/enqueue", add("m1", meta={"clientId": "c1"})),
-                ("run/steer", add("s1", meta={"clientId": "c2"})),
-            ]
-        )
-        call = await script.next_call()
-        assert [m["id"] for m in call.ctx.messages] == ["m1", "s1"]
-        call.fail(RuntimeError("boom"))
-        await drv.wait_status("error")
-        assert drv.run["queue"][0]["meta"] == {"clientId": "c1"}
-        assert drv.run["steerQueue"][0]["meta"] == {"clientId": "c2"}
-
-
 async def test_edit_meta_rides_the_replacement_message():
     script = Script()
     thread_with_turn(script)

harness_sdk_python-0.11.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)

{harness_sdk_python-0.10.1 → harness_sdk_python-0.11.0}/tests/test_settle.py

@@ -1,14 +1,13 @@
 """Contract: command settlement. Every initiator settles accepted with its
 state-visible application — sends with their insert (a lane entry or a direct
 ``dispatching`` entry), edit/reload/continue at their dispatch. The run's
-outcome never travels through settlement: a run that ends with unacked
-entries returns lane-origin items to the front of their lane, direct
-dispatches to the front of the queue, and lands any failure on
-``state.error``."""
+outcome never travels through settlement: settle consumes every delivered
+item, acked or not; steer entries still undelivered in the lane stay queued,
+and any failure lands on ``state.error``."""
 
 import asyncio
 
-from run_helpers import Script, add, edit_params, msg, queue_ids, run_host, target
+from run_helpers import Script, add, edit_params, msg, queue_ids, run_host
 
 from statewire import StatewireReject
 
@@ -51,7 +50,7 @@ async def test_run_reject_lands_the_payload_on_state_error():
         )
         assert (await drv.res(seq))["type"] == "accepted"
         await drv.wait_status("error")
-        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert queue_ids(drv.replica, "queue") == []
         assert drv.run["error"] == {
             "message": "payment required",
             "reason": "payment-required",
@@ -62,16 +61,15 @@ async def test_run_reject_lands_the_payload_on_state_error():
 async def test_unacked_run_end_settles_the_send_accepted():
     script = Script()
     async with run_host(script) as (drv, host):
-        for outcome in [
-            lambda call: call.fail(RuntimeError("boom")),
-            lambda call: call.finish(RunManager.Error(dispatch_queue=False)),
+        for name, outcome in [
+            ("m1", lambda call: call.fail(RuntimeError("boom"))),
+            ("m2", lambda call: call.finish(RunManager.Error(dispatch_queue=False))),
         ]:
-            seq = drv.post("run/enqueue", add("m1"))
+            seq = drv.post("run/enqueue", add(name))
             outcome(await script.next_call())
             assert (await drv.res(seq))["type"] == "accepted"
             await drv.wait_status("error")
-            assert queue_ids(drv.replica, "queue") == ["m1"]
-            await drv.command("run/dequeue", {"messageId": "m1"})
+            assert queue_ids(drv.replica, "queue") == []
 
 
 async def test_rewind_settles_before_the_reruns_end():
@@ -90,23 +88,23 @@ async def test_rewind_settles_before_the_reruns_end():
                 await drv.wait_status("stopped")
 
 
-async def test_unacked_run_end_reverts_entries_to_the_lane_front():
+async def test_unacked_run_end_consumes_the_delivered_batch():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.batch([("run/enqueue", add("m1")), ("run/enqueue", add("m2"))])
         call = await script.next_call()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
+        assert queue_ids(drv.replica, "queue") == []
         assert drv.run["error"] == {"message": "boom"}
-        await drv.command("run/steer", target(messageId="m1"), terminal=False)
+        await drv.command("run/steer", add("s1"), terminal=False)
         continued = await script.next_call()
         assert continued.ctx.trigger == "error-continue"
         continued.ack()
-        assert [m["id"] for m in continued.ctx.steering.take()] == ["m1"]
+        assert [m["id"] for m in continued.ctx.steering.take()] == ["s1"]
 
 
-async def test_unacked_run_end_reverts_taken_steered_items():
+async def test_unacked_run_end_consumes_taken_steered_items():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
@@ -117,7 +115,7 @@ async def test_unacked_run_end_reverts_taken_steered_items():
         call.ctx.steering.take()
         call.fail(RuntimeError("boom"))
         await drv.wait_status("error")
-        assert queue_ids(drv.replica, "steerQueue") == ["s1"]
+        assert queue_ids(drv.replica, "steerQueue") == []
         assert queue_ids(drv.replica, "queue") == []
 
 
@@ -132,17 +130,15 @@ async def test_ack_removes_the_entries_for_good():
         assert queue_ids(drv.replica, "queue") == []
 
 
-async def test_complete_without_ack_reverts_and_redispatches():
+async def test_complete_without_ack_consumes_the_dispatch():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.post("run/enqueue", add("m1"))
         (await script.next_call()).finish(RunManager.Complete())
-        redo = await script.next_call()
-        assert [m["id"] for m in redo.ctx.messages] == ["m1"]
         assert (await drv.res(seq))["type"] == "accepted"
-        redo.ack()
-        redo.finish(RunManager.Complete())
         await drv.wait_status("ready")
+        assert drv.replica["runs"] == []
+        script.no_call()
 
 
 async def test_dequeue_removes_a_parked_entry():
@@ -169,9 +165,9 @@ async def test_stop_lands_while_a_steer_is_parked():
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))
         await drv.wait_status("stopped")
-        # The unconsumed steer stays parked; the unacked dispatch reverts.
+        # The undelivered steer stays parked; the delivered dispatch is consumed.
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
-        assert queue_ids(drv.replica, "queue") == ["m1"]
+        assert queue_ids(drv.replica, "queue") == []
 
 
 async def test_rewind_edit_settles_at_its_dispatch():
@@ -199,7 +195,7 @@ async def test_rewind_rerun_failure_lands_on_state_error():
         assert drv.run["error"] == {"message": "payment required", "code": 402}
 
 
-async def test_task_cancellation_reverts_entries_and_settles_sends():
+async def test_task_cancellation_consumes_entries_and_settles_sends():
     script = Script()
     async with run_host(script) as (drv, host):
         seq = drv.batch([("run/enqueue", add("m1")), ("run/enqueue", add("m2"))])
@@ -208,7 +204,7 @@ async def test_task_cancellation_reverts_entries_and_settles_sends():
         task.cancel()
         assert (await drv.res(seq))["type"] == "accepted"
         await drv.wait_status("stopped")
-        assert queue_ids(drv.replica, "queue") == ["m1", "m2"]
+        assert queue_ids(drv.replica, "queue") == []
         assert task.cancelled()
 
 

harness_sdk_python-0.10.1/tests/test_facade.py

@@ -1,100 +0,0 @@
-"""Contract: run lifetime composed with the assistant-transport chat
-endpoint. The ``/chat`` hold releases once the send settles — the opening ``set`` carries the sent
-message as the ``dispatching`` record — then the response stays open through
-the run and EOFs once the run task ends; a run rejection is a single error
-frame then EOF.
-"""
-
-import asyncio
-
-from run_helpers import Script
-from statewire_helpers import statewire_client
-from test_assistant_transport import _PostStream, data_stream_frames, state_ops
-
-from statewire import AssistantTransport, StatewireReject, command
-
-from harness_sdk import RunManager
-
-
-def make_facade_host(script: Script):
-    class Host(AssistantTransport):
-        async def lifespan(self):
-            self.state = {}
-            self.runs = RunManager(
-                state=self.state,
-                run=script.run,
-                thread=script,
-                create_task=self.create_task,
-                schedule=self.schedule,
-            )
-            yield
-
-        @command("run/steer")
-        async def run_steer(self, params, *, ctx):
-            return await self.runs.steer(params, ack=ctx.ack)
-
-        @command("run/stop")
-        async def run_stop(self, params=None, *, ctx):
-            return await self.runs.stop(params, ack=ctx.ack)
-
-    return Host
-
-
-def chat_body():
-    return {
-        "commands": [
-            {
-                "type": "run/steer",
-                "runId": "run-1",
-                "runAnchorMessageId": None,
-                "message": {
-                    "id": "m1",
-                    "role": "user",
-                    "parts": [{"type": "text", "text": "hi"}],
-                },
-            }
-        ],
-        "state": {},
-        "threadId": "t1",
-    }
-
-
-async def test_chat_holds_until_the_entity_run_settles_then_eofs():
-    script = Script()
-    async with statewire_client(make_facade_host(script)) as (app, client):
-        async with _PostStream(
-            app, "/threads/t1/assistant-transport/api/chat", chat_body()
-        ) as stream:
-            assert stream.status == 200
-            call = await script.next_call()
-            assert call.ctx.trigger == "message-send"
-            instance = (await app.state.pinned_host.directory.get("t1")).instance
-            instance.state["messages"] = [dict(call.ctx.messages[0])]
-            call.ack()
-            await asyncio.sleep(0.05)
-            assert stream._task is not None and not stream._task.done()
-            call.finish(RunManager.Complete())
-            tail = await stream.until_closed()
-        frames = data_stream_frames(tail.decode())
-        assert frames and all(prefix == "aui-state" for prefix, _ in frames)
-        ops = state_ops(frames)
-        assert ops[0]["type"] == "set" and ops[0]["path"] == []
-        record = ops[0]["value"]["runs"][0]["dispatching"]
-        assert [m["id"] for m in record["messages"]] == [call.ctx.messages[0]["id"]]
-        assert any(
-            op["type"] == "set" and op["path"] == ["messages"] for op in ops[1:]
-        )
-
-
-async def test_chat_run_reject_is_one_error_frame_then_eof():
-    script = Script()
-    async with statewire_client(make_facade_host(script)) as (app, client):
-        async with _PostStream(
-            app, "/threads/t1/assistant-transport/api/chat", chat_body()
-        ) as stream:
-            call = await script.next_call()
-            call.fail(StatewireReject("payment required", payload={"code": 402}))
-            tail = await stream.until_closed()
-        frames = data_stream_frames(tail.decode())
-        errors = [frame for frame in frames if frame[0] == "3"]
-        assert errors == [("3", "payment required")]