harness-sdk-python 0.5.0__tar.gz → 0.6.0__tar.gz

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: harness-sdk-python
-Version: 0.5.0
+Version: 0.6.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
@@ -23,7 +23,7 @@ class MyHost(Statewire):
         self.runs = RunManager(
             state=self.state,
             start=self._start,
-            get_message_meta=self._get_message_meta,
+            thread=self._thread,
             create_task=self.create_task,
             capabilities=("rewind",),
         )

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/README.md

@@ -11,7 +11,7 @@ class MyHost(Statewire):
         self.runs = RunManager(
             state=self.state,
             start=self._start,
-            get_message_meta=self._get_message_meta,
+            thread=self._thread,
             create_task=self.create_task,
             capabilities=("rewind",),
         )

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/pyproject.toml

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

harness_sdk_python-0.6.0/src/harness_sdk/__init__.py

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

harness_sdk_python-0.6.0/src/harness_sdk/linear_thread.py

@@ -0,0 +1,52 @@
+from dataclasses import dataclass
+from typing import Any, Callable
+
+
+@dataclass(frozen=True)
+class LinearThread:
+    _messages: Callable[[], list[dict[str, Any]]]
+    _role: Callable[[dict[str, Any]], str]
+
+    async def get_message_meta(self, message_id: str | None) -> dict[str, Any] | None:
+        items = self._messages()
+        if message_id is None:
+            return {"isLeaf": not items}
+        for index, message in enumerate(items):
+            if message.get("id") == message_id:
+                return {
+                    "parentId": items[index - 1].get("id") if index > 0 else None,
+                    "role": self._role(message),
+                    "isLeaf": index == len(items) - 1,
+                    "onActiveBranch": True,
+                }
+        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()
+        index = next(
+            (i for i, m in enumerate(items) if m.get("id") == parent_id), None
+        )
+        if index is None:
+            return None
+        for message in items[index + 1 :]:
+            if message.get("type") != "tool":
+                return message.get("id")
+        return None
+
+
+def linear_thread(
+    *,
+    messages: Callable[[], list[dict[str, Any]]],
+    role: Callable[[dict[str, Any]], str],
+) -> LinearThread:
+    """RunManager thread projection over a linear message list: ``messages`` returns the current list, ``role`` maps a message to its role."""
+    if not callable(messages):
+        raise TypeError("messages must be callable")
+    if not callable(role):
+        raise TypeError("role must be callable")
+    return LinearThread(messages, role)

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/src/harness_sdk/run_manager.py

@@ -19,7 +19,7 @@ initiators settle rejected (``stopped`` or the failure).
 import asyncio
 import uuid
 from dataclasses import dataclass, field
-from typing import Any, Awaitable, Callable, Iterable
+from typing import Any, Awaitable, Callable, Iterable, Protocol
 
 from statewire import StatewireReject
 from statewire.state import plain
@@ -51,10 +51,6 @@ _TRIGGERS = (
 
 _DECISIONS = ("approve", "reject", "edit", "respond")
 
-# Called with None it answers for the thread root: isLeaf True iff the thread is empty.
-GetMessageMeta = Callable[[str | None], Awaitable[dict[str, Any] | None]]
-
-
 def _reject(reason: str, message: str) -> StatewireReject:
     return StatewireReject(message, payload={"reason": reason})
 
@@ -143,16 +139,31 @@ class _Effects:
 
 
 class RunManager:
+    class Thread(Protocol):
+        """The thread projection RunManager reads; the host owns the tree."""
+
+        async def get_message_meta(
+            self, message_id: str | None
+        ) -> dict[str, Any] | None:
+            """Meta for a known id ({parentId, role, isLeaf, onActiveBranch}), None for an unknown one; a None id probes the root ({isLeaf})."""
+            ...
+
+        async def get_leaf_message_id(self) -> str | None:
+            """The active branch's current leaf id, None while the thread is empty."""
+            ...
+
     def __init__(
         self,
         *,
         state: Any,
         run: Callable[["RunManager.RunContext"], Awaitable[Any]],
-        get_message_meta: GetMessageMeta,
+        thread: "RunManager.Thread",
         create_task: Callable[[Any], "asyncio.Task[Any]"],
         schedule: Callable[[Callable[[], None]], None],
         capabilities: Iterable[str] = (),
         max_queued: int = 50,
+        prepare_message: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
+        prepare_input: Callable[[dict[str, Any]], dict[str, Any]] | None = None,
     ) -> None:
         caps = frozenset(capabilities)
         unknown = caps - _CAPABILITIES
@@ -164,11 +175,13 @@ class RunManager:
             raise ValueError("max_queued must be >= 1")
         self._state = state
         self._run = run
-        self._get_message_meta = get_message_meta
+        self._thread = thread
         self._capabilities = caps
         self._create_task = create_task
         self._schedule = schedule
         self._max_queued = max_queued
+        self._prepare_message = prepare_message
+        self._prepare_input = prepare_input
         self._task: "asyncio.Task[Any] | None" = None
         self._ctx: "RunManager.RunContext | None" = None
         self._dispatched_ids: tuple[str, ...] = ()
@@ -480,6 +493,7 @@ class RunManager:
                     "run settled without acking its messages (call ctx.ack_messages())"
                 )
         except asyncio.CancelledError:
+            await self._pull_leaf()
             self._settle(ctx)
             self._set_status("stopped")
             self._entry()["runId"] = None
@@ -488,6 +502,7 @@ class RunManager:
             self._idle.set()
             raise  # no drain, no freeze
         except Exception as exc:
+            await self._pull_leaf()
             self._settle(ctx)
             message = str(exc) or type(exc).__name__
             if isinstance(exc, StatewireReject):
@@ -499,6 +514,7 @@ class RunManager:
             self._revert_dispatching()
             self._drain()
             return
+        await self._pull_leaf()
         self._settle(ctx)
         if isinstance(outcome, RunManager.Error):
             error = _reject("run-error", "run ended in error")
@@ -511,6 +527,12 @@ class RunManager:
         self._outcome = outcome
         self._drain()
 
+    async def _pull_leaf(self) -> None:
+        # An unacked end reverts instead of recording a leaf.
+        if self._dispatching or not self._run_acked:
+            return
+        self._entry()["runLeafMessageId"] = await self._thread.get_leaf_message_id()
+
     def _settle(self, ctx: "RunManager.RunContext") -> None:
         if self._ctx is ctx:
             self._ctx = None
@@ -585,7 +607,22 @@ class RunManager:
 
     # ─── Message and placement validation ───────────────────
 
+    def _prepared(
+        self,
+        hook: Callable[[dict[str, Any]], dict[str, Any]] | None,
+        name: str,
+        value: Any,
+    ) -> Any:
+        # Non-dict input skips the hook and falls through to validation's reject.
+        if hook is None or not isinstance(value, dict):
+            return value
+        result = hook(value)
+        if not isinstance(result, dict):
+            raise _reject("invalid-message", f"{name} must return an object")
+        return result
+
     def _validated_message(self, message: Any) -> dict[str, Any]:
+        message = self._prepared(self._prepare_message, "prepare_message", message)
         if not isinstance(message, dict):
             raise _reject("invalid-message", "message must be an object")
         if not isinstance(message.get("id"), str) or message["id"] == "":
@@ -907,7 +944,7 @@ class RunManager:
         anchor_meta: dict[str, Any] | None = None
         thread_empty = False
         if anchor is None:
-            root = await self._get_message_meta(None)
+            root = await self._thread.get_message_meta(None)
             assert root is not None, "get_message_meta(None) must answer for the root"
             thread_empty = bool(root["isLeaf"])
         elif anchor is not _ABSENT:
@@ -915,7 +952,7 @@ class RunManager:
                 raise _reject(
                     "invalid-message", "anchorMessageId must be an id or null"
                 )
-            anchor_meta = await self._get_message_meta(anchor)
+            anchor_meta = await self._thread.get_message_meta(anchor)
         if not has_message:
             message_id = params["messageId"]
             if not isinstance(message_id, str):
@@ -935,7 +972,7 @@ class RunManager:
                 )
             )
         message = self._validated_message(params["message"])
-        source_meta = await self._get_message_meta(message["id"])
+        source_meta = await self._thread.get_message_meta(message["id"])
         return await self._stage(
             _Send(
                 lane,
@@ -984,7 +1021,7 @@ class RunManager:
         source_id = params.get("sourceId") if isinstance(params, dict) else None
         if not isinstance(source_id, str):
             raise _reject("invalid-message", "sourceId must be a string")
-        source_meta = await self._get_message_meta(source_id)
+        source_meta = await self._thread.get_message_meta(source_id)
         if source_meta is None:
             raise _reject("unknown-id", f"message {source_id} is unknown")
         if source_meta["role"] != "user" and "assistant-edit" not in self._capabilities:
@@ -996,7 +1033,7 @@ class RunManager:
         )
         if (
             message["id"] != source_id
-            and await self._get_message_meta(message["id"]) is not None
+            and await self._thread.get_message_meta(message["id"]) is not None
         ):
             raise _reject("duplicate-id", f"message id {message['id']} is already used")
         return await self._stage(_Edit(source_id, source_meta, message, meta, ack))
@@ -1008,13 +1045,13 @@ class RunManager:
         source_id = params.get("sourceId") if isinstance(params, dict) else None
         if not isinstance(source_id, str):
             raise _reject("invalid-message", "sourceId must be a string")
-        source_meta = await self._get_message_meta(source_id)
+        source_meta = await self._thread.get_message_meta(source_id)
         if source_meta is None:
             raise _reject("unknown-id", f"message {source_id} is unknown")
         if source_meta["role"] != "assistant":
             raise _reject("invalid-message", "sourceId must name an assistant message")
         if source_meta["parentId"] is not None:
-            parent = await self._get_message_meta(source_meta["parentId"])
+            parent = await self._thread.get_message_meta(source_meta["parentId"])
             if (
                 parent is not None
                 and parent["role"] == "assistant"
@@ -1049,6 +1086,7 @@ class RunManager:
         return await entry.future
 
     def _validated_response(self, request_type: str, response: Any) -> dict[str, Any]:
+        response = self._prepared(self._prepare_input, "prepare_input", response)
         if not isinstance(response, dict):
             raise _reject("invalid-message", "response must be an object")
         if request_type == "tool-call":
@@ -1230,14 +1268,6 @@ class RunManager:
             self._ensure_active()
             self._manager._ack_messages()
 
-        def set_leaf_message_id(self, message_id: str) -> None:
-            self._ensure_active()
-            if not isinstance(message_id, str) or message_id == "":
-                raise ValueError("message_id must be a non-empty string")
-            if self._manager._dispatching or not self._manager._run_acked:
-                raise RuntimeError("ack_messages must precede set_leaf_message_id")
-            self._manager._entry()["runLeafMessageId"] = message_id
-
         def set_recovery_state(self, value: Any) -> None:
             self._ensure_active()
             record = self._manager._dispatch_record

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/tests/run_helpers.py

@@ -32,6 +32,7 @@ class Script:
     def __init__(self) -> None:
         self.calls: asyncio.Queue[Call] = asyncio.Queue()
         self.thread: dict[str, dict[str, Any]] = {}
+        self.leaf: str | None = None
 
     async def run(self, ctx: RunManager.RunContext) -> Any:
         call = Call(ctx, asyncio.get_running_loop().create_future())
@@ -43,6 +44,9 @@ class Script:
             return {"isLeaf": not self.thread}
         return self.thread.get(message_id)
 
+    async def get_leaf_message_id(self) -> str | None:
+        return self.leaf
+
     async def next_call(self, timeout: float = 5) -> Call:
         return await asyncio.wait_for(self.calls.get(), timeout)
 
@@ -55,7 +59,14 @@ def _meta(params: Any) -> Any:
     return params.pop("meta", None) if isinstance(params, dict) else None
 
 
-def make_host(script: Script, capabilities=(), initial_runs=None, max_queued=50):
+def make_host(
+    script: Script,
+    capabilities=(),
+    initial_runs=None,
+    max_queued=50,
+    prepare_message=None,
+    prepare_input=None,
+):
     class Host(Statewire):
         live: "Host | None" = None
 
@@ -67,11 +78,13 @@ def make_host(script: Script, capabilities=(), initial_runs=None, max_queued=50)
             self.runs = RunManager(
                 state=self.state,
                 run=script.run,
-                get_message_meta=script.get_message_meta,
+                thread=script,
                 create_task=self.create_task,
                 schedule=self.schedule,
                 capabilities=capabilities,
                 max_queued=max_queued,
+                prepare_message=prepare_message,
+                prepare_input=prepare_input,
             )
             yield
 
@@ -218,12 +231,21 @@ class RunDriver:
 
 
 @asynccontextmanager
-async def run_host(script: Script, capabilities=(), initial_runs=None, max_queued=50):
+async def run_host(
+    script: Script,
+    capabilities=(),
+    initial_runs=None,
+    max_queued=50,
+    prepare_message=None,
+    prepare_input=None,
+):
     host_cls = make_host(
         script,
         capabilities=capabilities,
         initial_runs=initial_runs,
         max_queued=max_queued,
+        prepare_message=prepare_message,
+        prepare_input=prepare_input,
     )
     async with statewire_client(host_cls) as (app, client):
         async with stream_of(app) as stream:

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/tests/test_enqueue.py

@@ -301,7 +301,7 @@ async def test_max_queued_below_one_rejects_at_construction():
         RunManager(
             state={},
             run=script.run,
-            get_message_meta=script.get_message_meta,
+            thread=script,
             create_task=lambda coro: None,
             schedule=lambda fn: None,
             max_queued=0,

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/tests/test_facade.py

@@ -22,7 +22,7 @@ def make_facade_host(script: Script):
             self.runs = RunManager(
                 state=self.state,
                 run=script.run,
-                get_message_meta=script.get_message_meta,
+                thread=script,
                 create_task=self.create_task,
                 schedule=self.schedule,
             )

harness_sdk_python-0.6.0/tests/test_linear_thread.py

@@ -0,0 +1,122 @@
+"""Contract: ``linear_thread`` projects a linear message list for RunManager —
+``get_message_meta(None)`` probes the root (isLeaf iff empty), a known id gets
+``{parentId, role, isLeaf, onActiveBranch}`` chained by list order, an unknown
+id gets ``None``; ``get_leaf_message_id`` is the last message's id; the extra
+``get_message_child_id`` resolves the first non-tool successor."""
+
+import pytest
+
+from harness_sdk import linear_thread
+
+
+def _role(message):
+    return "user" if message["type"] == "human" else "assistant"
+
+
+def _thread_for(messages):
+    return linear_thread(messages=lambda: messages, role=_role)
+
+
+THREAD = [
+    {"id": "u1", "type": "human"},
+    {"id": "a1", "type": "ai"},
+    {"id": "u2", "type": "human"},
+]
+
+
+async def test_root_probe_reports_empty_thread():
+    thread = _thread_for([])
+    assert await thread.get_message_meta(None) == {"isLeaf": True}
+
+
+async def test_root_probe_reports_nonempty_thread():
+    thread = _thread_for(THREAD)
+    assert await thread.get_message_meta(None) == {"isLeaf": False}
+
+
+async def test_first_message_has_no_parent():
+    thread = _thread_for(THREAD)
+    assert await thread.get_message_meta("u1") == {
+        "parentId": None,
+        "role": "user",
+        "isLeaf": False,
+        "onActiveBranch": True,
+    }
+
+
+async def test_middle_message_chains_to_predecessor():
+    thread = _thread_for(THREAD)
+    assert await thread.get_message_meta("a1") == {
+        "parentId": "u1",
+        "role": "assistant",
+        "isLeaf": False,
+        "onActiveBranch": True,
+    }
+
+
+async def test_last_message_is_leaf():
+    thread = _thread_for(THREAD)
+    assert await thread.get_message_meta("u2") == {
+        "parentId": "a1",
+        "role": "user",
+        "isLeaf": True,
+        "onActiveBranch": True,
+    }
+
+
+async def test_unknown_id_returns_none():
+    thread = _thread_for(THREAD)
+    assert await thread.get_message_meta("nope") is None
+
+
+async def test_leaf_is_the_last_message_id():
+    assert await _thread_for(THREAD).get_leaf_message_id() == "u2"
+
+
+async def test_leaf_of_an_empty_thread_is_none():
+    assert await _thread_for([]).get_leaf_message_id() is None
+
+
+async def test_child_id_skips_tool_messages():
+    thread = _thread_for(
+        [
+            {"id": "u1", "type": "human"},
+            {"id": "t1", "type": "tool"},
+            {"id": "t2", "type": "tool"},
+            {"id": "u2", "type": "human"},
+        ]
+    )
+    assert await thread.get_message_child_id("u1") == "u2"
+
+
+async def test_child_id_with_only_tool_successors_is_none():
+    thread = _thread_for(
+        [
+            {"id": "u1", "type": "human"},
+            {"id": "t1", "type": "tool"},
+        ]
+    )
+    assert await thread.get_message_child_id("u1") is None
+
+
+async def test_child_id_of_an_unknown_parent_is_none():
+    assert await _thread_for(THREAD).get_message_child_id("nope") is None
+
+
+async def test_reads_the_live_list():
+    messages = []
+    thread = linear_thread(messages=lambda: messages, role=_role)
+    assert await thread.get_message_meta(None) == {"isLeaf": True}
+    messages.append({"id": "u1", "type": "human"})
+    assert await thread.get_message_meta(None) == {"isLeaf": False}
+    assert await thread.get_leaf_message_id() == "u1"
+
+
+def test_non_callable_messages_raises():
+    with pytest.raises(TypeError, match="messages must be callable"):
+        linear_thread(messages=THREAD, role=_role)
+
+
+def test_non_callable_role_raises():
+    with pytest.raises(TypeError, match="role must be callable"):
+        linear_thread(messages=lambda: THREAD, role="user")

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/tests/test_outcomes.py

@@ -127,7 +127,7 @@ async def test_unknown_capability_rejects_at_construction():
         RunManager(
             state={},
             run=None,
-            get_message_meta=None,
+            thread=None,
             create_task=asyncio.create_task,
             schedule=lambda fn: None,
             capabilities=("time-travel",),

harness_sdk_python-0.6.0/tests/test_prepare_hooks.py

@@ -0,0 +1,167 @@
+"""Contract: admission hooks. prepare_message rewrites each incoming wire
+message before validation on every message-carrying path (enqueue, steer,
+edit), once per message at admission; prepare_input rewrites each run/input
+response before validation. A non-dict return rejects invalid-message."""
+
+from run_helpers import Script, assert_rejected, msg, run_host
+
+from harness_sdk import RunManager
+
+
+def noisy(id: str) -> dict:
+    return {
+        "id": id,
+        "role": "user",
+        "parts": [{"type": "text", "text": id}, {"type": "x-note", "note": "n"}],
+    }
+
+
+def strip_notes(message: dict) -> dict:
+    return {
+        **message,
+        "parts": [p for p in message["parts"] if p["type"] != "x-note"],
+    }
+
+
+async def test_unhooked_noisy_message_rejects():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        assert_rejected(
+            await drv.command(
+                "run/enqueue",
+                {"message": noisy("m1"), "anchorMessageId": None},
+                terminal=False,
+            ),
+            "invalid-message",
+        )
+
+
+async def test_prepare_message_runs_once_at_enqueue_admission():
+    calls: list[str] = []
+
+    def hook(message):
+        calls.append(message["id"])
+        return strip_notes(message)
+
+    script = Script()
+    async with run_host(script, prepare_message=hook) as (drv, host):
+        await drv.command(
+            "run/enqueue",
+            {"message": noisy("m1"), "anchorMessageId": None},
+            terminal=False,
+        )
+        call = await script.next_call()
+        await drv.command(
+            "run/enqueue",
+            {"message": noisy("m2"), "anchorMessageId": None},
+            terminal=False,
+        )
+        call.ack()
+        call.finish(RunManager.Complete())
+        queued = await script.next_call()
+        assert calls == ["m1", "m2"]
+        assert [m["parts"] for m in call.ctx.messages] == [
+            [{"type": "text", "text": "m1"}]
+        ]
+        assert [m["parts"] for m in queued.ctx.messages] == [
+            [{"type": "text", "text": "m2"}]
+        ]
+
+
+async def test_prepare_message_applies_to_steer():
+    script = Script()
+    async with run_host(script, prepare_message=strip_notes) as (drv, host):
+        await drv.command(
+            "run/enqueue", {"message": msg("m1"), "anchorMessageId": None}, terminal=False
+        )
+        call = await script.next_call()
+        await drv.command(
+            "run/steer", {"message": noisy("s1"), "anchorMessageId": "m1"}, terminal=False
+        )
+        taken = call.ctx.steering.take()
+        assert [m["parts"] for m in taken] == [[{"type": "text", "text": "s1"}]]
+
+
+async def test_prepare_message_applies_to_edit():
+    script = Script()
+    script.thread.update(
+        {
+            "u1": {
+                "parentId": None,
+                "role": "user",
+                "isLeaf": True,
+                "onActiveBranch": True,
+            }
+        }
+    )
+    async with run_host(
+        script, capabilities=("rewind",), prepare_message=strip_notes
+    ) as (drv, host):
+        await drv.command(
+            "run/edit", {"sourceId": "u1", "message": noisy("u2")}, terminal=False
+        )
+        call = await script.next_call()
+        assert call.ctx.trigger == "message-edit"
+        assert [m["parts"] for m in call.ctx.messages] == [
+            [{"type": "text", "text": "u2"}]
+        ]
+
+
+async def test_prepare_input_transforms_response_before_validation():
+    def hook(response):
+        return {"output": response["result"]}
+
+    script = Script()
+    async with run_host(script, prepare_input=hook) as (drv, host):
+        await drv.command(
+            "run/enqueue", {"message": msg("m1"), "anchorMessageId": None}, terminal=False
+        )
+        call = await script.next_call()
+        call.ack()
+        call.finish(
+            RunManager.InputRequired(
+                ({"type": "tool-call", "id": "r1", "toolCallId": "tc1"},)
+            )
+        )
+        await drv.wait_status("input-required")
+        res = await drv.command(
+            "run/input", {"requestId": "r1", "response": {"result": "ok"}}
+        )
+        assert res["type"] == "accepted"
+        resumed = await script.next_call()
+        assert resumed.ctx.input_outcomes[0][1] == {"output": "ok"}
+
+
+async def test_prepare_message_non_dict_return_rejects():
+    script = Script()
+    async with run_host(script, prepare_message=lambda m: None) as (drv, host):
+        assert_rejected(
+            await drv.command(
+                "run/enqueue",
+                {"message": msg("m1"), "anchorMessageId": None},
+                terminal=False,
+            ),
+            "invalid-message",
+        )
+
+
+async def test_prepare_input_non_dict_return_rejects():
+    script = Script()
+    async with run_host(script, prepare_input=lambda r: "nope") as (drv, host):
+        await drv.command(
+            "run/enqueue", {"message": msg("m1"), "anchorMessageId": None}, terminal=False
+        )
+        call = await script.next_call()
+        call.ack()
+        call.finish(
+            RunManager.InputRequired(
+                ({"type": "tool-call", "id": "r1", "toolCallId": "tc1"},)
+            )
+        )
+        await drv.wait_status("input-required")
+        assert_rejected(
+            await drv.command(
+                "run/input", {"requestId": "r1", "response": {"output": "ok"}}
+            ),
+            "invalid-message",
+        )

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/tests/test_rewind_during_run.py

@@ -130,7 +130,7 @@ async def test_rewind_during_run_requires_rewind():
         RunManager(
             state={},
             run=script.run,
-            get_message_meta=script.get_message_meta,
+            thread=script,
             create_task=asyncio.create_task,
             schedule=lambda fn: None,
             capabilities=("rewind-during-run",),

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/tests/test_run_leaf.py

@@ -1,4 +1,3 @@
-import pytest
 from run_helpers import Script, add, msg, run_host, run_of
 
 from harness_sdk import RunManager
@@ -66,15 +65,48 @@ async def test_steering_take_sets_the_leaf():
         call.finish(RunManager.Complete())
 
 
-async def test_executor_report_sets_the_leaf():
+async def test_settle_pulls_the_thread_leaf():
+    for outcome in [
+        RunManager.Error(dispatch_queue=False),
+        RunManager.Stop(dispatch_queue=False),
+    ]:
+        script = Script()
+        async with run_host(script) as (drv, host):
+            await drv.command("run/enqueue", add("m1"), terminal=False)
+            call = await script.next_call()
+            call.ack()
+            script.leaf = "a1"
+            call.finish(outcome)
+            await drv.wait_status("error", "stopped")
+            assert drv.run["runLeafMessageId"] == "a1"
+
+
+async def test_input_required_settle_pulls_the_thread_leaf():
     script = Script()
     async with run_host(script) as (drv, host):
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         call.ack()
-        call.ctx.set_leaf_message_id("a1")
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a1")
-        call.finish(RunManager.Complete())
+        script.leaf = "a1"
+        call.finish(
+            RunManager.InputRequired(
+                requests=({"id": "r1", "type": "tool-call", "toolCallId": "t1"},)
+            )
+        )
+        await drv.wait_status("input-required")
+        assert drv.run["runLeafMessageId"] == "a1"
+
+
+async def test_unacked_end_reverts_instead_of_pulling():
+    script = Script()
+    async with run_host(script) as (drv, host):
+        await drv.command("run/enqueue", add("m1"), terminal=False)
+        call = await script.next_call()
+        script.leaf = "a1"
+        call.fail(RuntimeError("boom"))
+        await drv.wait_status("error")
+        assert drv.run["runLeafMessageId"] is None
+        assert [item["id"] for item in drv.run["queue"]] == ["m1"]
 
 
 async def test_complete_clears_the_leaf_on_ready():
@@ -83,8 +115,7 @@ async def test_complete_clears_the_leaf_on_ready():
         await drv.command("run/enqueue", add("m1"), terminal=False)
         call = await script.next_call()
         call.ack()
-        call.ctx.set_leaf_message_id("a1")
-        await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a1")
+        script.leaf = "a1"
         call.finish(RunManager.Complete())
         await drv.wait_status("ready")
         assert drv.replica["runs"] == []
@@ -97,7 +128,7 @@ async def test_complete_with_a_queued_item_keeps_the_leaf_flowing():
         call = await script.next_call()
         await drv.command("run/enqueue", add("m2", anchor="m1"), terminal=False)
         call.ack()
-        call.ctx.set_leaf_message_id("a1")
+        script.leaf = "a1"
         call.finish(RunManager.Complete())
         drain = await script.next_call()
         await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "m2")
@@ -107,22 +138,6 @@ async def test_complete_with_a_queued_item_keeps_the_leaf_flowing():
         assert drv.replica["runs"] == []
 
 
-async def test_error_and_stop_keep_the_in_flight_leaf():
-    for outcome in [
-        RunManager.Error(dispatch_queue=False),
-        RunManager.Stop(dispatch_queue=False),
-    ]:
-        script = Script()
-        async with run_host(script) as (drv, host):
-            await drv.command("run/enqueue", add("m1"), terminal=False)
-            call = await script.next_call()
-            call.ack()
-            call.ctx.set_leaf_message_id("a1")
-            call.finish(outcome)
-            await drv.wait_status("error", "stopped")
-            assert drv.run["runLeafMessageId"] == "a1"
-
-
 async def test_edit_dispatch_sets_the_leaf_to_the_replacement():
     script = Script()
     thread_with_turn(script)
@@ -142,16 +157,6 @@ async def test_reload_dispatch_sets_the_leaf_to_the_rollback_target():
         call = await script.next_call()
         await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "u1")
         call.ack()
-        call.ctx.set_leaf_message_id("a2")
+        script.leaf = "a2"
+        call.finish(RunManager.Stop(dispatch_queue=False))
         await drv.wait(lambda s: run_of(s).get("runLeafMessageId") == "a2")
-
-
-async def test_report_rejects_an_empty_id():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        call = await script.next_call()
-        with pytest.raises(ValueError, match="non-empty"):
-            call.ctx.set_leaf_message_id("")
-        call.ack()
-        call.finish(RunManager.Complete())

{harness_sdk_python-0.5.0 → harness_sdk_python-0.6.0}/tests/test_settle.py

@@ -146,17 +146,6 @@ async def test_complete_without_ack_is_a_run_error():
         assert (await drv.res(pending["seq"]))["type"] == "accepted"
 
 
-async def test_set_leaf_before_ack_raises():
-    script = Script()
-    async with run_host(script) as (drv, host):
-        await drv.command("run/enqueue", add("m1"), terminal=False)
-        call = await script.next_call()
-        with pytest.raises(RuntimeError, match="ack_messages"):
-            call.ctx.set_leaf_message_id("a1")
-        call.ack()
-        call.finish(RunManager.Complete())
-
-
 async def test_dequeue_removes_a_parked_entry():
     script = Script()
     async with run_host(script) as (drv, host):

harness_sdk_python-0.5.0/src/harness_sdk/__init__.py

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

harness_sdk_python-0.5.0/src/harness_sdk/linear_thread.py

@@ -1,31 +0,0 @@
-from typing import Any, Callable
-
-from .run_manager import GetMessageMeta
-
-
-def linear_thread_meta(
-    *,
-    messages: Callable[[], list[dict[str, Any]]],
-    role: Callable[[dict[str, Any]], str],
-) -> GetMessageMeta:
-    """RunManager ``get_message_meta`` for a linear message list: ``messages`` returns the current list, ``role`` maps a message to its role."""
-    if not callable(messages):
-        raise TypeError("messages must be callable")
-    if not callable(role):
-        raise TypeError("role must be callable")
-
-    async def get_message_meta(message_id: str | None) -> dict[str, Any] | None:
-        items = messages()
-        if message_id is None:
-            return {"isLeaf": not items}
-        for index, message in enumerate(items):
-            if message.get("id") == message_id:
-                return {
-                    "parentId": items[index - 1].get("id") if index > 0 else None,
-                    "role": role(message),
-                    "isLeaf": index == len(items) - 1,
-                    "onActiveBranch": True,
-                }
-        return None
-
-    return get_message_meta

harness_sdk_python-0.5.0/tests/test_linear_thread.py

@@ -1,87 +0,0 @@
-"""Contract: ``linear_thread_meta`` answers ``get_message_meta`` over a linear
-message list — ``None`` probes the root (isLeaf iff empty), a known id gets
-``{parentId, role, isLeaf, onActiveBranch}`` chained by list order, an unknown
-id gets ``None``."""
-
-import pytest
-
-from harness_sdk import linear_thread_meta
-
-
-def _role(message):
-    return "user" if message["type"] == "human" else "assistant"
-
-
-def _meta_for(messages):
-    return linear_thread_meta(messages=lambda: messages, role=_role)
-
-
-THREAD = [
-    {"id": "u1", "type": "human"},
-    {"id": "a1", "type": "ai"},
-    {"id": "u2", "type": "human"},
-]
-
-
-async def test_root_probe_reports_empty_thread():
-    meta = _meta_for([])
-    assert await meta(None) == {"isLeaf": True}
-
-
-async def test_root_probe_reports_nonempty_thread():
-    meta = _meta_for(THREAD)
-    assert await meta(None) == {"isLeaf": False}
-
-
-async def test_first_message_has_no_parent():
-    meta = _meta_for(THREAD)
-    assert await meta("u1") == {
-        "parentId": None,
-        "role": "user",
-        "isLeaf": False,
-        "onActiveBranch": True,
-    }
-
-
-async def test_middle_message_chains_to_predecessor():
-    meta = _meta_for(THREAD)
-    assert await meta("a1") == {
-        "parentId": "u1",
-        "role": "assistant",
-        "isLeaf": False,
-        "onActiveBranch": True,
-    }
-
-
-async def test_last_message_is_leaf():
-    meta = _meta_for(THREAD)
-    assert await meta("u2") == {
-        "parentId": "a1",
-        "role": "user",
-        "isLeaf": True,
-        "onActiveBranch": True,
-    }
-
-
-async def test_unknown_id_returns_none():
-    meta = _meta_for(THREAD)
-    assert await meta("nope") is None
-
-
-async def test_reads_the_live_list():
-    messages = []
-    meta = linear_thread_meta(messages=lambda: messages, role=_role)
-    assert await meta(None) == {"isLeaf": True}
-    messages.append({"id": "u1", "type": "human"})
-    assert await meta(None) == {"isLeaf": False}
-    assert (await meta("u1"))["isLeaf"] is True
-
-
-def test_non_callable_messages_raises():
-    with pytest.raises(TypeError, match="messages must be callable"):
-        linear_thread_meta(messages=THREAD, role=_role)
-
-
-def test_non_callable_role_raises():
-    with pytest.raises(TypeError, match="role must be callable"):
-        linear_thread_meta(messages=lambda: THREAD, role="user")