harness-sdk-python 0.8.0__tar.gz → 0.10.0__tar.gz

{harness_sdk_python-0.8.0 → harness_sdk_python-0.10.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.8.0
+Version: 0.10.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

harness_sdk_python-0.10.0/examples/runs_app.py

@@ -0,0 +1,203 @@
+"""Minimal RunManager backend: a no-tools deepagents agent behind statewire.
+
+Run from python/harness-sdk-python:
+
+    uv run --extra deepagents uvicorn examples.runs_app:app --port 8000
+
+State is ``{"messages": [...]}`` in langchain format; rewind truncates the
+list. Threads live at /threads/{id}: ``GET .../stream`` (SSE), ``.../ws``,
+``POST .../commands``, and ``POST .../assistant-transport/api/chat``.
+
+Set PINBOARD_URL, PINBOARD_TOKEN, and ADVERTISE_URL to register with a
+pinboard control plane instead of local placement.
+"""
+
+import asyncio
+import contextlib
+import os
+from typing import Any
+
+from fastapi import FastAPI
+from langchain_core.messages import AIMessage, HumanMessage, ToolMessage
+from pinned import PinnedHost
+from statewire import AssistantTransport, command, plain
+from statewire.langgraph import append_langgraph_event
+
+from harness_sdk import RunManager, linear_thread
+
+
+def select_model() -> str:
+    if model := os.environ.get("DEEPAGENTS_MODEL"):
+        return model
+    if os.environ.get("OPENAI_API_KEY"):
+        return "openai:gpt-4o"
+    return "anthropic:claude-opus-4-8"
+
+
+def build_agent() -> Any:
+    from deepagents import create_deep_agent
+    from langgraph.checkpoint.memory import MemorySaver
+
+    return create_deep_agent(
+        model=select_model(),
+        tools=[],
+        system_prompt="You are a concise assistant.",
+        checkpointer=MemorySaver(),
+    )
+
+
+def to_langchain(message: dict[str, Any]) -> Any:
+    match message["type"]:
+        case "human":
+            return HumanMessage(id=message["id"], content=message["content"])
+        case "ai":
+            return AIMessage(
+                id=message["id"],
+                content=message["content"],
+                tool_calls=message.get("tool_calls") or [],
+            )
+        case "tool":
+            return ToolMessage(
+                id=message["id"],
+                content=message["content"],
+                tool_call_id=message["tool_call_id"],
+            )
+        case other:
+            raise ValueError(f"unsupported message type: {other}")
+
+
+def user_text(message: dict[str, Any]) -> str:
+    return "\n\n".join(
+        part["text"] for part in message["parts"] if part["type"] == "text"
+    )
+
+
+class RunsHost(AssistantTransport):
+    assistant_transport_protocol = "assistant-transport"
+
+    async def lifespan(self):
+        self.agent = build_agent()
+        self.state = {"messages": []}
+        self.thread = linear_thread(
+            messages=lambda: plain(self.state["messages"]),
+            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_child_id(self, parent_id: str) -> str | None:
+        return await self.thread.get_message_child_id(parent_id)
+
+    async def run(self, ctx: RunManager.RunContext) -> Any:
+        if ctx.has_rollback:
+            self.truncate(ctx.rollback_to)
+        pending = list(ctx.messages)
+        while True:
+            for message in pending:
+                self.state["messages"].append(
+                    {
+                        "id": message["id"],
+                        "type": "human",
+                        "content": user_text(message),
+                    }
+                )
+            ctx.ack()
+            outcome = await self.stream_turn(ctx)
+            if outcome is not None:
+                return outcome
+            pending = list(ctx.steering.take())
+            if not pending:
+                return RunManager.Complete()
+
+    def truncate(self, message_id: str | None) -> None:
+        messages = self.state["messages"]
+        keep = 0
+        if message_id is not None:
+            items = plain(messages)
+            keep = 1 + next(
+                index for index, m in enumerate(items) if m["id"] == message_id
+            )
+        while len(plain(messages)) > keep:
+            messages.pop()
+
+    async def stream_turn(self, ctx: RunManager.RunContext) -> Any:
+        history = [to_langchain(m) for m in plain(self.state["messages"])]
+        self.turn += 1
+        stream = self.agent.astream(
+            {"messages": history},
+            config={"configurable": {"thread_id": f"{self.id}:{self.turn}"}},
+            stream_mode=["messages", "updates"],
+            subgraphs=True,
+        )
+        iterator = stream.__aiter__()
+        stop = asyncio.ensure_future(ctx.stop_requested.wait())
+        try:
+            while True:
+                step = asyncio.ensure_future(anext(iterator))
+                await asyncio.wait({step, stop}, return_when=asyncio.FIRST_COMPLETED)
+                if stop.done() and not step.done():
+                    step.cancel()
+                    with contextlib.suppress(asyncio.CancelledError):
+                        await step
+                    return RunManager.Stop(dispatch_queue=True)
+                try:
+                    namespace, mode, payload = await step
+                except StopAsyncIteration:
+                    return None
+                append_langgraph_event(self.state, namespace, mode, payload)
+        finally:
+            stop.cancel()
+            with contextlib.suppress(Exception):
+                await stream.aclose()
+
+    @command("run/enqueue")
+    async def run_enqueue(self, params, *, ctx):
+        return await self.runs.enqueue(params, ack=ctx.ack)
+
+    @command("run/steer")
+    async def run_steer(self, params, *, ctx):
+        return await self.runs.steer(params, ack=ctx.ack)
+
+    @command("run/dequeue")
+    async def run_dequeue(self, params):
+        return await self.runs.dequeue(params)
+
+    @command("run/edit")
+    async def run_edit(self, params, *, ctx):
+        return await self.runs.edit(params, ack=ctx.ack)
+
+    @command("run/reload")
+    async def run_reload(self, params, *, ctx):
+        return await self.runs.reload(params, ack=ctx.ack)
+
+    @command("run/stop")
+    async def run_stop(self, params=None, *, ctx):
+        return await self.runs.stop(params, ack=ctx.ack)
+
+    @command("run/continue")
+    async def run_continue(self, params=None, *, ctx):
+        return await self.runs.continue_run(ack=ctx.ack)
+
+    @command("run/input")
+    async def run_input(self, params):
+        return await self.runs.input(params)
+
+
+_pinboard_url = os.environ.get("PINBOARD_URL")
+router = PinnedHost(
+    RunsHost,
+    pinboard_url=_pinboard_url,
+    token=os.environ.get("PINBOARD_TOKEN"),
+    advertise_url=os.environ.get("ADVERTISE_URL"),
+    namespace="/threads" if _pinboard_url else None,
+)
+app = FastAPI(lifespan=router.lifespan)
+app.include_router(router, prefix="/threads")

{harness_sdk_python-0.8.0 → harness_sdk_python-0.10.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "harness-sdk-python"
-version = "0.8.0"
+version = "0.10.0"
 description = "RunManager: the harness-sdk runs subsystem for Python Statewire hosts"
 readme = "README.md"
 license = "MIT"

{harness_sdk_python-0.8.0 → harness_sdk_python-0.10.0}/src/harness_sdk/linear_thread.py

@@ -21,10 +21,6 @@ class LinearThread:
                 }
         return None
 
-    async def get_leaf_message_id(self) -> str | None:
-        items = self._messages()
-        return items[-1].get("id") if items else None
-
     async def get_message_child_id(self, parent_id: str) -> str | None:
         """The id of the first non-tool message after parent_id; None when parent_id is unknown or only tools follow."""
         items = self._messages()