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

{harness_sdk_python-0.15.0 → harness_sdk_python-0.16.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.16.0}/PKG-INFO

@@ -1,11 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.15.0
+Version: 0.16.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.11,>=0.10.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.16.0}/examples/runs_app.py

@@ -19,7 +19,7 @@ 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 statewire import Statewire, command, plain
 from statewire.langgraph import append_langgraph_event
 
@@ -189,13 +189,12 @@ class RunsHost(Statewire):
         return await self.runs.input(params)
 
 
-_pinboard_url = os.environ.get("PINBOARD_URL")
-router = PinnedHost(
-    RunsHost,
-    pinboard_url=_pinboard_url,
+worker = PinnedWorker(
+    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.16.0}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.15.0"
+version = "0.16.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.10.0,<0.11"]
 
 [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.16.0/src/harness_sdk/__init__.py

@@ -0,0 +1,11 @@
+from .linear_thread import linear_thread
+from .run_manager import RunManager
+from .run_trays import RunManagerNamespace, RunTray, run_manager
+
+__all__ = [
+    "RunManager",
+    "RunManagerNamespace",
+    "RunTray",
+    "linear_thread",
+    "run_manager",
+]

{harness_sdk_python-0.15.0 → harness_sdk_python-0.16.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)
 

{harness_sdk_python-0.15.0 → harness_sdk_python-0.16.0}/src/harness_sdk/run_manager.py

@@ -36,11 +36,14 @@ staged dispatch, whose command already settled at its admission write.
 """
 
 import asyncio
+import logging
 from dataclasses import dataclass, field
 from typing import Any, Awaitable, Callable, Iterable, Protocol
 
 from statewire import StatewireReject
-from statewire.state import plain
+from statewire import plain
+
+logger = logging.getLogger(__name__)
 
 _ABSENT: Any = object()
 _PARKED: Any = object()
@@ -590,6 +593,11 @@ class RunManager:
             if isinstance(exc, StatewireReject):
                 self._freeze(exc.message, exc.payload)
             else:
+                logger.exception(
+                    "run %r crashed in %s",
+                    self._entry().get("runId"),
+                    getattr(self._run, "__qualname__", repr(self._run)),
+                )
                 self._freeze(message)
             self._drain()
             return

harness_sdk_python-0.16.0/src/harness_sdk/run_trays.py

@@ -0,0 +1,363 @@
+"""RunTray + ``@run_manager``: the durable run dispatch queue of a Statewire host.
+
+A ``RunTray`` instance is one thread's run lane: sends queue (or steer into
+the live run), the head of the queue moves into the ``dispatching`` outbox
+and the handler runs it, the outcome settles into the next dispatch —
+``input-required`` and un-dispatched ``error``/``stop`` park in
+``nextDispatch`` until ``input``/``continueRun`` release them. Every move
+records the dispatch before clearing its source in one storage segment, so
+a crash replays the in-flight dispatch (at least once, never lost); a steer
+dispatch carries the steer lane it drained as ``messages``. ``epoch`` counts
+the lane's dispatches; ``stop(epoch=...)`` rejects any other value, so a
+replayed stop never ends a later dispatch. In-flight run progress rides
+``ctx.state``: graph runs bind ``{thread_id, checkpoint_ns, runId}`` and
+resume from the checkpointer's latest checkpoint on redelivery; non-graph
+handlers use ``ctx.state`` itself as the checkpoint.
+``@run_manager`` declares the tray on a Statewire host, registers
+the run commands routed by thread id, and mounts each tray's state into
+``state["runs"]``.
+"""
+
+from typing import Any, Callable, Coroutine
+
+from pinned.trays import Tray, TrayDescriptor, TrayMapNamespace, inbox
+from pinned.traystore import persistent, persistent_outbox, persistent_queue
+from statepatch import observable
+from statewire import command, plain
+
+_OUTCOMES = ("complete", "input-required", "error", "stop")
+
+
+class RunTray(Tray):
+    queue = persistent_queue()
+    steerQueue = persistent_queue()
+    dispatching = persistent_outbox()
+    nextDispatch = persistent(None)
+    epoch = persistent(0)
+    isStopping = observable(False)
+
+    state = observable(
+        {
+            "id": None,
+            "queue": queue,
+            "steerQueue": steerQueue,
+            "dispatching": dispatching,
+            "nextDispatch": nextDispatch,
+            "epoch": epoch,
+            "isStopping": isStopping,
+        }
+    )
+
+    async def lifecycle(self):
+        self.state["id"] = self.id
+        yield
+
+    def items(self):
+        """Each dispatch: outbox record then source clear land in one atomic
+        segment, in that order, so a mid-segment crash duplicates instead of
+        losing (the outbox bump is the durable attempt counter); the
+        outcome settles ack + continuation in another segment."""
+        while True:
+            recorded = self.dispatching.value
+            if recorded is not None:
+                item = recorded["item"]
+                self.dispatching.dispatch(item)  # redelivery bumps the attempt
+                # a crash between the record and the source clear leaves both
+                if self.queue.value and self.queue.peek() == item:
+                    self.queue.popleft()
+                for message in item.get("messages", ()):
+                    if self.steerQueue.value and self.steerQueue.peek() == message:
+                        self.steerQueue.popleft()
+                pending = self.nextDispatch.value
+                if pending is not None and {
+                    k: v for k, v in pending.items() if k != "ready"
+                } == item:
+                    self.nextDispatch.value = None
+            else:
+                pending = self.nextDispatch.value
+                if pending is not None:
+                    # an unreleased continuation parks the whole lane
+                    if not pending.get("ready"):
+                        return
+                    item = {k: v for k, v in pending.items() if k != "ready"}
+                    self._dispatch_fresh(item)
+                    self.nextDispatch.value = None
+                elif self.queue.value:
+                    item = self.queue.peek()
+                    self._dispatch_fresh(item)
+                    self.queue.popleft()
+                elif self.steerQueue.value:
+                    item = {"trigger": "steer", "messages": self.steerQueue.value}
+                    self._dispatch_fresh(item)
+                    self.steerQueue.value = []
+                else:
+                    return
+            yield item
+
+    def _dispatch_fresh(self, item: Any) -> None:
+        self.epoch.value = self.epoch.value + 1
+        self.dispatching.dispatch(item)
+
+    async def _run_item(
+        self, item: Any, fn: Callable[..., Coroutine[Any, Any, Any]]
+    ) -> Any:
+        outcome = await super()._run_item(item, self._validated(fn))
+        self._settle(outcome)
+        return outcome
+
+    def _make_ctx(self) -> Any:
+        ctx = super()._make_ctx()
+        if self.isStopping.value:
+            ctx.cancelled.set()
+        return ctx
+
+    def _record_delivery(self) -> int:
+        return self.dispatching.attempt  # the outbox dispatch() already counted durably
+
+    def _ack_delivery(self) -> None:
+        pass  # the outbox ack in _settle is the durable reset
+
+    def _validated(
+        self, fn: Callable[..., Coroutine[Any, Any, Any]]
+    ) -> Callable[..., Coroutine[Any, Any, Any]]:
+        # an invalid outcome aborts the instance with the outbox unacked;
+        # the dispatch redelivers on the next activation
+        async def run(item: Any, ctx: Any) -> Any:
+            outcome = plain(await fn(item, ctx))
+            if outcome is None:
+                return {"type": "complete"}
+            kind = outcome.get("type") if isinstance(outcome, dict) else None
+            if kind not in _OUTCOMES:
+                raise TypeError(
+                    f"run handler must return an outcome dict with type in {_OUTCOMES}, got {outcome!r}"
+                )
+            if kind == "input-required" and not isinstance(
+                outcome.get("requests"), list
+            ):
+                raise TypeError(
+                    f"input-required outcome must carry a 'requests' list, got {outcome!r}"
+                )
+            return outcome
+
+        return run
+
+    def _settle(self, outcome: Any) -> None:
+        if outcome is None:  # user cancel consumed the item without a result
+            outcome = {"type": "complete"}
+        kind = outcome["type"]
+        if kind == "input-required":
+            self.nextDispatch.value = {
+                "trigger": "input-resume",
+                "requests": outcome["requests"],
+                "responses": None,
+                "ready": False,
+            }
+        elif kind in ("error", "stop") and not outcome.get("dispatchQueue", False):
+            self.nextDispatch.value = {
+                "trigger": "error-continue" if kind == "error" else "stop-continue",
+                "ready": False,
+            }
+        self.isStopping.value = False
+        self._clear_dispatch_state()  # the run's progress dies with its ack
+        self.dispatching.ack()
+
+    # ─── Verbs ──────────────────────────────────────────────
+
+    def _known(self, message_id: str) -> bool:
+        recorded = self.dispatching.value
+        entries = [*self.queue.value, *self.steerQueue.value]
+        if recorded is not None:
+            entries.append(recorded["item"])
+            entries.extend(recorded["item"].get("messages", ()))
+        return any(
+            isinstance(entry, dict) and entry.get("id") == message_id
+            for entry in entries
+        )
+
+    def _admit(self, entry: dict[str, Any], *, steer: bool) -> None:
+        if steer and (self.dispatching.value is not None or self._active is not None):
+            self.steerQueue.append({k: v for k, v in entry.items() if k != "trigger"})
+        elif steer:
+            self.queue.insert(0, entry)
+        else:
+            self.queue.append(entry)
+        self.kick()
+
+    @inbox
+    def send(
+        self, message_id: str, parts: list[Any], behavior: str = "queue"
+    ) -> None:
+        if behavior not in ("queue", "steer"):
+            raise ValueError(f"unknown send behavior {behavior!r}")
+        if self._known(message_id):
+            return
+        entry = {"id": message_id, "trigger": "message-send", "parts": parts}
+        self._admit(entry, steer=behavior == "steer")
+
+    @inbox
+    def edit(self, message_id: str, message: dict[str, Any]) -> None:
+        self._admit(
+            {"id": message_id, "trigger": "message-edit", "message": message},
+            steer=False,
+        )
+
+    @inbox
+    def reload(self, message_id: str, params: Any = None) -> None:
+        self._admit(
+            {"id": message_id, "trigger": "message-reload", "params": params},
+            steer=False,
+        )
+
+    @inbox
+    def dequeue(self, message_id: str) -> None:
+        self.queue.remove(message_id)
+
+    @inbox
+    def queue_steer(self, message_id: str) -> None:
+        entry = next(
+            (e for e in self.queue.value if e.get("id") == message_id), None
+        )
+        if entry is None:
+            raise KeyError(f"no queued message {message_id!r}")
+        self.queue.remove(message_id)
+        self._admit(entry, steer=True)
+
+    @inbox
+    def stop(self, epoch: int | None = None) -> None:
+        if self.dispatching.value is None and self._active is None:
+            raise RuntimeError("no active run to stop")
+        if epoch is not None and epoch != self.epoch.value:
+            raise RuntimeError(
+                f"epoch {epoch} does not name the live dispatch ({self.epoch.value})"
+            )
+        self.isStopping.value = True
+        if self._active is not None:
+            self._active.cancelled.set()
+
+    @inbox
+    def input(self, params: Any) -> None:
+        pending = self.nextDispatch.value
+        if pending is None or pending.get("trigger") != "input-resume":
+            raise RuntimeError("no input requested")
+        if pending.get("ready"):
+            raise RuntimeError("input already provided")
+        self.nextDispatch.value = {**pending, "responses": params, "ready": True}
+        self.kick()
+
+    @inbox
+    def continue_run(self) -> None:
+        pending = self.nextDispatch.value
+        if pending is None:
+            raise RuntimeError("nothing to continue")
+        if pending.get("trigger") == "input-resume":
+            raise RuntimeError("run is awaiting input; answer with input()")
+        self.nextDispatch.value = {**pending, "ready": True}
+        self.kick()
+
+
+class RunManagerNamespace(TrayMapNamespace):
+    """The RunManager: run verbs routed by thread id onto tray instances.
+
+    Every verb awaits its admission receipt, so the command's verdict follows
+    the admission's durability."""
+
+    async def enqueue(
+        self, thread_id: str, message_id: str, parts: list[Any]
+    ) -> None:
+        await (await self.get_or_create(thread_id)).send(message_id, parts)
+
+    async def steer(self, thread_id: str, message_id: str, parts: list[Any]) -> None:
+        await (await self.get_or_create(thread_id)).send(
+            message_id, parts, behavior="steer"
+        )
+
+    async def dequeue(self, thread_id: str, message_id: str) -> None:
+        await (await self.get(thread_id)).dequeue(message_id)
+
+    async def edit(
+        self, thread_id: str, message_id: str, message: dict[str, Any]
+    ) -> None:
+        await (await self.get_or_create(thread_id)).edit(message_id, message)
+
+    async def reload(self, thread_id: str, message_id: str, params: Any = None) -> None:
+        await (await self.get_or_create(thread_id)).reload(message_id, params)
+
+    async def stop(self, thread_id: str, epoch: int | None = None) -> None:
+        await (await self.get(thread_id)).stop(epoch)
+
+    async def continue_run(self, thread_id: str) -> None:
+        await (await self.get(thread_id)).continue_run()
+
+    async def input(self, thread_id: str, params: Any) -> None:
+        await (await self.get(thread_id)).input(params)
+
+
+async def _mount_runs(api: Any, id: str, tray: RunTray):
+    if "runs" not in api.state:
+        api.state["runs"] = []
+    api.state["runs"].append(tray.state)
+    yield
+    runs = plain(api.state["runs"])
+    index = next(i for i, entry in enumerate(runs) if entry.get("id") == id)
+    api.state["runs"].pop(index)
+
+
+def _commands(name: str) -> dict[str, Any]:
+    async def enqueue(self, threadId: str, message: dict[str, Any]) -> None:
+        await getattr(self, name).enqueue(threadId, message["messageId"], message["parts"])
+
+    async def steer(self, threadId: str, message: dict[str, Any]) -> None:
+        await getattr(self, name).steer(threadId, message["messageId"], message["parts"])
+
+    async def dequeue(self, threadId: str, messageId: str) -> None:
+        await getattr(self, name).dequeue(threadId, messageId)
+
+    async def edit(self, threadId: str, messageId: str, message: dict[str, Any]) -> None:
+        await getattr(self, name).edit(threadId, messageId, message)
+
+    async def reload(self, threadId: str, messageId: str, params: Any = None) -> None:
+        await getattr(self, name).reload(threadId, messageId, params)
+
+    async def stop(self, threadId: str, epoch: int | None = None) -> None:
+        await getattr(self, name).stop(threadId, epoch)
+
+    async def continueRun(self, threadId: str) -> None:
+        await getattr(self, name).continue_run(threadId)
+
+    async def input(self, threadId: str, params: Any) -> None:
+        await getattr(self, name).input(threadId, params)
+
+    commands = {
+        fn.__name__: command(fn)
+        for fn in (enqueue, steer, dequeue, edit, reload, stop, continueRun, input)
+    }
+    for fn in commands.values():
+        fn._run_manager_command = name
+    return commands
+
+
+class RunManagerDescriptor(TrayDescriptor):
+    namespace_cls = RunManagerNamespace
+
+    def __init__(self, handler: Callable[..., Coroutine[Any, Any, Any]]) -> None:
+        super().__init__(RunTray, handler, always_open=True)
+        self._on_activate.append(_mount_runs)
+
+    def __set_name__(self, owner: type, name: str) -> None:
+        super().__set_name__(owner, name)
+        for verb, fn in _commands(name).items():
+            existing = getattr(owner, verb, None)
+            if existing is not None and getattr(
+                existing, "_run_manager_command", None
+            ) != name:
+                raise TypeError(
+                    f"{owner.__name__}.{verb} collides with a @run_manager command"
+                )
+            setattr(owner, verb, fn)
+
+
+def run_manager(fn: Callable[..., Coroutine[Any, Any, Any]]) -> Any:
+    """``@tray.map(RunTray)`` plus the interaction layer: registers the run
+    commands routed by thread id and mounts each run's state into
+    ``state["runs"]``. The descriptor is the RunManager."""
+    return RunManagerDescriptor(fn)