harness-sdk-python 0.33.0__tar.gz → 0.35.0__tar.gz

{harness_sdk_python-0.33.0 → harness_sdk_python-0.35.0}/.gitignore

@@ -25,3 +25,6 @@ apps/docs/.docs
 /.deepsec/
 .vercel
 .env*
+
+MAINTAIN_EPOCH.md
+DOCS_EPOCH.md

{harness_sdk_python-0.33.0 → harness_sdk_python-0.35.0}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.33.0
+Version: 0.35.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
 Requires-Python: <4.0,>=3.12
 Requires-Dist: pinned<0.16,>=0.15.0
-Requires-Dist: statewire<0.14,>=0.13.0
+Requires-Dist: statewire<0.16,>=0.15.0
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'
@@ -50,8 +50,10 @@ class RunsHost(Statewire):
         return RunManager.Complete()
 
     @command("run/enqueue")
-    async def run_enqueue(self, params, *, ctx):
-        return await (await self.run.get()).enqueue(params, applied=ctx.applied)
+    async def run_enqueue(self, params, *, ctx, auth_result):
+        return await self.run.enqueue(
+            params, applied=ctx.applied, auth_result=auth_result
+        )
 ```
 
 ## Docs

{harness_sdk_python-0.33.0 → harness_sdk_python-0.35.0}/README.md

@@ -31,8 +31,10 @@ class RunsHost(Statewire):
         return RunManager.Complete()
 
     @command("run/enqueue")
-    async def run_enqueue(self, params, *, ctx):
-        return await (await self.run.get()).enqueue(params, applied=ctx.applied)
+    async def run_enqueue(self, params, *, ctx, auth_result):
+        return await self.run.enqueue(
+            params, applied=ctx.applied, auth_result=auth_result
+        )
 ```
 
 ## Docs

{harness_sdk_python-0.33.0 → harness_sdk_python-0.35.0}/examples/runs_app.py

@@ -20,7 +20,7 @@ from typing import Any
 from fastapi import FastAPI
 from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
 from pinned import PinnedHost, PinnedWorker
-from pinned.testing import MemoryStateStore
+from pinned.durability import MemoryStateStore
 from statewire import Statewire, command, plain
 from statewire.langgraph import append_langgraph_event
 
@@ -154,36 +154,42 @@ class RunsHost(Statewire):
                 await stream.aclose()
 
     @command("run/enqueue")
-    async def run_enqueue(self, params, *, ctx):
-        return await (await self.run.get()).enqueue(params, applied=ctx.applied)
+    async def run_enqueue(self, params, *, ctx, auth_result):
+        return await self.run.enqueue(
+            params, applied=ctx.applied, auth_result=auth_result
+        )
 
     @command("run/steer")
-    async def run_steer(self, params, *, ctx):
-        return await (await self.run.get()).steer(params, applied=ctx.applied)
+    async def run_steer(self, params, *, ctx, auth_result):
+        return await self.run.steer(
+            params, applied=ctx.applied, auth_result=auth_result
+        )
 
     @command("run/dequeue")
-    async def run_dequeue(self, params):
-        return await (await self.run.get()).dequeue(params)
+    async def run_dequeue(self, params, *, auth_result):
+        return await self.run.dequeue(params, auth_result=auth_result)
 
     @command("run/edit")
-    async def run_edit(self, params, *, ctx):
-        return await (await self.run.get()).edit(params, applied=ctx.applied)
+    async def run_edit(self, params, *, ctx, auth_result):
+        return await self.run.edit(params, applied=ctx.applied, auth_result=auth_result)
 
     @command("run/reload")
-    async def run_reload(self, params, *, ctx):
-        return await (await self.run.get()).reload(params, applied=ctx.applied)
+    async def run_reload(self, params, *, ctx, auth_result):
+        return await self.run.reload(
+            params, applied=ctx.applied, auth_result=auth_result
+        )
 
     @command("run/stop")
-    async def run_stop(self, params=None, *, ctx):
-        return await (await self.run.get()).stop(params, applied=ctx.applied)
+    async def run_stop(self, params=None, *, ctx, auth_result):
+        return await self.run.stop(params, applied=ctx.applied, auth_result=auth_result)
 
     @command("run/continue")
-    async def run_continue(self, params=None, *, ctx):
-        return await (await self.run.get()).continue_run(applied=ctx.applied)
+    async def run_continue(self, params=None, *, ctx, auth_result):
+        return await self.run.continue_run(applied=ctx.applied, auth_result=auth_result)
 
     @command("run/input")
-    async def run_input(self, params):
-        return await (await self.run.get()).input(params)
+    async def run_input(self, params, *, auth_result):
+        return await self.run.input(params, auth_result=auth_result)
 
 
 worker = PinnedWorker(

{harness_sdk_python-0.33.0 → harness_sdk_python-0.35.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.33.0"
+version = "0.35.0"
 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.13.0,<0.14", "pinned>=0.15.0,<0.16"]
+dependencies = ["statewire>=0.15.0,<0.16", "pinned>=0.15.0,<0.16"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.33.0 → harness_sdk_python-0.35.0}/src/harness_sdk/run_manager.py

@@ -63,7 +63,6 @@ equality per principal.
 """
 
 import asyncio
-import contextlib
 import logging
 from dataclasses import dataclass, field
 from typing import Any, AsyncIterator, Callable, Coroutine, Iterable, Protocol
@@ -220,6 +219,17 @@ def _validated_response(
     return response
 
 
+def _check_rewind_gate(caps: Any, in_flight: bool, command: str) -> None:
+    if in_flight:
+        if "rewind-during-run" not in caps:
+            raise _reject(
+                "capability-missing",
+                f"{command} during a run requires the rewind-during-run capability",
+            )
+    elif "rewind" not in caps:
+        raise _reject("capability-missing", "the rewind capability is not enabled")
+
+
 def _check_rewind_anchor(params: Any, source_meta: dict[str, Any]) -> None:
     anchor = params.get("runAnchorMessageId", _ABSENT)
     if anchor is _ABSENT:
@@ -304,8 +314,9 @@ class _Continue:
 @dataclass
 class _Input:
     request_id: str
-    response: dict[str, Any]
+    response: Any
     meta: Any
+    principal: Any
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
 
@@ -1093,10 +1104,9 @@ class RunManager(Tray):
             raise _reject("queue-full", f"queue is full ({self.max_queued} messages)")
         self._batch.extend(("steerQueue", item) for item in steer)
         self._batch.append((e.lane, self._stamped(e.message, e.meta)))
-        self.dispatching.value = {
-            "trigger": self._send_trigger(),
-            "messages": [_public(item) for _, item in self._batch],
-        }
+        self.dispatching.value = _public_record(
+            self._record_of(self._send_trigger(), [item for _, item in self._batch])
+        )
 
     def _dispatch_staged(
         self, *, input_outcomes: tuple[tuple[dict[str, Any], Any, Any], ...] = ()
@@ -1331,14 +1341,7 @@ class RunManager(Tray):
     def _park_dispatched_edit(self, e: _Send) -> Any:
         assert e.message is not None
         self._check_run_owner(e.principal)
-        if self._in_flight():
-            if "rewind-during-run" not in self.capabilities:
-                raise _reject(
-                    "capability-missing",
-                    "editing during a run requires the rewind-during-run capability",
-                )
-        elif "rewind" not in self.capabilities:
-            raise _reject("capability-missing", "the rewind capability is not enabled")
+        _check_rewind_gate(self.capabilities, self._in_flight(), "editing")
         if e.source_meta is None:
             raise _reject("unknown-id", f"message {e.message_id} is unknown")
         self._check_anchor(e)
@@ -1367,6 +1370,7 @@ class RunManager(Tray):
     def _apply_input(self, e: _Input) -> Any:
         if self._status() != "input-required":
             raise _reject("wrong-state", f"run/input is rejected in {self._status()}")
+        self._check_run_owner(e.principal)
         index = next(
             (
                 i
@@ -1382,9 +1386,12 @@ class RunManager(Tray):
                 "already-answered",
                 f"input request {e.request_id} is already answered",
             )
-        self._input_answers[e.request_id] = (e.response, e.meta)
+        response = _validated_response(
+            type(self), self._input_requests[index]["type"], e.response
+        )
+        self._input_answers[e.request_id] = (response, e.meta)
         requests = self.inputRequests.value
-        requests[index]["response"] = e.response
+        requests[index]["response"] = response
         if e.meta is not None:
             requests[index]["meta"] = e.meta
         self.inputRequests.value = requests
@@ -1471,19 +1478,9 @@ class RunManager(Tray):
     async def input(
         self, params: dict[str, Any], *, meta: Any = None, auth_result: Any
     ) -> Any:
-        request_id = params["requestId"]
-        if self._status() != "input-required":
-            raise _reject("wrong-state", f"run/input is rejected in {self._status()}")
-        self._check_run_owner(auth_result)
-        request = next((r for r in self._input_requests if r["id"] == request_id), None)
-        if request is None:
-            raise _reject("unknown-id", f"input request {request_id} is unknown")
-        if request_id in self._input_answers:
-            raise _reject(
-                "already-answered", f"input request {request_id} is already answered"
-            )
-        response = _validated_response(type(self), request["type"], params["response"])
-        return await self._stage(_Input(request_id, response, meta))
+        return await self._stage(
+            _Input(params["requestId"], params["response"], meta, auth_result)
+        )
 
     async def continue_run(
         self, *, meta: Any = None, applied: Callable[[], None], auth_result: Any
@@ -1564,10 +1561,9 @@ class RunManager(Tray):
             added = [item["id"] for item in items if item["id"] not in known]
             if added:
                 manager.dispatchedIds.value = [*known, *added]
-            manager.dispatching.value = {
-                "trigger": "steer",
-                "messages": [_public(item) for item in items],
-            }
+            manager.dispatching.value = _public_record(
+                manager._record_of("steer", items)
+            )
             self._ctx._message_meta.update(
                 {item["id"]: item.get("meta") for item in items}
             )
@@ -1705,23 +1701,20 @@ class RunManagerNamespace(TrayMapNamespace):
     async def _machine(self, run_id: str, principal: Any) -> tuple[RunManager, bool]:
         # No await between the live() check and the mint's publication, and no
         # lock held across storage I/O: same-tick callers await the shared mint
-        # task and merge into the machine it mounts; the creator raises its
-        # mint's failure while followers re-mint and progress.
-        while True:
-            tray = self.live()
-            if tray is not None:
-                return tray, False
-            pending = self._mint
-            if pending is None:
-                pending = self._api.create_task(self.get_or_create(run_id))
-                self._mint = pending
-                pending.add_done_callback(self._mint_settled)
-                tray = await pending
-                if principal is not None and tray.principal.value is None:
-                    tray.principal.value = principal
-                return tray, True
-            with contextlib.suppress(Exception):
-                await pending
+        # task and merge into the machine it mounts, or raise its failure.
+        tray = self.live()
+        if tray is not None:
+            return tray, False
+        pending = self._mint
+        minted = pending is None
+        if pending is None:
+            pending = self._api.create_task(self.get_or_create(run_id))
+            self._mint = pending
+            pending.add_done_callback(self._mint_settled)
+        tray = await pending
+        if minted and principal is not None and tray.principal.value is None:
+            tray.principal.value = principal
+        return tray, minted
 
     def _mint_settled(self, task: "asyncio.Task[Any]") -> None:
         if self._mint is task:
@@ -1876,15 +1869,9 @@ class RunManagerNamespace(TrayMapNamespace):
     def _check_rewind_gate(self, command: str) -> None:
         cls: type[RunManager] = self._spec.tray_cls  # type: ignore[assignment]
         live = self.live()
-        status = "ready" if live is None else live._status()
-        if status in ("running", "stopping"):
-            if "rewind-during-run" not in cls.capabilities:
-                raise _reject(
-                    "capability-missing",
-                    f"{command} during a run requires the rewind-during-run capability",
-                )
-        elif "rewind" not in cls.capabilities:
-            raise _reject("capability-missing", "the rewind capability is not enabled")
+        _check_rewind_gate(
+            cls.capabilities, live is not None and live._in_flight(), command
+        )
 
     async def edit(
         self,

{harness_sdk_python-0.33.0 → harness_sdk_python-0.35.0}/tests/test_mint_concurrency.py

@@ -27,10 +27,10 @@ class WedgeStore(MemoryStateStore):
         return await super().get_tray(ns, id, tray_ns, tray_id, epoch)
 
 
-async def test_a_parked_mint_fails_at_the_deadline_and_followers_progress():
+async def test_a_parked_mint_failure_reaches_the_creator_and_its_followers():
     """No lock is held across mint storage I/O: a wedged mint fails loudly at
-    the store deadline, the waiting command re-mints its own machine, and the
-    wedged command surfaces the store error."""
+    the store deadline, and every command that merged into it raises that
+    same store error instead of re-minting."""
     script = Script()
     store = WedgeStore()
     async with run_host(script, store=store) as (drv, host):
@@ -42,10 +42,11 @@ async def test_a_parked_mint_fails_at_the_deadline_and_followers_progress():
         await asyncio.sleep(0.05)
         assert not follower.done()  # same-tick mints merge: followers await the pending mint
         store.fail()
-        tray = await asyncio.wait_for(follower, 5)
-        assert tray.id == "run-b"
+        with pytest.raises(TimeoutError):
+            await asyncio.wait_for(follower, 5)
         with pytest.raises(TimeoutError):
             await parked
+        assert list(api.runs.instances) == []
 
 
 async def test_concurrent_same_run_id_mints_resolve_to_one_machine():