harness-sdk-python 0.15.0__tar.gz → 0.17.0__tar.gz

{harness_sdk_python-0.15.0 → harness_sdk_python-0.17.0}/.gitignore

@@ -22,5 +22,6 @@ __pycache__
 /doc_*.md
 apps/docs/.docs
 /.agentdoc/
+/.deepsec/
 .vercel
 .env*

{harness_sdk_python-0.15.0 → harness_sdk_python-0.17.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.15.0
+Version: 0.17.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: statewire<0.9,>=0.8.1
+Requires-Dist: pinned<0.12,>=0.11.0
+Requires-Dist: statewire<0.10,>=0.9.0
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.15.0 → harness_sdk_python-0.17.0}/examples/runs_app.py

@@ -19,11 +19,12 @@ from typing import Any
 
 from fastapi import FastAPI
 from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
-from pinned import PinnedHost
+from pinned import PinnedHost, PinnedWorker
+from pinned.testing import MemoryStateStore
 from statewire import Statewire, command, plain
 from statewire.langgraph import append_langgraph_event
 
-from harness_sdk import RunManager, linear_thread
+from harness_sdk import RunManager, linear_thread, run_manager
 
 
 def select_model() -> str:
@@ -81,19 +82,15 @@ class RunsHost(Statewire):
             role=lambda m: "user" if m["type"] == "human" else "assistant",
         )
         self.turn = 0
-        self.runs = RunManager(
-            state=self.state,
-            run=self.run,
-            thread=self.thread,
-            create_task=self.create_task,
-            schedule=self.schedule,
-            capabilities=("rewind",),
-        )
         yield
 
+    async def get_message_meta(self, message_id: str | None) -> dict[str, Any] | None:
+        return await self.thread.get_message_meta(message_id)
+
     async def get_message_child_id(self, parent_id: str) -> str | None:
         return await self.thread.get_message_child_id(parent_id)
 
+    @run_manager(capabilities=("rewind",))
     async def run(self, ctx: RunManager.RunContext) -> Any:
         if ctx.has_rollback:
             self.truncate(ctx.rollback_to)
@@ -158,44 +155,44 @@ class RunsHost(Statewire):
 
     @command("run/enqueue")
     async def run_enqueue(self, params, *, ctx):
-        return await self.runs.enqueue(params, applied=ctx.applied)
+        return await (await self.run.get()).enqueue(params, applied=ctx.applied)
 
     @command("run/steer")
     async def run_steer(self, params, *, ctx):
-        return await self.runs.steer(params, applied=ctx.applied)
+        return await (await self.run.get()).steer(params, applied=ctx.applied)
 
     @command("run/dequeue")
     async def run_dequeue(self, params):
-        return await self.runs.dequeue(params)
+        return await (await self.run.get()).dequeue(params)
 
     @command("run/edit")
     async def run_edit(self, params, *, ctx):
-        return await self.runs.edit(params, applied=ctx.applied)
+        return await (await self.run.get()).edit(params, applied=ctx.applied)
 
     @command("run/reload")
     async def run_reload(self, params, *, ctx):
-        return await self.runs.reload(params, applied=ctx.applied)
+        return await (await self.run.get()).reload(params, applied=ctx.applied)
 
     @command("run/stop")
     async def run_stop(self, params=None, *, ctx):
-        return await self.runs.stop(params, applied=ctx.applied)
+        return await (await self.run.get()).stop(params, applied=ctx.applied)
 
     @command("run/continue")
     async def run_continue(self, params=None, *, ctx):
-        return await self.runs.continue_run(applied=ctx.applied)
+        return await (await self.run.get()).continue_run(applied=ctx.applied)
 
     @command("run/input")
     async def run_input(self, params):
-        return await self.runs.input(params)
+        return await (await self.run.get()).input(params)
 
 
-_pinboard_url = os.environ.get("PINBOARD_URL")
-router = PinnedHost(
-    RunsHost,
-    pinboard_url=_pinboard_url,
+worker = PinnedWorker(
+    state_store=MemoryStateStore(),
+    pinboard_url=os.environ.get("PINBOARD_URL"),
     token=os.environ.get("PINBOARD_TOKEN"),
     advertise_url=os.environ.get("ADVERTISE_URL"),
-    namespace="/threads" if _pinboard_url else None,
 )
+router = PinnedHost(RunsHost, worker=worker, namespace="/threads")
 app = FastAPI(lifespan=router.lifespan)
-app.include_router(router, prefix="/threads")
+app.include_router(worker)
+app.include_router(router)

{harness_sdk_python-0.15.0 → harness_sdk_python-0.17.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.15.0"
+version = "0.17.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.8.1,<0.9"]
+dependencies = ["statewire>=0.9.0,<0.10", "pinned>=0.11.0,<0.12"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]
@@ -22,6 +22,7 @@ Repository = "https://github.com/assistant-ui/harness-sdk"
 
 [tool.uv.sources]
 statewire = { workspace = true }
+pinned = { workspace = true }
 
 [build-system]
 requires = ["hatchling"]

harness_sdk_python-0.17.0/src/harness_sdk/__init__.py

@@ -0,0 +1,9 @@
+from .linear_thread import linear_thread
+from .run_manager import RunManager, RunManagerDescriptor, run_manager
+
+__all__ = [
+    "RunManager",
+    "RunManagerDescriptor",
+    "linear_thread",
+    "run_manager",
+]

{harness_sdk_python-0.15.0 → harness_sdk_python-0.17.0}/src/harness_sdk/fenced_postgres.py

@@ -86,6 +86,21 @@ def _bump_sql(fence_table: str) -> SQL:
     ).format(t=Identifier(fence_table))
 
 
+def _adopt_sql(fence_table: str) -> SQL:
+    return SQL(
+        "INSERT INTO {t} (thread_id, epoch) VALUES (%s, %s) "
+        "ON CONFLICT (thread_id) DO UPDATE SET epoch = excluded.epoch "
+        "WHERE {t}.epoch <= excluded.epoch "
+        "RETURNING epoch"
+    ).format(t=Identifier(fence_table))
+
+
+def _require_epoch(epoch: int) -> int:
+    if isinstance(epoch, bool) or not isinstance(epoch, int) or epoch < 0:
+        raise ValueError(f"epoch must be a non-negative integer, got {epoch!r}")
+    return epoch
+
+
 def _assert_sql(fence_table: str) -> SQL:
     return SQL("SELECT {}(%s, %s)").format(Identifier(_assert_fn(fence_table)))
 
@@ -125,30 +140,43 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
         self.fence_table = _require_fence_table(fence_table)
         self.on_fence_lost = on_fence_lost
         self._fence_lost_notified = False
+        self._fence_lost_terminal = False
 
     @staticmethod
-    async def _validate_and_bump(
+    async def _ensure_fence_objects(
         cur: "AsyncCursor[DictRow]",
-        thread_id: str,
         *,
         create_fence_table: bool,
         fence_table: str,
-    ) -> int:
+    ) -> None:
         if create_fence_table:
             await cur.execute(_create_sql(fence_table))
             await cur.execute(_create_fn_sql(fence_table))
-        else:
-            await cur.execute(
-                "SELECT to_regclass(%s) AS tbl, to_regprocedure(%s) AS fn",
-                (fence_table, f"{_assert_fn(fence_table)}(text, bigint)"),
+            return
+        await cur.execute(
+            "SELECT to_regclass(%s) AS tbl, to_regprocedure(%s) AS fn",
+            (fence_table, f"{_assert_fn(fence_table)}(text, bigint)"),
+        )
+        row = await cur.fetchone()
+        if row["tbl"] is None:
+            raise _missing_fence_error(f"fence table {fence_table!r}")
+        if row["fn"] is None:
+            raise _missing_fence_error(
+                f"fence function {_assert_fn(fence_table)!r}"
             )
-            row = await cur.fetchone()
-            if row["tbl"] is None:
-                raise _missing_fence_error(f"fence table {fence_table!r}")
-            if row["fn"] is None:
-                raise _missing_fence_error(
-                    f"fence function {_assert_fn(fence_table)!r}"
-                )
+
+    @classmethod
+    async def _validate_and_bump(
+        cls,
+        cur: "AsyncCursor[DictRow]",
+        thread_id: str,
+        *,
+        create_fence_table: bool,
+        fence_table: str,
+    ) -> int:
+        await cls._ensure_fence_objects(
+            cur, create_fence_table=create_fence_table, fence_table=fence_table
+        )
         await cur.execute(_bump_sql(fence_table), (thread_id,))
         return (await cur.fetchone())["epoch"]
 
@@ -218,7 +246,54 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
             on_fence_lost=on_fence_lost,
         )
 
+    @classmethod
+    async def adopt(
+        cls,
+        conn: _ainternal.Conn,
+        thread_id: str,
+        epoch: int,
+        *,
+        create_fence_table: bool,
+        pipe: AsyncPipeline | None = None,
+        serde: SerializerProtocol | None = None,
+        fence_table: str = DEFAULT_FENCE_TABLE,
+        on_fence_lost: Callable[[], None] | None = None,
+    ) -> "AsyncFencedPostgresSaver":
+        """Install a caller-owned epoch (the placement epoch) into the fence row, so one epoch fences the tray store and the checkpoints; a newer stored epoch raises ``FenceLost``."""
+        _require_thread_id(thread_id)
+        _require_epoch(epoch)
+        _require_fence_table(fence_table)
+        async with _ainternal.get_connection(conn) as c:
+            if c.info.transaction_status != TransactionStatus.IDLE:
+                raise RuntimeError(
+                    "adopt requires a connection with no transaction in progress"
+                )
+            async with (
+                c.transaction(),
+                c.cursor(binary=True, row_factory=dict_row) as cur,
+            ):
+                await cls._ensure_fence_objects(
+                    cur,
+                    create_fence_table=create_fence_table,
+                    fence_table=fence_table,
+                )
+                await cur.execute(_adopt_sql(fence_table), (thread_id, epoch))
+                if await cur.fetchone() is None:
+                    raise FenceLost(thread_id, epoch)
+        if pipe is not None:
+            await pipe.sync()
+        return cls(
+            conn,
+            thread_id,
+            epoch,
+            pipe=pipe,
+            serde=serde,
+            fence_table=fence_table,
+            on_fence_lost=on_fence_lost,
+        )
+
     def _fence_lost(self) -> FenceLost:
+        self._fence_lost_terminal = True
         if self.on_fence_lost is not None and not self._fence_lost_notified:
             self._fence_lost_notified = True
             self.on_fence_lost()
@@ -262,6 +337,12 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
             row = await cur.fetchone()
         return row is None or row["epoch"] != self.epoch
 
+    # Fence loss is terminal: the epoch can never become current again, so
+    # later writes fail before serializing or round-tripping to Postgres.
+    def _raise_if_fence_lost(self) -> None:
+        if self._fence_lost_terminal:
+            raise FenceLost(self.thread_id, self.epoch)
+
     async def aput(
         self,
         config: RunnableConfig,
@@ -269,6 +350,7 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
         metadata: Any,
         new_versions: Any,
     ) -> RunnableConfig:
+        self._raise_if_fence_lost()
         self._bound_to(config["configurable"]["thread_id"])
         return await super().aput(config, checkpoint, metadata, new_versions)
 
@@ -279,6 +361,7 @@ class AsyncFencedPostgresSaver(AsyncPostgresSaver):
         task_id: str,
         task_path: str = "",
     ) -> None:
+        self._raise_if_fence_lost()
         self._bound_to(config["configurable"]["thread_id"])
         await super().aput_writes(config, writes, task_id, task_path)