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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.10.1
+Version: 0.10.2
 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.10.2}/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.10.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "harness-sdk-python"
-version = "0.10.1"
+version = "0.10.2"
 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.10.2}/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
@@ -308,7 +307,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 +491,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 +500,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 +511,8 @@ class RunManager:
             self._ctx = None
             self._task = None
         self._dispatch_record = None
+        self._dispatching = []
+        self._ensure_entry()["dispatching"] = None
 
     def _ack(self) -> None:
         entry = self._entry()
@@ -524,18 +522,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.10.2}/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.10.2}/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.10.2}/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.10.1 → harness_sdk_python-0.10.2}/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")]