harness-sdk-python 0.13.1__tar.gz → 0.13.2__tar.gz

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.2}/PKG-INFO

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

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

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.2}/src/harness_sdk/run_manager.py

@@ -10,10 +10,10 @@ dispatchable send appends straight into ``dispatching`` — it never transits a
 queue lane — and everything staged there by the end of the drain dispatches
 as one run; in error/stop the dispatch is the continuation
 (``error-continue`` / ``stop-continue``) carrying the send's messages. Every
-initiator acks and settles accepted with its state-visible application —
-sends with their insert (lane or ``dispatching``), edit/reload/continue at
-their dispatch; ``run/stop`` awaits a future the drain resolves once the
-in-flight run has ended.
+initiator acks and settles accepted with its state-visible application:
+the verdict certifies the admission write — sends with their insert (lane
+or ``dispatching``), mid-run edit/reload with the stopping window,
+``run/stop`` with ``stopping`` — never future execution.
 
 ``entry["dispatching"]`` is the dispatch record (absent between an ack and
 the next dispatch or take): the payload the run callback receives.
@@ -25,8 +25,8 @@ A mid-run stop or rewind opens a stopping window on the entry:
 ``stopping: {reason}`` plus, for rewinds, the staged dispatch as
 ``nextDispatch`` — written in the same envelope as the opener's pending
 answer. On run end one envelope promotes ``nextDispatch`` into
-``dispatching`` and clears the window; a later stop/rewind supersedes the
-staged one, which settles rejected (``superseded``).
+``dispatching`` and clears the window; a later stop/rewind replaces the
+staged dispatch, whose command already settled at its admission write.
 """
 
 import asyncio
@@ -209,7 +209,7 @@ class RunManager:
         self._dispatch_record: dict[str, Any] | None = None
         self._intake: list[Any] = []
         self._outcome: Any = None
-        self._staged_stops: list["asyncio.Future[Any]"] = []
+        self._stop_staged = False
         self._stop_reason: str | None = None
         self._staged_rewind: _Rewind | None = None
         self._dispatching: list[tuple[str, dict[str, Any]]] = []
@@ -354,10 +354,7 @@ class RunManager:
         for entry in entries:
             self._apply(entry, fx)
         if self._task is None:
-            for stop in self._staged_stops:
-                if not stop.done():
-                    stop.set_result(None)
-            self._staged_stops.clear()
+            self._stop_staged = False
             if isinstance(outcome, RunManager.Complete):
                 self._dispatched_ids = ()
             if self._staged_rewind is not None:
@@ -378,14 +375,12 @@ class RunManager:
                 )
                 if not rewind.acked:
                     rewind.ack()
-                if not rewind.future.done():
-                    rewind.future.set_result(None)
             elif outcome is not None:
                 self._settle_outcome(outcome)
             else:
                 self._idle_action(fx)
         if self._task is not None and (
-            self._staged_stops or self._staged_rewind is not None
+            self._stop_staged or self._staged_rewind is not None
         ):
             assert self._ctx is not None
             self._ctx.stop_requested.set()
@@ -401,12 +396,14 @@ class RunManager:
 
     def _apply(self, entry: Any, fx: _Effects) -> None:
         if isinstance(entry, _Stop):
-            self._staged_stops.append(entry.future)
             if self._task is not None:
+                self._stop_staged = True
                 if self._staged_rewind is not None:
-                    self._supersede()
+                    self._staged_rewind = None
                     self._entry().pop("nextDispatch", None)
                 self._entry()["stopping"] = {"reason": "stop"}
+            if not entry.future.done():
+                entry.future.set_result(None)
             return
         if isinstance(entry, _Continue):
             if not fx.continue_requested:
@@ -683,17 +680,7 @@ class RunManager:
             return True
         return False
 
-    def _supersede(self) -> None:
-        rewind, self._staged_rewind = self._staged_rewind, None
-        assert rewind is not None
-        if not rewind.future.done():
-            rewind.future.set_exception(
-                _reject("superseded", "a later stop/rewind replaced this command")
-            )
-
     def _stage_rewind(self, rewind: _Rewind) -> None:
-        if self._staged_rewind is not None:
-            self._supersede()
         self._staged_rewind = rewind
         if self._task is not None:
             entry = self._entry()
@@ -706,6 +693,8 @@ class RunManager:
             )
             rewind.ack()
             rewind.acked = True
+        if not rewind.future.done():
+            rewind.future.set_result(None)
 
     def _freeze(self, message: str, payload: Any = None) -> None:
         self._set_status("error")

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.2}/tests/test_batches.py

@@ -59,30 +59,24 @@ async def test_steer_and_stop_in_one_batch_nets_to_stop():
             [("run/steer", add("s1")), ("run/stop", {"runId": await drv.run_id()})]
         )
         assert (await drv.res(first))["type"] == "accepted"
-        assert (await drv.res(first + 1, terminal=False))["type"] == "pending"
+        assert (await drv.res(first + 1))["type"] == "accepted"
         await asyncio.wait_for(call.ctx.stop_requested.wait(), 5)
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(first + 1))["type"] == "accepted"
         await drv.wait_status("stopped")
         assert queue_ids(drv.replica, "steerQueue") == ["s1"]
         script.no_call()
 
 
-async def test_stop_settles_only_after_the_run_task_ends():
+async def test_stop_settles_at_the_stopping_write():
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
         call = await script.next_call()
         call.ack()
-        pending = await drv.stop(terminal=False)
-        assert pending["type"] == "pending"
-        for _ in range(5):
-            await asyncio.sleep(0)
-        assert all(
-            rsp["type"] == "pending" for rsp in drv._res.get(pending["seq"], [])
-        )
+        settled = await drv.stop()
+        assert settled["type"] == "accepted"
+        assert drv.replica["status"] == "running"
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
         await drv.wait_status("stopped")
 
 

{harness_sdk_python-0.13.1 → harness_sdk_python-0.13.2}/tests/test_stopping_window.py

@@ -1,10 +1,10 @@
 """Contract: the stopping window. Three openers — run/stop, mid-run
 edit/reload, and the enqueue/steer edit-of-dispatched form — write
-``stopping: {reason}`` (plus the staged rewind as ``nextDispatch``) in the
-same envelope as the opener's pending answer, ``status`` staying "running".
-On run end one envelope promotes ``nextDispatch`` into ``dispatching`` and
-clears the window; a later stop/rewind supersedes the staged command, which
-settles rejected (``superseded``)."""
+``stopping: {reason}`` (plus the staged rewind as ``nextDispatch``) and
+settle accepted with that write, ``status`` staying "running". On run end
+one envelope promotes ``nextDispatch`` into ``dispatching`` and clears the
+window; a later stop/rewind replaces the staged dispatch, whose command
+already settled at its admission write."""
 
 import asyncio
 import copy
@@ -13,7 +13,6 @@ import pytest
 from run_helpers import (
     Script,
     add,
-    assert_rejected,
     edit_params,
     msg,
     queue_ids,
@@ -57,23 +56,22 @@ async def start_run(drv, script, *, parent="p0"):
     return call
 
 
-async def test_stop_opens_the_window_with_the_pending_answer():
+async def test_stop_opens_the_window_and_settles_with_its_write():
     script = Script()
     async with run_host(script) as (drv, host):
         call = await start_run(drv, script)
-        pending = await drv.stop(terminal=False)
-        assert pending["type"] == "pending"
+        settled = await drv.stop()
+        assert settled["type"] == "accepted"
         assert drv.replica["status"] == "running"
         assert drv.run["stopping"] == {"reason": "stop"}
         assert "nextDispatch" not in drv.run
         opened = next(
             state
             for env, state in states(drv)
-            if any(r["seq"] == pending["seq"] for r in env.get("res", []))
+            if any(r["seq"] == settled["seq"] for r in env.get("res", []))
         )
         assert window_of(opened) == ({"reason": "stop"}, None)
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
         await drv.wait_status("stopped")
         assert "stopping" not in drv.run
 
@@ -178,7 +176,7 @@ async def test_edit_of_dispatched_message_opens_the_window(command):
         rerun.finish(RunManager.Complete())
 
 
-async def test_later_rewind_supersedes_the_staged_one():
+async def test_later_rewind_replaces_the_staged_dispatch():
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
         drv,
@@ -188,7 +186,7 @@ async def test_later_rewind_supersedes_the_staged_one():
         first = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
         await drv.wait(lambda s: "nextDispatch" in (s["runs"] or [{}])[0])
         second = drv.post("run/reload", reload_params("a1", anchor="m1"))
-        assert_rejected(await drv.res(first), "superseded")
+        assert (await drv.res(first))["type"] == "accepted"
         await drv.wait(
             lambda s: s["runs"][0]["nextDispatch"]["trigger"] == "message-reload"
         )
@@ -201,7 +199,7 @@ async def test_later_rewind_supersedes_the_staged_one():
         rerun.finish(RunManager.Complete())
 
 
-async def test_stop_supersedes_a_staged_rewind():
+async def test_stop_clears_a_staged_rewind():
     script = Script()
     async with run_host(script, capabilities=("rewind", "rewind-during-run")) as (
         drv,
@@ -210,12 +208,12 @@ async def test_stop_supersedes_a_staged_rewind():
         call = await start_run(drv, script)
         seq = drv.post("run/edit", edit_params("m1", msg("m2"), anchor="p0"))
         await drv.wait(lambda s: "nextDispatch" in (s["runs"] or [{}])[0])
-        pending = await drv.stop(terminal=False)
-        assert_rejected(await drv.res(seq), "superseded")
+        assert (await drv.res(seq))["type"] == "accepted"
+        settled = await drv.stop()
+        assert settled["type"] == "accepted"
         await drv.wait(lambda s: (s["runs"] or [{}])[0].get("stopping") == {"reason": "stop"})
         assert "nextDispatch" not in drv.run
         call.finish(RunManager.Stop(dispatch_queue=False))
-        assert (await drv.res(pending["seq"]))["type"] == "accepted"
         await drv.wait_status("stopped")
         script.no_call()