harness-sdk-python 0.36.2__py3-none-any.whl → 0.36.4__py3-none-any.whl

harness_sdk/deepagents.py

@@ -146,6 +146,8 @@ class DeepagentsMessages:
             )
         self._checkpointer = checkpointer
         self._captured: dict[str, Any] | None = None
+        self._admission: Any | None = None
+        self._input_checkpoint_seen = False
         self._ephemeral: dict[str, dict[str, Any]] = {}
         self._write_lock = asyncio.Lock()
 
@@ -190,8 +192,7 @@ class DeepagentsMessages:
         self, ctx: Any
     ) -> tuple[dict[str, Any] | None, dict[str, Any]]:
         """The dispatch's langgraph (payload, config): plans the resumption, restores a rewind's window, appends the batch to the wire state, and confirms it applied."""
-        self._captured = None
-        self._thread.abandon_plan()
+        self.abandon_turn()
         config = self.config()
         if ctx.resume:
             return None, config
@@ -206,7 +207,7 @@ class DeepagentsMessages:
         turn: list[Any] = [*plan.replay]
         for message in ctx.messages:
             turn.append(self._append_user(message))
-        ctx.applied()
+        self.admit(ctx.applied())
         if plan.fork:
             if plan.checkpoint_id is not None:
                 config["configurable"]["checkpoint_id"] = plan.checkpoint_id
@@ -217,11 +218,34 @@ class DeepagentsMessages:
                 turn = [RemoveMessage(id=REMOVE_ALL_MESSAGES), *turn]
         return ({"messages": turn} if turn else None), config
 
+    def admit(self, admission: Any) -> None:
+        """Retain a visibly applied batch until its root checkpoint is saved."""
+        if self._admission is not None:
+            raise RuntimeError("previous input admission is still pending")
+        self._admission = admission
+
+    def checkpoint_saved(self, config: Any, checkpoint: Any, metadata: Any) -> None:
+        """Confirm this turn's input from a FrontierCheckpointer checkpoint callback."""
+        configurable = config["configurable"]
+        if (
+            configurable["thread_id"] == self._thread_id
+            and configurable.get("checkpoint_ns", "") == ""
+            and metadata["source"] in ("input", "loop")
+        ):
+            self._confirm_admission()
+
+    def _confirm_admission(self) -> None:
+        if self._admission is not None:
+            self._admission.dur()
+            self._admission = None
+
     def append_event(self, namespace: tuple, mode: str, event: Any) -> None:
         """Fold one ``astream`` event into the wire state; the root checkpoint stream is captured for the turn's ingest."""
         if mode == "checkpoints":
             if namespace == ():
                 self._captured = event
+                if event["metadata"]["source"] in ("input", "loop"):
+                    self._input_checkpoint_seen = True
             return
         from statewire.langgraph import append_langgraph_event
 
@@ -231,11 +255,15 @@ class DeepagentsMessages:
         """Ingest the turn's captured checkpoint and restamp; ``refetch`` discards the capture and reads the checkpointer's latest instead."""
         captured, self._captured = self._captured, None
         await deepagents_ingest(self._thread, captured, refetch=refetch)
+        if self._input_checkpoint_seen:
+            self._confirm_admission()
         self._restamp()
 
     def abandon_turn(self) -> None:
         """Discard a stream capture and any fork planned for the abandoned turn."""
         self._captured = None
+        self._admission = None
+        self._input_checkpoint_seen = False
         self._thread.abandon_plan()
 
     def append_users(self, messages: Any) -> list[dict[str, Any]]:

harness_sdk/langgraph.py

@@ -0,0 +1,78 @@
+from typing import Any, AsyncIterator, Awaitable, Callable
+
+from langgraph.checkpoint.base import BaseCheckpointSaver
+from pinned import Frontier
+
+
+class FrontierCheckpointer(BaseCheckpointSaver):
+    """Order a LangGraph saver's async writes with the owning instance's durable effects."""
+
+    def __init__(
+        self,
+        saver: BaseCheckpointSaver,
+        *,
+        frontier: Frontier,
+        on_checkpoint: Callable[[Any, Any, Any], None] | None = None,
+    ) -> None:
+        if isinstance(saver, FrontierCheckpointer):
+            raise ValueError("a checkpointer can participate in only one frontier")
+        super().__init__(serde=saver.serde)
+        self.saver = saver
+        self.frontier = frontier
+        self.on_checkpoint = on_checkpoint
+
+    @property
+    def config_specs(self):
+        return self.saver.config_specs
+
+    def get_next_version(self, current, channel):
+        return self.saver.get_next_version(current, channel)
+
+    async def _persist(self, effect: Callable[[], Awaitable[Any]]) -> Any:
+        result = None
+
+        async def write() -> None:
+            nonlocal result
+            result = await effect()
+
+        pending = write()
+        try:
+            position = self.frontier.enlist(pending)
+        except BaseException:
+            pending.close()
+            raise
+        await self.frontier.wait(position)
+        return result
+
+    async def aget_tuple(self, config):
+        await self.frontier.receipt()
+        return await self.saver.aget_tuple(config)
+
+    async def aget_delta_channel_history(self, *, config, channels):
+        await self.frontier.receipt()
+        return await self.saver.aget_delta_channel_history(config=config, channels=channels)
+
+    async def alist(
+        self, config, *, filter=None, before=None, limit=None
+    ) -> AsyncIterator[Any]:
+        await self.frontier.receipt()
+        async for checkpoint in self.saver.alist(
+            config, filter=filter, before=before, limit=limit
+        ):
+            yield checkpoint
+
+    async def aput(self, config, checkpoint, metadata, new_versions):
+        result = await self._persist(
+            lambda: self.saver.aput(config, checkpoint, metadata, new_versions)
+        )
+        if self.on_checkpoint is not None:
+            self.on_checkpoint(config, checkpoint, metadata)
+        return result
+
+    async def aput_writes(self, config, writes, task_id, task_path="") -> None:
+        await self._persist(
+            lambda: self.saver.aput_writes(config, writes, task_id, task_path)
+        )
+
+    async def adelete_thread(self, thread_id) -> None:
+        await self._persist(lambda: self.saver.adelete_thread(thread_id))

harness_sdk/run_manager.py

@@ -26,9 +26,10 @@ order, then takes exactly one action based on the derived status and net
 effect (rewind > send-dispatch > continue > input-resume). Every initiator applies
 and settles accepted with its state-visible application, and every verb's
 verdict follows the admission's durable flush. ``entry["dispatching"]`` is
-the unconfirmed batch record; ``ctx.applied()`` confirms it durably,
+the visible batch record; ``ctx.applied()`` clears it at memory speed and
+returns an admission whose ``dur()`` confirms consumption behind prior frontier effects,
 ``steering.take()`` may refill it via deferred durable pops — at most one
-unconfirmed batch ever exists. Settle consumes a confirmed batch; a batch
+visibly unapplied batch exists. Admission handles retain unconfirmed batches. Settle consumes a confirmed batch; a batch
 still unconfirmed at settle returns to the front of its lanes (after a crash,
 unconfirmed taken entries re-present there on their own). A batch already
 durably confirmed redelivers in resume mode instead (``ctx.resume``): the
@@ -68,6 +69,7 @@ from dataclasses import dataclass, field
 from typing import Any, AsyncIterator, Callable, Coroutine, Iterable, Protocol
 
 from pinned import EvictionRequested
+from pinned.durability import FenceLost
 from pinned.trays import Tray, TrayDescriptor, TrayCtx, TrayMapNamespace, inbox
 from pinned.trays import persistent, persistent_outbox, persistent_queue
 from statepatch import observable
@@ -396,6 +398,7 @@ class RunManager(Tray):
         self._staged_rewind: _Rewind | None = None
         self._batch: list[tuple[str, dict[str, Any]]] = []
         self._pending_takes = 0
+        self._admissions: list[RunManager.Admission] = []
         self._input_requests: list[dict[str, Any]] = []
         self._input_answers: dict[str, Any] = {}
         self._run_live: "RunManager.RunContext | None" = None
@@ -914,7 +917,9 @@ class RunManager(Tray):
                     "run must return a RunManager outcome, got "
                     f"{type(outcome).__name__}"
                 )
-            if isinstance(outcome, RunManager.Complete) and self.dispatching.value is not None:
+            if isinstance(outcome, RunManager.Complete) and (
+                self.dispatching.value is not None or self._admissions
+            ):
                 raise RuntimeError("run returned Complete with an unconfirmed batch")
         except EvictionRequested:
             self._advance()
@@ -1028,11 +1033,33 @@ class RunManager(Tray):
     def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._run_live is ctx:
             self._run_live = None
+        takes = self._pending_takes + sum(a._takes for a in self._admissions)
+        if takes:
+            self.steerQueue.untake(takes)
+            self._drop_dispatched(
+                message["id"]
+                for admission in self._admissions
+                if admission._takes
+                for _, message in admission._batch
+            )
+            if self._pending_takes:
+                self._drop_dispatched(message["id"] for _, message in self._batch)
+                self._batch = []
+            self._pending_takes = 0
+        self._admissions.clear()
+        recorded = self.outbox.value
+        if recorded is not None and not self.batchApplied.value:
+            item = recorded["item"]
+            self._batch = list(zip(item["lanes"], item["record"]["messages"]))
         if self._batch:
             self._drop_dispatched(item["id"] for _, item in self._batch)
             self._unstage_batch()
         else:
-            record = self.dispatching.value
+            record = (
+                recorded["item"]["record"]
+                if recorded is not None and not self.batchApplied.value
+                else self.dispatching.value
+            )
             if (
                 record is not None
                 and record["trigger"] != "steer"
@@ -1068,16 +1095,15 @@ class RunManager(Tray):
         self.dispatching.value = None
         self._finish_settle()
 
-    def _applied(self) -> None:
+    def _applied(self, ctx: "RunManager.RunContext") -> "RunManager.Admission":
         if self.dispatching.value is None:
             raise RuntimeError("applied() with no unapplied batch")
-        if self._pending_takes:
-            self.confirmedTakes.value = self.confirmedTakes.value + self._pending_takes
-            self._pending_takes = 0
-        else:
-            self.batchApplied.value = True
+        admission = RunManager.Admission(ctx, list(self._batch), self._pending_takes)
+        self._admissions.append(admission)
+        self._pending_takes = 0
         self._batch = []
         self.dispatching.value = None
+        return admission
 
     def _unstage_batch(self) -> None:
         taken, self._batch = self._batch, []
@@ -1600,6 +1626,29 @@ class RunManager(Tray):
                 for item in items
             )
 
+    @dataclass(eq=False)
+    class Admission:
+        """One visibly applied batch; ``dur()`` orders its consumption behind enlisted checkpoint writes."""
+
+        _ctx: "RunManager.RunContext"
+        _batch: list[tuple[str, dict[str, Any]]]
+        _takes: int
+        _confirmed: bool = False
+
+        def dur(self) -> None:
+            """Enlist this batch's durable consumption; idempotent until the dispatch settles."""
+            self._ctx._ensure_active()
+            if self._confirmed:
+                return
+            self._confirmed = True
+            manager = self._ctx._manager
+            while manager._admissions and manager._admissions[0]._confirmed:
+                admission = manager._admissions.pop(0)
+                if admission._takes:
+                    manager.confirmedTakes.value += admission._takes
+                else:
+                    manager.batchApplied.value = True
+
     @dataclass(frozen=True, eq=False)
     class RunContext:
         trigger: str
@@ -1691,10 +1740,10 @@ class RunManager(Tray):
             if self._manager._run_live is not self:
                 raise RuntimeError("this run has already settled")
 
-        def applied(self) -> None:
-            """Durably confirms the current batch: clears the dispatch record so settle consumes it."""
+        def applied(self) -> "RunManager.Admission":
+            """Clear the visible dispatch immediately; call the returned admission's ``dur()`` after enlisting its checkpoint."""
             self._ensure_active()
-            self._manager._applied()
+            return self._manager._applied(self)
 
 
 class RunManagerNamespace(TrayMapNamespace):
@@ -1709,6 +1758,8 @@ class RunManagerNamespace(TrayMapNamespace):
                 "(RunManager.Thread) to host @run_manager"
             )
         self._mint: "asyncio.Task[Any] | None" = None
+        self._loading: "asyncio.Task[None] | None" = None
+        self._loaded = False
         self._mounted: list[RunManager] = []
         api.state["runs"] = []
         api.state["status"] = "ready"
@@ -1725,7 +1776,103 @@ class RunManagerNamespace(TrayMapNamespace):
         tray, _minted = await self._machine(run_id, principal)
         return tray
 
+    async def _load_existing(self) -> None:
+        if self._loaded:
+            return
+        if self._loading is None:
+            self._loading = self._api.create_task(self._restore_existing())
+        await asyncio.shield(self._loading)
+
+    async def _restore_existing(self) -> None:
+        durability = self._durability()
+        try:
+            rows = await durability.store.list(
+                durability.ns, durability.id, durability.epoch, tray_ns=self._spec.name
+            )
+        except FenceLost:
+            self._api.abort()
+            raise
+        for _, run_id, marked, doc in rows:
+            await self._obtain(run_id, create=False, row=(marked, doc))
+        self._loaded = True
+
+    async def maybe_sync(
+        self,
+        *,
+        pending_inputs: Iterable[dict[str, Any]],
+        has_pending_tasks: bool,
+        principal: Any,
+        meta: Any = None,
+    ) -> bool:
+        """Import external pending work into an inactive run; return whether its state changed."""
+        if type(has_pending_tasks) is not bool:
+            raise TypeError("has_pending_tasks must be a bool")
+        requests = tuple(pending_inputs)
+        if requests:
+            RunManager.InputRequired(requests)
+        await self._load_existing()
+        if self._mint is not None:
+            await asyncio.shield(self._mint)
+        tray = self.live()
+        if tray is None:
+            if not requests and not has_pending_tasks:
+                return False
+            tray, _ = await self._machine(self._api.domain.token_hex(16), principal)
+        tray._check_run_owner(principal)
+        if (
+            tray._in_flight()
+            or tray._intake
+            or tray._batch
+            or tray.queue.value
+            or tray.steerQueue.value
+            or tray.nextDispatch.value is not None
+            or tray._staged_rewind is not None
+            or tray.outcome.value is not None
+        ):
+            return False
+        previous = {r["id"]: r for r in tray.inputRequests.value or ()}
+        synchronized = []
+        for request in requests:
+            item = {k: v for k, v in request.items() if k not in ("response", "meta")}
+            old = previous.get(request["id"], {})
+            if "response" in old:
+                item.update(response=old["response"], meta=old.get("meta"))
+            synchronized.append(item)
+        if requests:
+            if (
+                tray.inputRequests.value == synchronized
+                and tray.halted.value is None
+                and tray.error.value is None
+            ):
+                return False
+            tray.inputRequests.value = synchronized
+            tray._input_requests = [
+                {k: v for k, v in r.items() if k not in ("response", "meta")}
+                for r in synchronized
+            ]
+            tray._input_answers = {
+                r["id"]: (r["response"], r.get("meta"))
+                for r in synchronized if "response" in r
+            }
+            tray.halted.value = None
+            tray.error.value = None
+            tray._publish_status()
+            tray._schedule(tray._advance)
+            return True
+        changed = bool(tray.inputRequests.value)
+        tray._clear_input()
+        if has_pending_tasks:
+            tray._dispatch("stop-continue", [], root_meta=meta)
+            tray.batchApplied.value = True
+            tray.dispatching.value = None
+            tray._publish_status()
+            return True
+        if changed:
+            tray._publish_status()
+        return changed
+
     async def _machine(self, run_id: str, principal: Any) -> tuple[RunManager, bool]:
+        await self._load_existing()
         # 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, or raise its failure.

{harness_sdk_python-0.36.2.dist-info → harness_sdk_python-0.36.4.dist-info}/METADATA

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.36.2
+Version: 0.36.4
 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.1
-Requires-Dist: statewire<0.18,>=0.17.2
+Requires-Dist: pinned<0.16,>=0.15.2
+Requires-Dist: statewire<0.18,>=0.17.4
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.36.2.dist-info → harness_sdk_python-0.36.4.dist-info}/RECORD

@@ -1,11 +1,12 @@
 harness_sdk/__init__.py,sha256=zoABjY3ixYzh5YyWtHQKs3MjphMJrwklzV0LOacDA5c,1740
 harness_sdk/checkpoints.py,sha256=4Jv0eyjGoUv9lC6ZZSOpHmZ4j_vMFkFPSxFcrpJ-NTQ,28195
-harness_sdk/deepagents.py,sha256=3iWadYjG-Yv0fli4x8s5n3jOTs11JHS2cK6tj8foyvk,14520
+harness_sdk/deepagents.py,sha256=ilrz32oEhvoiKkKGPGbmsTmjZvWomhg1roxPMMxSCXk,15745
 harness_sdk/fenced_postgres.py,sha256=hbbrMR1WaqrHTNgd4wFrXfRrzQFGnyim-c8nZXgwWp4,13235
+harness_sdk/langgraph.py,sha256=0yT3l7wWrxjG4SOMQQAjre-EK2JBndryAmBg-k8NESg,2680
 harness_sdk/linear_thread.py,sha256=laDRXKLFsMlyWS4snqNAM6t38wO26gevLWXRNivhHSM,1810
 harness_sdk/protocol.py,sha256=4diqaWeYIVEKRjyKkqzeMMHJb7zrOQCvPkjQzkeIku8,140
-harness_sdk/run_manager.py,sha256=gcd4nfXJ8ssD-v0yP2FF4WsUE-xWzgrChdG4RQV_UqA,82165
+harness_sdk/run_manager.py,sha256=wKhMHscBUtAT4qddHC6_mftGO3u9T3HivlUgwfmJCAk,88062
 harness_sdk/voice.py,sha256=bRloaKSS1d0mFvfIM4Bhp50ADBK_7GpdarGvmDBubjg,32370
-harness_sdk_python-0.36.2.dist-info/METADATA,sha256=aJPyd884khPDjcycx20eL8ZrLZSw1voyTkoIEajTCKs,2488
-harness_sdk_python-0.36.2.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
-harness_sdk_python-0.36.2.dist-info/RECORD,,
+harness_sdk_python-0.36.4.dist-info/METADATA,sha256=s8ACi-pVJMePCNS9BK75tFL7umZJxu0YYo7B7sI3sCA,2488
+harness_sdk_python-0.36.4.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+harness_sdk_python-0.36.4.dist-info/RECORD,,