harness-sdk-python 0.38.0__tar.gz → 0.39.1__tar.gz

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/.gitignore

@@ -2,6 +2,7 @@ node_modules
 .next
 dist
 dist-test
+coverage
 .wrangler
 .DS_Store
 .env

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.38.0
+Version: 0.39.1
 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.2
-Requires-Dist: statewire<0.20,>=0.19.0
+Requires-Dist: pinned<0.17,>=0.16.0
+Requires-Dist: statewire<0.23,>=0.21.2
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'
@@ -57,7 +57,10 @@ class RunsHost(Statewire):
     @command("run/enqueue")
     async def run_enqueue(self, params, *, ctx, auth_result):
         return await self.run.enqueue(
-            params, applied=ctx.applied, auth_result=auth_result
+            params,
+            applied=ctx.applied,
+            auth_result=auth_result,
+            version=ctx.version,
         )
 ```
 

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/README.md

@@ -35,7 +35,10 @@ class RunsHost(Statewire):
     @command("run/enqueue")
     async def run_enqueue(self, params, *, ctx, auth_result):
         return await self.run.enqueue(
-            params, applied=ctx.applied, auth_result=auth_result
+            params,
+            applied=ctx.applied,
+            auth_result=auth_result,
+            version=ctx.version,
         )
 ```
 

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/examples/runs_app.py

@@ -158,13 +158,19 @@ class RunsHost(Statewire):
     @command("run/enqueue")
     async def run_enqueue(self, params, *, ctx, auth_result):
         return await self.run.enqueue(
-            params, applied=ctx.applied, auth_result=auth_result
+            params,
+            applied=ctx.applied,
+            auth_result=auth_result,
+            version=ctx.version,
         )
 
     @command("run/steer")
     async def run_steer(self, params, *, ctx, auth_result):
         return await self.run.steer(
-            params, applied=ctx.applied, auth_result=auth_result
+            params,
+            applied=ctx.applied,
+            auth_result=auth_result,
+            version=ctx.version,
         )
 
     @command("run/dequeue")

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.38.0"
+version = "0.39.1"
 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.19.0,<0.20", "pinned>=0.15.2,<0.16"]
+dependencies = ["statewire>=0.21.2,<0.23", "pinned>=0.16.0,<0.17"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/src/harness_sdk/deepagents.py

@@ -10,6 +10,7 @@ main run; its rows persist under ``checkpoint_ns == ns``.
 from typing import Any, Callable
 
 from statepatch import plain
+from statewire import StatewireReject
 
 from .checkpoints import (
     CheckpointIndex,
@@ -32,8 +33,45 @@ def deepagents_role(message: dict[str, Any]) -> str:
         raise ValueError(f"unsupported message type: {message['type']!r}") from exc
 
 
-def _user_text(message: dict[str, Any]) -> str:
-    return "\n\n".join(part["text"] for part in message["parts"] if part["type"] == "text")
+def _file_block(part: dict[str, Any]) -> dict[str, Any]:
+    url, media_type = part["url"], part["mediaType"]
+    if url.startswith("data:"):
+        header, comma, data = url.removeprefix("data:").partition(",")
+        media_type, *params = header.split(";")
+        if not comma or not media_type or params[-1:] != ["base64"]:
+            raise ValueError("file data URLs must be data:<type>;base64,<data>")
+        source = {"base64": data, "mime_type": media_type}
+    else:
+        raise ValueError("file URLs must be inline data:<type>;base64,<data> URLs")
+    kind = media_type.split("/", 1)[0]
+    block = {"type": kind if kind in ("image", "audio", "video") else "file", **source}
+    if "filename" in part:
+        block["extras"] = {"filename": part["filename"]}
+    return block
+
+
+def _user_content(message: dict[str, Any]) -> str | list[dict[str, Any]]:
+    parts = message["parts"]
+    if all(part["type"] == "text" for part in parts):
+        return "\n\n".join(part["text"] for part in parts)
+    return [{"type": "text", "text": part["text"]} if part["type"] == "text" else _file_block(part) for part in parts]
+
+
+def check_file_parts(message: dict[str, Any]) -> dict[str, Any]:
+    """``prepare_message`` hook: a file part ``_file_block`` cannot carry rejects ``invalid-message``."""
+    parts = message.get("parts")
+    for part in parts if isinstance(parts, list) else ():
+        if (
+            isinstance(part, dict)
+            and part.get("type") == "file"
+            and isinstance(part.get("url"), str)
+            and isinstance(part.get("mediaType"), str)
+        ):
+            try:
+                _file_block(part)
+            except ValueError as exc:
+                raise StatewireReject(str(exc), payload={"reason": "invalid-message"}) from exc
+    return message
 
 
 def _ns_of(namespace: tuple[str, ...]) -> str:
@@ -123,19 +161,25 @@ class DeepagentsThread:
         """The dispatch's langgraph (payload, config): forks at the anchor when the batch does not extend the head."""
         self.abandon_turn()
         config = self.config()
-        if ctx.resume:
-            return None, config
         thread = self.tree.thread(MAIN_NS)
         if ctx.trigger == "input-resume":
             from langgraph.types import Command
 
+            tool_ids = {p.get("toolInvocationId") for p in plain(self.tree.get(MAIN_NS, thread.head)["parts"])}
+            missing = [r["toolCallId"] for r, _response, _meta in ctx.input_outcomes if r["toolCallId"] not in tool_ids]
+            if missing:
+                raise KeyError(f"head {thread.head!r} holds no tool part for {missing!r}")
+            self._mount(MAIN_NS, thread.head)
+            if ctx.resume:
+                return None, config
             decisions = [
                 {"type": "approve"} if response and response.get("decision") == "approve" else {"type": "reject"}
                 for _request, response, _meta in ctx.input_outcomes
             ]
             self._admission = ctx.applied()
-            self._assemblers.pop(MAIN_NS, None)
             return Command(resume={"decisions": decisions}), config
+        if ctx.resume:
+            return None, config
         if ctx.has_rollback:
             parent = ctx.rollback_to
         elif ctx.messages:
@@ -156,7 +200,7 @@ class DeepagentsThread:
 
         turn: list[Any] = [*plan.replay]
         for message in ctx.messages:
-            turn.append(HumanMessage(id=message["id"], content=_user_text(message)))
+            turn.append(HumanMessage(id=message["id"], content=_user_content(message)))
             self._append_user(message, parent)
             parent = message["id"]
         self.tree.set_head(MAIN_NS, parent)
@@ -196,7 +240,7 @@ class DeepagentsThread:
         turn = []
         for message in messages:
             self._append_user(message, thread.head)
-            turn.append(HumanMessage(id=message["id"], content=_user_text(message)))
+            turn.append(HumanMessage(id=message["id"], content=_user_content(message)))
         self._thread_state(MAIN_NS)
         self._assemblers.pop(MAIN_NS, None)
         self._changed()
@@ -233,10 +277,14 @@ class DeepagentsThread:
                 "metadata": {"provider": {"ids": []}},
             }
             self.tree.add(ns, value)
-            self._touched.add((ns, message_id))
-            assembler = self._assemblers[ns] = PartsAssembler(lambda: self.tree.get(ns, message_id))
-            self._thread_state(ns, status="streaming")
-            self._changed()
+            assembler = self._mount(ns, message_id)
+        return assembler
+
+    def _mount(self, ns: str, message_id: str) -> PartsAssembler:
+        self._touched.add((ns, message_id))
+        assembler = self._assemblers[ns] = PartsAssembler(lambda: self.tree.get(ns, message_id))
+        self._thread_state(ns, status="streaming")
+        self._changed()
         return assembler
 
     def _fold_id(self, assembler: PartsAssembler, langchain_id: str | None) -> None:
@@ -317,14 +365,16 @@ class DeepagentsThread:
                 self.interrupt = {"toolCallId": tool_id}
                 self._changed()
 
-    def _finish(self, ns: str) -> None:
+    def _finish(self, ns: str, outcome: dict[str, Any] | None = None) -> None:
         assembler = self._assemblers.pop(ns, None)
         if assembler is not None:
             assembler.finish()
+            for key, value in (outcome or {}).items():
+                assembler.message[key] = value
         self._thread_state(ns, status="idle")
 
-    async def ingest_turn(self, *, refetch: bool = False) -> None:
-        """Ingest the turn's captured root checkpoint, persist the touched harness messages, and settle streaming state."""
+    async def ingest_turn(self, *, refetch: bool = False, outcome: dict[str, Any] | None = None) -> None:
+        """Ingest the turn's captured root checkpoint, persist the touched harness messages, and settle streaming state; ``outcome`` lands on the turn's open replies."""
         captured, self._captured = self._captured, None
         if refetch:
             await self._thread.ingest_latest()
@@ -336,7 +386,7 @@ class DeepagentsThread:
             self._confirm_admission()
         for ns in self._turn_namespaces():
             if self.interrupt is None or ns != MAIN_NS:
-                self._finish(ns)
+                self._finish(ns, outcome)
         for ns in self.tree.threads:
             if ns != MAIN_NS and _root_of(ns) not in self._subagents:
                 self._thread_state(ns, status="idle")
@@ -354,14 +404,14 @@ class DeepagentsThread:
             raise ValueError(f"subagent namespace must be a root namespace other than {MAIN_NS!r}, got {ns!r}")
         if ns in self._subagents:
             raise RuntimeError(f"subagent {ns!r} is already running")
+        config = {"configurable": {"thread_id": f"{self._thread_id}/{ns}"}}
+        payload = {"messages": [HumanMessage(id=message["id"], content=_user_content(message))]}
         thread = self.tree.thread(ns)
         self.tree.add(ns, {**message, "parentId": thread.head})
         self._touched.add((ns, message["id"]))
         self._thread_state(ns, status="streaming")
         self._subagents.add(ns)
         self._changed()
-        config = {"configurable": {"thread_id": f"{self._thread_id}/{ns}"}}
-        payload = {"messages": [HumanMessage(id=message["id"], content=_user_text(message))]}
         try:
             async for namespace, mode, event in self._agent.astream(
                 payload, config=config, stream_mode=["messages", "updates", "checkpoints"], subgraphs=True
@@ -416,14 +466,19 @@ class DeepagentsThread:
         await self._persist()
         self._changed()
 
-    def abandon_turn(self) -> None:
-        """Discard a stream capture and any fork planned for the abandoned turn."""
+    async def fail_turn(self, error: str) -> None:
+        """Abandon the turn with its open replies marked ``failed`` and persist the touched messages."""
+        self.abandon_turn({"status": "failed", "error": error})
+        await self._persist()
+
+    def abandon_turn(self, outcome: dict[str, Any] | None = None) -> None:
+        """Discard a stream capture and any fork planned for the abandoned turn; ``outcome`` lands on the turn's open replies."""
         self._captured = None
         self._admission = None
         self._input_checkpoint_seen = False
         self.interrupt = None
         for ns in self._turn_namespaces():
-            self._finish(ns)
+            self._finish(ns, outcome)
         self._thread.abandon_plan()
 
 

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/src/harness_sdk/deepagents_host.py

@@ -14,10 +14,10 @@ from typing import Any
 from statewire import Statewire, command
 
 from .checkpoints import CheckpointIndex
-from .deepagents import DeepagentsThread
+from .deepagents import DeepagentsThread, check_file_parts
 from .messages import MAIN_NS
 from .protocol import HARNESS_PROTOCOL
-from .run_manager import RunManager, run_manager
+from .run_manager import RunManager, error_of, run_manager
 from .voice import VoiceTurnCommitDeferred, end_voice, set_voice_mic, start_voice, voice_client_departed
 from .voice_thread import VoiceThread, is_ephemeral
 from .wire import HarnessMessages
@@ -26,6 +26,11 @@ logger = logging.getLogger(__name__)
 _HALTED = ("stopped", "error")
 
 
+def _interrupted(ctx: RunManager.RunContext) -> dict[str, Any]:
+    reason = ctx.stop_reason
+    return {"status": "interrupted"} if reason is None else {"status": "interrupted", "stopReason": reason}
+
+
 class DeepagentsHost(VoiceThread, HarnessMessages, Statewire):
     """One thread: ``build_agent(checkpointer)`` returns the compiled deepagents graph."""
 
@@ -128,15 +133,20 @@ class DeepagentsHost(VoiceThread, HarnessMessages, Statewire):
 
     # ─── Runs ───────────────────────────────────────────────
 
-    @run_manager(capabilities=("rewind",))
+    @run_manager(capabilities=("rewind", "files"), prepare_message=check_file_parts)
     async def run(self, ctx: RunManager.RunContext) -> Any:
         payload, config = await self.messages.plan_turn(ctx)
         while True:
             try:
                 outcome = await self._stream_turn(ctx, payload, config)
-                await self.messages.ingest_turn(refetch=outcome is not None)
+                await self.messages.ingest_turn(
+                    refetch=outcome is not None, outcome=None if outcome is None else _interrupted(ctx)
+                )
+            except Exception as exc:
+                await self.messages.fail_turn(error_of(exc)["message"])
+                raise
             except BaseException:
-                self.messages.abandon_turn()
+                self.messages.abandon_turn(_interrupted(ctx))
                 raise
             if outcome is not None:
                 return outcome
@@ -179,11 +189,11 @@ class DeepagentsHost(VoiceThread, HarnessMessages, Statewire):
 
     @command("run/enqueue")
     async def run_enqueue(self, params, *, ctx, auth_result):
-        return await self.run.enqueue(params, applied=ctx.applied, auth_result=auth_result)
+        return await self.run.enqueue(params, applied=ctx.applied, auth_result=auth_result, version=ctx.version)
 
     @command("run/steer")
     async def run_steer(self, params, *, ctx, auth_result):
-        return await self.run.steer(params, applied=ctx.applied, auth_result=auth_result)
+        return await self.run.steer(params, applied=ctx.applied, auth_result=auth_result, version=ctx.version)
 
     @command("run/dequeue")
     async def run_dequeue(self, params, *, auth_result):

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/src/harness_sdk/parts.py

@@ -73,6 +73,7 @@ class PartsAssembler:
         text = text_of(content)
         if text:
             self._append_text("text", text, chunk_id)
+        self._cite(chunk)
         for tool_chunk in getattr(chunk, "tool_call_chunks", None) or []:
             key = (chunk_id, tool_chunk.get("index") or 0)
             tool_id = tool_chunk.get("id") or self._chunk_tools.get(key)
@@ -120,6 +121,18 @@ class PartsAssembler:
             elif call.get("args"):
                 self.parts[index]["input"] = call["args"]
 
+    def _cite(self, chunk: Any) -> None:
+        cited = {part["url"] for part in plain(self.parts) if part["type"] == "source"}
+        for block in chunk.content_blocks:
+            if block["type"] != "text":
+                continue
+            for note in block.get("annotations", []):
+                url = note.get("url") if note["type"] == "citation" else None
+                if url and url not in cited:
+                    cited.add(url)
+                    title = note.get("title")
+                    self.parts.append({"type": "source", "url": url, **({"title": title} if title else {})})
+
     def tool_result(self, message: Any) -> None:
         tool_id = getattr(message, "tool_call_id", None)
         index = self._index(tool_id) if tool_id else None

{harness_sdk_python-0.38.0 → harness_sdk_python-0.39.1}/src/harness_sdk/protocol.py

@@ -3,7 +3,7 @@ from statewire.protocol import Subprotocol
 
 HARNESS_PROTOCOL = Statewire.Protocol(
     "harness-sdk",
-    version="2026-09-30",
+    version="2026-11-02",
     min_version="2026-09-30",
     subprotocols=(
         Subprotocol("interest", record="ephemeral"),