harness-sdk-python 0.36.1__tar.gz → 0.36.2__tar.gz

{harness_sdk_python-0.36.1 → harness_sdk_python-0.36.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.36.1
+Version: 0.36.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
 Requires-Python: <4.0,>=3.12
-Requires-Dist: pinned<0.16,>=0.15.0
-Requires-Dist: statewire<0.18,>=0.17.0
+Requires-Dist: pinned<0.16,>=0.15.1
+Requires-Dist: statewire<0.18,>=0.17.2
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.36.1 → harness_sdk_python-0.36.2}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.36.1"
+version = "0.36.2"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"
 requires-python = ">=3.12,<4.0"
-dependencies = ["statewire>=0.17.0,<0.18", "pinned>=0.15.0,<0.16"]
+dependencies = ["statewire>=0.17.2,<0.18", "pinned>=0.15.1,<0.16"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.36.1 → harness_sdk_python-0.36.2}/src/harness_sdk/run_manager.py

@@ -67,6 +67,7 @@ import logging
 from dataclasses import dataclass, field
 from typing import Any, AsyncIterator, Callable, Coroutine, Iterable, Protocol
 
+from pinned import EvictionRequested
 from pinned.trays import Tray, TrayDescriptor, TrayCtx, TrayMapNamespace, inbox
 from pinned.trays import persistent, persistent_outbox, persistent_queue
 from statepatch import observable
@@ -845,6 +846,12 @@ class RunManager(Tray):
 
     def _make_run_ctx(self, item: Any) -> "RunManager.RunContext":
         record = item["record"]
+        root_meta = record.get("rootMeta")
+        if "rootMeta" not in record:
+            if record["messages"]:
+                root_meta = record["messages"][0].get("meta")
+            elif record.get("inputOutcomes"):
+                root_meta = record["inputOutcomes"][0]["meta"]
         messages = [
             {k: v for k, v in message.items() if k not in ("meta", "~admit")}
             for message in record["messages"]
@@ -857,7 +864,7 @@ class RunManager(Tray):
             _manager=self,
             _rollback_to=record["rollbackTo"] if "rollbackTo" in record else _ABSENT,
             _message_meta={m["id"]: m.get("meta") for m in record["messages"]},
-            _root_meta=record.get("rootMeta"),
+            _root_meta=root_meta,
             _input_outcomes=tuple(
                 (o["request"], o["response"], o["meta"])
                 for o in record.get("inputOutcomes", ())
@@ -877,6 +884,8 @@ class RunManager(Tray):
         self._sync_steering()
         try:
             await task
+        except EvictionRequested:
+            raise
         except asyncio.CancelledError:
             current = asyncio.current_task()
             if current is not None and current.cancelling():
@@ -886,6 +895,8 @@ class RunManager(Tray):
             # user cancel: _execute already converged on the settle discipline
         finally:
             self._active = None
+            if self._run_live is ctx:
+                self._run_live = None
 
     async def _execute(self, ctx: "RunManager.RunContext", fn: Any) -> None:
         try:
@@ -905,34 +916,25 @@ class RunManager(Tray):
                 )
             if isinstance(outcome, RunManager.Complete) and self.dispatching.value is not None:
                 raise RuntimeError("run returned Complete with an unconfirmed batch")
+        except EvictionRequested:
+            self._advance()
+            if self._stop_staged or ctx._tray_ctx.consumed:
+                self._cancel_run(ctx)
+                return
+            raise
         except asyncio.CancelledError:
-            if self._closing or self._retirement is not None:
-                raise  # teardown: the un-acked outbox redelivers next activation
-            self.outcome.value = {
-                "kind": "cancel",
-                "epoch": self.epoch.value,
-                "dispatchQueue": False,
-            }
-            self._settle(ctx)
-            fx = self._apply_intake()
-            rewind = self._staged_rewind
-            if rewind is not None and not rewind.applied_sent:
-                # park the in-drain rewind durably; a cancel starts no dispatch
-                self.nextDispatch.value = self._record_of(
-                    rewind.type,
-                    list(rewind.messages),
-                    rollback_to=rewind.rollback_to,
-                    root_meta=rewind.root_meta,
+            if (
+                self._closing
+                or self._retirement is not None
+                or (
+                    self._evicting()
+                    and not self._stop_staged
+                    and not ctx._tray_ctx.consumed
                 )
-                rewind.applied()
-                rewind.applied_sent = True
-            self.halted.value = "stop"
-            self.outcome.value = None
-            self._resolve_stop_waiters()
-            self._publish_status()
-            self._settle_applied(fx)
-            self._idle.set()
-            raise  # staged intake settled; a cancelled run starts no dispatch
+            ):
+                raise  # teardown: the un-acked outbox redelivers next activation
+            self._cancel_run(ctx)
+            raise
         except Exception as exc:
             if not isinstance(exc, StatewireReject):
                 logger.exception(
@@ -957,6 +959,31 @@ class RunManager(Tray):
         self._outcome = self.outcome.value
         self._advance()
 
+    def _cancel_run(self, ctx: "RunManager.RunContext") -> None:
+        self.outcome.value = {
+            "kind": "cancel",
+            "epoch": self.epoch.value,
+            "dispatchQueue": False,
+        }
+        self._settle(ctx)
+        fx = self._apply_intake()
+        rewind = self._staged_rewind
+        if rewind is not None and not rewind.applied_sent:
+            self.nextDispatch.value = self._record_of(
+                rewind.type,
+                list(rewind.messages),
+                rollback_to=rewind.rollback_to,
+                root_meta=rewind.root_meta,
+            )
+            rewind.applied()
+            rewind.applied_sent = True
+        self.halted.value = "stop"
+        self.outcome.value = None
+        self._resolve_stop_waiters()
+        self._publish_status()
+        self._settle_applied(fx)
+        self._idle.set()
+
     def _maybe_self_delete(self) -> None:
         """A settled machine with no durable obligations deletes its tray; the
         next send recreates it fresh."""

{harness_sdk_python-0.36.1 → harness_sdk_python-0.36.2}/tests/test_meta.py

@@ -1,7 +1,7 @@
 """Contract: per-entry opaque meta. Message-carrying ops stamp it on the lane
 entry (client-visible, dies with the entry); dispatch delivers it through the
 start context — ``ctx.meta(id)`` per message, ``ctx.meta()`` for the op that
-started a reload/continue run, and the ``(request, response, meta)`` triple
+started the run, and the ``(request, response, meta)`` triple
 for input."""
 
 import pytest
@@ -36,7 +36,7 @@ async def test_immediate_dispatch_delivers_message_meta():
         call = await script.next_call()
         assert call.ctx.meta("m1") == {"clientId": "c1"}
         assert "meta" not in call.ctx.messages[0]
-        assert call.ctx.meta() is None
+        assert call.ctx.meta() == {"clientId": "c1"}
         call.applied()
         call.finish(RunManager.Complete())
 
@@ -55,6 +55,7 @@ async def test_queue_entry_projects_meta():
         call.finish(RunManager.Complete())
         dispatched = await script.next_call()
         assert dispatched.ctx.meta("m2") == {"tag": 7}
+        assert dispatched.ctx.meta() == {"tag": 7}
         assert "meta" not in dispatched.ctx.messages[0]
         dispatched.applied()
         dispatched.finish(RunManager.Complete())
@@ -140,7 +141,7 @@ async def test_edit_meta_rides_the_replacement_message():
         assert call.ctx.trigger == "message-edit"
         assert call.ctx.meta("u2") == {"edited": True}
         assert "meta" not in call.ctx.messages[0]
-        assert call.ctx.meta() is None
+        assert call.ctx.meta() == {"edited": True}
         call.applied()
         call.finish(RunManager.Complete())
 
@@ -189,5 +190,6 @@ async def test_input_meta_rides_the_response_triple():
         resumed = await script.next_call()
         assert resumed.ctx.trigger == "input-resume"
         assert resumed.ctx.input_outcomes == ((request, {"output": "ok"}, {"src": "c1"}),)
+        assert resumed.ctx.meta() == {"src": "c1"}
         resumed.applied()
         resumed.finish(RunManager.Complete())

harness_sdk_python-0.36.2/tests/test_run_eviction.py

@@ -0,0 +1,265 @@
+import asyncio
+import contextlib
+
+import pytest
+from pinned import EvictionRequested
+from pinned.testing import MemoryStateStore, instance
+from run_helpers import Script, _statement, add, make_host, run_host
+from statewire_helpers import post_frame
+
+from harness_sdk import RunManager
+
+
+async def enqueue(host, message_id, run_id):
+    return await asyncio.wait_for(
+        host.runs.enqueue(
+            add(message_id, run_id=run_id), applied=lambda: None, auth_result=None
+        ),
+        2,
+    )
+
+
+async def yield_run(call):
+    tray = call.ctx._manager
+    call.outcome.set_exception(EvictionRequested())
+    with contextlib.suppress(asyncio.CancelledError):
+        await asyncio.wait_for(asyncio.shield(tray._pump), 2)
+    await tray.storage._frontier.wait()
+
+
+@pytest.mark.parametrize("confirmed", [False, True])
+async def test_eviction_preserves_dispatch_and_admitted_queue_for_activation(confirmed):
+    store = MemoryStateStore()
+    script = Script()
+    async with instance(make_host(script), state_store=store) as host:
+        await enqueue(host, "first", "run")
+        call = await script.next_call()
+        call.ctx.set_state({"step": 3})
+        if confirmed:
+            call.applied()
+        tray = call.ctx._manager
+        tray._evicting = lambda: True
+        await enqueue(host, "queued", "run")
+        await yield_run(call)
+        await enqueue(host, "after-boundary", "run")
+        assert tray.status.value == "running"
+        assert tray.error.value is None
+        assert tray.halted.value is None
+        assert tray.outbox.value is not None
+        assert tray._run_live is None
+        script.no_call()
+
+    resumed = Script()
+    async with instance(make_host(resumed), state_store=store):
+        call = await resumed.next_call()
+        assert call.ctx.resume is confirmed
+        assert call.ctx.state == {"step": 3}
+        assert call.ctx.attempts == 1
+        if not confirmed:
+            assert [message["id"] for message in call.ctx.messages] == ["first"]
+            call.applied()
+        call.finish(RunManager.Complete())
+        for message_id in ["queued", "after-boundary"]:
+            queued = await resumed.next_call()
+            assert not queued.ctx.resume
+            assert [message["id"] for message in queued.ctx.messages] == [message_id]
+            queued.applied()
+            queued.finish(RunManager.Complete())
+        await asyncio.wait_for(queued.ctx._manager.idle.wait(), 2)
+        resumed.no_call()
+
+
+async def test_repeated_evictions_do_not_exhaust_delivery_attempts():
+    store = MemoryStateStore()
+    for activation in range(RunManager.max_attempts + 2):
+        script = Script()
+        async with instance(make_host(script), state_store=store) as host:
+            if activation == 0:
+                await enqueue(host, "first", "run")
+            call = await script.next_call()
+            assert call.ctx.attempts == 1
+            assert call.ctx.resume is (activation > 0)
+            if activation == 0:
+                call.applied()
+            call.ctx.set_state({"step": activation})
+            await yield_run(call)
+            assert not call.ctx._manager.parked
+    script = Script()
+    async with instance(make_host(script), state_store=store):
+        call = await script.next_call()
+        assert call.ctx.state == {"step": RunManager.max_attempts + 1}
+        call.finish(RunManager.Complete())
+        await asyncio.wait_for(call.ctx._manager.idle.wait(), 2)
+
+
+async def test_applied_send_retains_run_start_meta_after_eviction():
+    store = MemoryStateStore()
+    meta = {"user_id": "author", "runConfig": {"model": "test"}}
+    script = Script()
+    async with instance(make_host(script), state_store=store) as host:
+        await host.runs.enqueue(
+            add("first", run_id="run"),
+            meta=meta,
+            applied=lambda: None,
+            auth_result=None,
+        )
+        call = await script.next_call()
+        assert call.ctx.meta() == meta
+        call.applied()
+        await yield_run(call)
+
+    resumed = Script()
+    async with instance(make_host(resumed), state_store=store):
+        call = await resumed.next_call()
+        assert call.ctx.resume
+        with pytest.raises(RuntimeError, match="resume"):
+            _ = call.ctx.messages
+        assert call.ctx.meta() == meta
+        assert call.ctx.meta("first") == meta
+        call.finish(RunManager.Complete())
+        await asyncio.wait_for(call.ctx._manager.idle.wait(), 2)
+
+
+async def test_completion_during_wind_down_records_next_dispatch_without_starting_it():
+    store = MemoryStateStore()
+    script = Script()
+    async with instance(make_host(script), state_store=store) as host:
+        await enqueue(host, "first", "run")
+        call = await script.next_call()
+        call.applied()
+        await enqueue(host, "queued", "run")
+        tray = call.ctx._manager
+        tray._evicting = lambda: True
+        call.finish(RunManager.Complete())
+        with contextlib.suppress(asyncio.CancelledError):
+            await asyncio.wait_for(asyncio.shield(tray._pump), 2)
+        await host.frontier.wait()
+        assert tray.outbox.value["item"]["record"]["messages"][0]["id"] == "queued"
+        script.no_call()
+
+    resumed = Script()
+    async with instance(make_host(resumed), state_store=store):
+        call = await resumed.next_call()
+        assert not call.ctx.resume
+        assert [message["id"] for message in call.ctx.messages] == ["queued"]
+        call.applied()
+        call.finish(RunManager.Complete())
+        await asyncio.wait_for(call.ctx._manager.idle.wait(), 2)
+        resumed.no_call()
+
+
+async def test_command_admitted_over_wire_during_wind_down_runs_after_restart():
+    store = MemoryStateStore()
+    script = Script()
+    async with run_host(script, store=store) as (driver, host):
+        result = await driver.command("run/enqueue", add("first", run_id="run"))
+        assert result["type"] == "accepted"
+        call = await script.next_call()
+        call.ctx.set_state({"step": 3})
+        call.applied()
+        host.live.lease.wind_down()
+        response = await post_frame(
+            driver._client,
+            {"cmd": [_statement("run/enqueue", add("queued", run_id="run"), 2)]},
+            client_id=driver.client_id,
+        )
+        assert response.status_code == 200
+        await host.live.frontier.wait()
+        await yield_run(call)
+        await asyncio.wait_for(driver._app.state.pinned_host.directory.wait_empty(), 2)
+        script.no_call()
+
+    resumed = Script()
+    async with run_host(resumed, store=store):
+        call = await resumed.next_call()
+        assert call.ctx.resume
+        assert call.ctx.state == {"step": 3}
+        call.finish(RunManager.Complete())
+        queued = await resumed.next_call()
+        assert [message["id"] for message in queued.ctx.messages] == ["queued"]
+        queued.applied()
+        queued.finish(RunManager.Complete())
+        await asyncio.wait_for(queued.ctx._manager.idle.wait(), 2)
+        resumed.no_call()
+
+
+async def test_user_stop_at_eviction_boundary_settles_without_resuming():
+    store = MemoryStateStore()
+    script = Script()
+    async with instance(make_host(script), state_store=store) as host:
+        await enqueue(host, "first", "run")
+        call = await script.next_call()
+        call.applied()
+        await enqueue(host, "queued", "run")
+        stop = asyncio.create_task(
+            host.runs.stop({"runId": "run"}, applied=lambda: None, auth_result=None)
+        )
+        await asyncio.wait_for(call.ctx.stop_requested.wait(), 2)
+        await yield_run(call)
+        await asyncio.wait_for(stop, 2)
+        assert call.ctx._manager.status.value == "stopped"
+        script.no_call()
+
+    resumed = Script()
+    async with instance(make_host(resumed), state_store=store) as host:
+        await host.frontier.wait()
+        tray = host.runs.live()
+        assert tray is not None
+        assert tray.status.value == "stopped"
+        assert [message["id"] for message in tray.queue.value] == ["queued"]
+        resumed.no_call()
+
+
+async def test_forced_eviction_deadline_preserves_confirmed_run_and_queue():
+    store = MemoryStateStore()
+    script = Script()
+    async with run_host(script, store=store) as (driver, host):
+        await driver.command("run/enqueue", add("first", run_id="run"))
+        call = await script.next_call()
+        call.ctx.set_state({"step": 3})
+        call.applied()
+        await driver.command("run/enqueue", add("queued", run_id="run"))
+        host.live.lease.wind_down(0)
+        with contextlib.suppress(asyncio.CancelledError):
+            await asyncio.wait_for(asyncio.shield(call.ctx._manager._pump), 2)
+        assert call.outcome.cancelled()
+        assert call.ctx._manager.outbox.value is not None
+        assert call.ctx._manager.halted.value is None
+        await asyncio.wait_for(driver._app.state.pinned_host.directory.wait_empty(), 2)
+        script.no_call()
+
+    resumed = Script()
+    async with run_host(resumed, store=store):
+        call = await resumed.next_call()
+        assert call.ctx.resume
+        assert call.ctx.state == {"step": 3}
+        call.finish(RunManager.Complete())
+        queued = await resumed.next_call()
+        assert [message["id"] for message in queued.ctx.messages] == ["queued"]
+        queued.applied()
+        queued.finish(RunManager.Complete())
+        await asyncio.wait_for(queued.ctx._manager.idle.wait(), 2)
+        resumed.no_call()
+
+
+async def test_pending_approval_survives_eviction_without_execution():
+    store = MemoryStateStore()
+    script = Script()
+    request = {"id": "approval", "type": "tool-approval", "toolCallId": "tool"}
+    async with instance(make_host(script), state_store=store) as host:
+        await enqueue(host, "first", "run")
+        call = await script.next_call()
+        call.applied()
+        tray = call.ctx._manager
+        tray._evicting = lambda: True
+        call.finish(RunManager.InputRequired((request,)))
+        await asyncio.wait_for(tray.idle.wait(), 2)
+        await host.frontier.wait()
+        script.no_call()
+
+    resumed = Script()
+    async with instance(make_host(resumed), state_store=store) as host:
+        tray = await host.runs.for_run("run", principal=None)
+        assert tray.status.value == "input-required"
+        assert tray.inputRequests.value == [request]
+        resumed.no_call()