harness-sdk-python 0.39.0__tar.gz → 0.39.2__tar.gz

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.39.0
+Version: 0.39.2
 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.17,>=0.16.0
-Requires-Dist: statewire<0.23,>=0.21.1
+Requires-Dist: statewire<0.24,>=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.39.0 → harness_sdk_python-0.39.2}/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.39.0 → harness_sdk_python-0.39.2}/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.39.0 → harness_sdk_python-0.39.2}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.39.0"
+version = "0.39.2"
 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.21.1,<0.23", "pinned>=0.16.0,<0.17"]
+dependencies = ["statewire>=0.21.2,<0.24", "pinned>=0.16.0,<0.17"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/src/harness_sdk/deepagents_host.py

@@ -189,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.39.0 → harness_sdk_python-0.39.2}/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"),

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/src/harness_sdk/run_manager.py

@@ -88,6 +88,7 @@ MAX_MESSAGE_BYTES = 1 << 20
 MAX_RUN_IDS = 4096
 
 _ABSENT: Any = object()
+_LEAF_SEND_VERSION = "2026-11-02"
 _PARKED: Any = object()
 
 _CAPABILITIES = frozenset(
@@ -310,6 +311,7 @@ class _Send:
     thread_empty: bool = False
     minted: bool = False
     principal: Any = None
+    version: str | None = None
     future: "asyncio.Future[Any]" = field(default_factory=_future)
 
 
@@ -1252,7 +1254,12 @@ class RunManager(Tray):
         if len(self._batch) + len(steer) >= self.max_queued:
             raise _reject("queue-full", f"queue is full ({self.max_queued} messages)")
         staged = self._stamped(e.message, e.meta)
-        if not self._batch and not steer and e.anchor is not _ABSENT:
+        if (
+            not self._batch
+            and not steer
+            and e.anchor is not _ABSENT
+            and not self._stale_anchor(e)
+        ):
             staged["~parent"] = e.anchor
         self._batch.extend(("steerQueue", item) for item in steer)
         self._batch.append((e.lane, staged))
@@ -1380,6 +1387,15 @@ class RunManager(Tray):
         if not e.anchor_meta["onActiveBranch"]:
             raise _reject("wrong-anchor", f"anchor {e.anchor} is off the active branch")
 
+    def _stale_anchor(self, e: _Send) -> bool:
+        return (
+            e.version is not None
+            and e.version >= _LEAF_SEND_VERSION
+            and e.anchor_meta is not None
+            and not e.anchor_meta["isLeaf"]
+            and e.anchor not in self.dispatchedIds.value
+        )
+
     # ─── Queue mutations ────────────────────────────────────
 
     def _stamped(self, message: dict[str, Any], meta: Any) -> dict[str, Any]:
@@ -2106,6 +2122,7 @@ class RunManagerNamespace(TrayMapNamespace):
         meta: Any,
         applied: Callable[[], None],
         auth_result: Any,
+        version: str | None,
     ) -> Any:
         cls: type[RunManager] = self._spec.tray_cls  # type: ignore[assignment]
         if not isinstance(params, dict):
@@ -2151,6 +2168,7 @@ class RunManagerNamespace(TrayMapNamespace):
                     anchor_meta=anchor_meta,
                     thread_empty=thread_empty,
                     principal=auth_result,
+                    version=version,
                 )
             )
         message = _validated_message(cls, params["message"])
@@ -2171,6 +2189,7 @@ class RunManagerNamespace(TrayMapNamespace):
                 thread_empty=thread_empty,
                 minted=minted,
                 principal=auth_result,
+                version=version,
             )
         )
 
@@ -2181,8 +2200,9 @@ class RunManagerNamespace(TrayMapNamespace):
         meta: Any = None,
         applied: Callable[[], None],
         auth_result: Any,
+        version: str | None = None,
     ) -> Any:
-        return await self._send("queue", params, meta, applied, auth_result)
+        return await self._send("queue", params, meta, applied, auth_result, version)
 
     async def steer(
         self,
@@ -2191,8 +2211,9 @@ class RunManagerNamespace(TrayMapNamespace):
         meta: Any = None,
         applied: Callable[[], None],
         auth_result: Any,
+        version: str | None = None,
     ) -> Any:
-        return await self._send("steerQueue", params, meta, applied, auth_result)
+        return await self._send("steerQueue", params, meta, applied, auth_result, version)
 
     async def dequeue(self, params: Any, *, auth_result: Any) -> None:
         message_id = params.get("messageId") if isinstance(params, dict) else None

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/tests/run_helpers.py

@@ -8,9 +8,11 @@ from uuid import uuid4
 from pinned import PinnedWorker
 from pinned.testing import MemoryStateStore
 from statewire import Statewire, command
+from statewire.protocol import VERSION, Offer, Protocol, VersionRange
+from statewire.protocol import headers as protocol_headers
 from statewire_helpers import apply_ops, attach, post_frame, statewire_client, stream_of
 
-from harness_sdk import RunManager, run_manager
+from harness_sdk import HARNESS_PROTOCOL, RunManager, run_manager
 
 
 @dataclass
@@ -53,6 +55,11 @@ class Script:
         assert self.calls.empty(), "unexpected start() invocation"
 
 
+def negotiating(version: str) -> dict[str, str]:
+    """Attach headers offering only ``version`` of the test host's protocol."""
+    return protocol_headers(VersionRange(VERSION), (Offer("default", VersionRange(version)),))
+
+
 def _meta(params: Any) -> Any:
     """Test hosts stamp meta from a wire `meta` param; real hosts stamp their own."""
     return params.pop("meta", None) if isinstance(params, dict) else None
@@ -65,8 +72,16 @@ def make_host(
     prepare_message=None,
     prepare_input=None,
     authorize=None,
+    version=HARNESS_PROTOCOL.version,
 ):
     class Host(Statewire):
+        protocols = (
+            Protocol(
+                "default",
+                version=HARNESS_PROTOCOL.version,
+                min_version=HARNESS_PROTOCOL.min_version,
+            ),
+        )
         live: "Host | None" = None
 
         async def lifespan(self):
@@ -89,13 +104,21 @@ def make_host(
         @command("run/enqueue")
         async def run_enqueue(self, params, *, ctx, auth_result):
             return await self.runs.enqueue(
-                params, meta=_meta(params), applied=ctx.applied, auth_result=auth_result
+                params,
+                meta=_meta(params),
+                applied=ctx.applied,
+                auth_result=auth_result,
+                version=version,
             )
 
         @command("run/steer")
         async def run_steer(self, params, *, ctx, auth_result):
             return await self.runs.steer(
-                params, meta=_meta(params), applied=ctx.applied, auth_result=auth_result
+                params,
+                meta=_meta(params),
+                applied=ctx.applied,
+                auth_result=auth_result,
+                version=version,
             )
 
         @command("run/dequeue")
@@ -315,7 +338,9 @@ async def run_host(
     store=None,
     authorize=None,
     headers=None,
+    version=HARNESS_PROTOCOL.version,
 ):
+    """``version`` is the negotiated protocol date the host passes to sends; None passes none."""
     host_cls = make_host(
         script,
         capabilities=capabilities,
@@ -323,6 +348,7 @@ async def run_host(
         prepare_message=prepare_message,
         prepare_input=prepare_input,
         authorize=authorize,
+        version=version,
     )
     worker = PinnedWorker(
         state_store=store if store is not None else MemoryStateStore()
@@ -330,7 +356,14 @@ async def run_host(
     async with statewire_client(host_cls, worker=worker) as (app, client):
         # Fresh client id per session, like a production client.
         client_id = f"c-{uuid4().hex[:8]}"
-        async with stream_of(app, client_id=client_id, headers=headers) as stream:
+        async with stream_of(
+            app,
+            client_id=client_id,
+            headers={
+                **negotiating(version or HARNESS_PROTOCOL.min_version),
+                **(headers or {}),
+            },
+        ) as stream:
             snapshot = await stream.next_event()
             driver = RunDriver(client, stream, app, client_id=client_id)
             driver.envelopes.append(snapshot)

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/tests/test_branch_anchor.py

@@ -1,3 +1,4 @@
+import pytest
 from run_helpers import (
     Script,
     add,
@@ -14,6 +15,19 @@ from run_helpers import (
 
 from harness_sdk import RunManager
 
+BRANCHING = "2026-09-30"
+
+
+def two_turns():
+    script = Script()
+    script.thread.update(
+        {
+            "u1": {"parentId": None, "role": "user", "isLeaf": False, "onActiveBranch": True},
+            "a1": {"parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": True},
+        }
+    )
+    return script
+
 
 async def test_add_requires_a_run_id():
     script = Script()
@@ -208,15 +222,28 @@ async def test_post_reload_sends_anchor_on_the_reload_targets_parent():
         await drv.wait_status("running")
 
 
-async def test_a_dispatching_send_carries_its_anchor_as_the_parent():
-    script = Script()
-    script.thread.update(
-        {
-            "u1": {"parentId": None, "role": "user", "isLeaf": False, "onActiveBranch": True},
-            "a1": {"parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": True},
-        }
-    )
+async def test_a_dispatching_send_carries_its_leaf_anchor_as_the_parent():
+    script = two_turns()
     async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1", anchor="a1"))
+        call = await script.next_call()
+        assert call.ctx.messages == ({**msg("m1"), "parentId": "a1"},)
+
+
+async def test_a_stale_anchor_appends_at_the_leaf():
+    script = two_turns()
+    async with run_host(script) as (drv, host):
+        drv.post("run/steer", add("m1", anchor="u1"))
+        call = await script.next_call()
+        assert call.ctx.messages == (msg("m1"),)
+        await drv.wait(lambda s: run_of(s)["dispatching"] is not None)
+        assert drv.run["dispatching"]["messages"] == [msg("m1")]
+
+
+@pytest.mark.parametrize("version", [BRANCHING, None])
+async def test_a_stale_anchor_branches_under_2026_09_30_or_an_unknown_version(version):
+    script = two_turns()
+    async with run_host(script, version=version) as (drv, host):
         drv.post("run/enqueue", add("m1", anchor="u1"))
         call = await script.next_call()
         assert call.ctx.messages == ({**msg("m1"), "parentId": "u1"},)
@@ -229,6 +256,62 @@ async def test_a_dispatching_send_carries_its_anchor_as_the_parent():
         assert queued.ctx.messages == (msg("m2"),)
 
 
+async def test_off_branch_and_unknown_anchors_reject_under_2026_09_30():
+    script = two_turns()
+    script.thread["old"] = {
+        "parentId": "u1", "role": "assistant", "isLeaf": True, "onActiveBranch": False
+    }
+    async with run_host(script, version=BRANCHING) as (drv, host):
+        assert_rejected(
+            await drv.command("run/enqueue", add("m1", anchor="old"), terminal=False),
+            "wrong-anchor",
+        )
+        assert_rejected(
+            await drv.command("run/enqueue", add("m1", anchor="zz"), terminal=False),
+            "unknown-id",
+        )
+        script.no_call()
+
+
+async def test_a_dispatched_anchor_stays_the_parent_after_an_error():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        drv.post("run/enqueue", add("m1"))
+        call = await script.next_call()
+        call.applied()
+        script.thread.update(
+            {
+                "m1": {"parentId": None, "role": "user", "isLeaf": False, "onActiveBranch": True},
+                "a1": {"parentId": "m1", "role": "assistant", "isLeaf": True, "onActiveBranch": True},
+            }
+        )
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        drv.post("run/enqueue", add("m2", anchor="m1"))
+        retry = await script.next_call()
+        assert retry.ctx.messages == ({**msg("m2"), "parentId": "m1"},)
+
+
+async def test_edit_and_reload_anchor_at_a_non_leaf_parent():
+    script = two_turns()
+    script.thread["a0"] = {
+        "parentId": None, "role": "assistant", "isLeaf": False, "onActiveBranch": True
+    }
+    script.thread["u1"] = {**script.thread["u1"], "parentId": "a0"}
+    async with run_host(script, capabilities=("rewind",)) as (drv, host):
+        drv.post("run/edit", edit_params("u1", msg("u2"), anchor="a0"))
+        edit = await script.next_call()
+        assert edit.ctx.rollback_to == "a0"
+        assert edit.ctx.messages == (msg("u2"),)
+        edit.applied()
+        edit.finish(RunManager.Complete())
+        await drv.wait_status("ready")
+        drv.post("run/reload", reload_params("a1", anchor="u1"))
+        reload = await script.next_call()
+        assert reload.ctx.trigger == "message-reload"
+        assert reload.ctx.rollback_to == "u1"
+
+
 async def test_a_message_parent_id_is_rejected():
     script = Script()
     async with run_host(script) as (drv, host):

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/tests/test_deepagents_thread.py

@@ -15,6 +15,7 @@ from langgraph.checkpoint.memory import InMemorySaver
 from pinned import PinnedWorker
 from pinned.testing import MemoryStateStore
 from run_helpers import _statement, add, edit_params, msg
+from statewire.protocol import VERSION, Offer, VersionRange, headers as protocol_headers
 from statewire_helpers import apply_ops, post_frame, statewire_client, stream_of
 from voice_helpers import NEGOTIATION, VoiceDriver
 
@@ -334,3 +335,29 @@ async def test_host_send_from_a_switched_branch_grows_under_its_leaf():
             assert all(w[:2] == ["u1", old_leaf] for w in windows)
             assert window(drv)[2:] == ["u3", drv.replica["threads"]["main"]["headId"]]
             assert next(m for m in drv.mounted() if m["id"] == "u3")["parentId"] == old_leaf
+
+
+@pytest.mark.parametrize(("version", "appends"), [("2026-11-02", True), ("2026-09-30", False)])
+async def test_host_stale_on_branch_send_appends_at_the_leaf_from_2026_11_02(version, appends):
+    """A send anchored at a committed non-leaf message on the active branch appends at the
+    leaf for a 2026-11-02 client and branches for a 2026-09-30 one, via ``ctx.version``."""
+
+    class Fresh(Host):
+        checkpointer = InMemorySaver()
+        index = MemoryCheckpointIndex()
+
+    headers = protocol_headers(VersionRange(VERSION), (Offer("harness-sdk", VersionRange(version)),))
+    async with statewire_client(Fresh, worker=PinnedWorker(state_store=MemoryStateStore())) as (app, client):
+        async with stream_of(app, client_id="c1", headers=headers) as stream:
+            snapshot = await stream.next_event()
+            drv = VoiceDriver(client, stream, app, client_id="c1", protocol="harness-sdk")
+            apply_ops(drv.replica, copy.deepcopy(snapshot))
+            drv.fold(snapshot)
+            await drv.command("run/enqueue", add("u1", anchor=None))
+            await drv.wait(lambda s: len(window(drv)) == 2 and s["status"] == "ready")
+            leaf = window(drv)[1]
+            await drv.command("run/enqueue", add("u2", anchor="u1"))
+            await drv.wait(lambda s: "u2" in window(drv) and len(window(drv)) >= 3 and s["status"] == "ready")
+            parent = next(m for m in drv.mounted() if m["id"] == "u2")["parentId"]
+            assert parent == (leaf if appends else "u1")
+            assert window(drv)[: (3 if appends else 2)] == (["u1", leaf, "u2"] if appends else ["u1", "u2"])

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/tests/test_threads.py

@@ -9,7 +9,7 @@ from fastapi import FastAPI
 from pinned import PinnedAPI, PinnedHost, PinnedWorker, route
 from pinned.testing import MemoryStateStore
 from run_helpers import RunDriver, Script, add, make_host
-from statewire.protocol import Offer, VersionRange, headers as protocol_headers
+from statewire.protocol import VERSION, Offer, VersionRange, headers as protocol_headers
 from statewire_helpers import CLIENT_ID_HEADER, SSEStream, apply_ops, cmd_on, stream_of
 
 from harness_sdk import RunManager
@@ -20,8 +20,8 @@ from harness_sdk.wire import HarnessMessages, first_user_text
 
 pytestmark = pytest.mark.anyio
 
-NEGOTIATION = protocol_headers(VersionRange(), (Offer("harness-sdk-threads", VersionRange("2026-09-13")),))
-HOST_NEGOTIATION = protocol_headers(VersionRange(), (Offer("harness-sdk", VersionRange()),))
+NEGOTIATION = protocol_headers(VersionRange(VERSION), (Offer("harness-sdk-threads", VersionRange("2026-09-13")),))
+HOST_NEGOTIATION = protocol_headers(VersionRange(VERSION), (Offer("harness-sdk", VersionRange(VERSION)),))
 
 
 class Toucher(PinnedAPI):

{harness_sdk_python-0.39.0 → harness_sdk_python-0.39.2}/tests/voice_helpers.py

@@ -10,7 +10,7 @@ from pinned.testing import MemoryStateStore
 from run_helpers import RunDriver, _statement
 from statewire import Statewire, command
 from statewire.client import apply_ops as client_apply_ops
-from statewire.protocol import Offer, VersionRange, headers as protocol_headers
+from statewire.protocol import VERSION, Offer, VersionRange, headers as protocol_headers
 from statewire_helpers import apply_ops, post_frame, statewire_client, stream_of
 
 from harness_sdk import (
@@ -26,7 +26,7 @@ from harness_sdk import (
 from harness_sdk.messages import MAIN_NS
 from harness_sdk.protocol import HARNESS_PROTOCOL
 
-NEGOTIATION = protocol_headers(VersionRange(), (Offer("harness-sdk", VersionRange()),))
+NEGOTIATION = protocol_headers(VersionRange(VERSION), (Offer("harness-sdk", VersionRange(VERSION)),))
 
 OFFER = "v=0 fake-offer"
 ANSWER = "v=0 fake-answer"