harness-sdk-python 0.37.0__tar.gz → 0.37.1__tar.gz

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.37.0
+Version: 0.37.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.19,>=0.18.0
+Requires-Dist: statewire<0.19,>=0.18.1
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.37.0"
+version = "0.37.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.18.0,<0.19", "pinned>=0.15.2,<0.16"]
+dependencies = ["statewire>=0.18.1,<0.19", "pinned>=0.15.2,<0.16"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/src/harness_sdk/__init__.py

@@ -1,4 +1,4 @@
-from .protocol import HARNESS_PROTOCOL
+from .protocol import HARNESS_PROTOCOL, HARNESS_THREADS_PROTOCOL
 from .checkpoints import (
     CheckpointIndex,
     CheckpointStore,
@@ -21,6 +21,7 @@ from .messages import MAIN_NS, MessageTree
 from .parts import PartsAssembler
 from .linear_thread import linear_thread
 from .run_manager import RunManager, RunManagerDescriptor, run_manager
+from .threads import DuplicateThread, HarnessThreads, MemoryThreadStore, ThreadRecord, ThreadStatus, ThreadStore, UnknownThread
 from .wire import CONTEXT, INTEREST, HarnessMessages
 from .voice import (
     VoiceManager,
@@ -37,6 +38,14 @@ from .voice import (
 __all__ = [
     "CONTEXT",
     "HARNESS_PROTOCOL",
+    "HARNESS_THREADS_PROTOCOL",
+    "HarnessThreads",
+    "MemoryThreadStore",
+    "ThreadRecord",
+    "ThreadStatus",
+    "ThreadStore",
+    "DuplicateThread",
+    "UnknownThread",
     "HarnessMessages",
     "INTEREST",
     "CheckpointIndex",

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/src/harness_sdk/deepagents_host.py

@@ -13,9 +13,26 @@ from .checkpoints import CheckpointIndex
 from .deepagents import DeepagentsThread
 from .langgraph import FrontierCheckpointer
 from .protocol import HARNESS_PROTOCOL
+from .messages import MAIN_NS
 from .run_manager import RunManager, run_manager
 from .wire import HarnessMessages
 
+TITLE_LENGTH = 80
+
+
+def first_user_text(tree: Any) -> str | None:
+    """Text of the first user message on the main head chain, cut to ``TITLE_LENGTH``."""
+    thread = tree.threads.get(MAIN_NS)
+    if thread is None or thread.head is None:
+        return None
+    for message_id in thread.chain(thread.head):
+        message = thread.messages[message_id]
+        if message["role"] != "user":
+            continue
+        text = " ".join(p["text"] for p in message["parts"] if p.get("type") == "text").strip()
+        return text[:TITLE_LENGTH] if text else None
+    return None
+
 
 class DeepagentsHost(HarnessMessages, Statewire):
     """One thread: ``build_agent(checkpointer)`` returns the compiled deepagents graph."""
@@ -23,6 +40,8 @@ class DeepagentsHost(HarnessMessages, Statewire):
     protocols = (HARNESS_PROTOCOL,)
     checkpointer: Any = None
     index: CheckpointIndex | None = None
+    #: Path of the ``HarnessThreads`` instance this thread lists itself on, e.g. ``"/thread-lists/default"``. Alpha.
+    thread_list: str | None = None
 
     def build_agent(self, checkpointer: Any) -> Any:
         raise NotImplementedError(f"{type(self).__name__}.build_agent")
@@ -61,6 +80,7 @@ class DeepagentsHost(HarnessMessages, Statewire):
             except BaseException:
                 self.messages.abandon_turn()
                 raise
+            await self._touch_thread_list()
             if outcome is not None:
                 return outcome
             interrupt = self.messages.interrupt
@@ -75,6 +95,17 @@ class DeepagentsHost(HarnessMessages, Statewire):
             payload = {"messages": steered}
             config = self.messages.config()
 
+    async def _touch_thread_list(self) -> None:
+        if self.thread_list is None:
+            return
+        body: dict[str, Any] = {"threadId": self.id}
+        title = first_user_text(self.tree)
+        if title is not None:
+            body["title"] = title
+        response = await self.cluster.post(f"{self.thread_list}/touch", json=body)
+        if response.status_code != 200:
+            raise RuntimeError(f"{self.thread_list}/touch answered {response.status_code}: {response.text}")
+
     async def _stream_turn(self, ctx: RunManager.RunContext, payload: Any, config: dict[str, Any]) -> Any:
         stream = self.agent.astream(
             payload, config=config, stream_mode=["messages", "updates", "checkpoints"], subgraphs=True

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/src/harness_sdk/interest.py

@@ -11,6 +11,12 @@ from .messages import MessageTree, Thread
 
 MAX_WINDOW = 200
 MAX_INTERESTS = 16
+DEFAULT_WINDOW = 50
+
+
+def head_request(window: int = DEFAULT_WINDOW) -> dict[str, Any]:
+    """The head window of the main thread: every attach starts with it."""
+    return {"ns": "main", "before": window, "follow": {"before": window}}
 
 
 class InterestError(ValueError):

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/src/harness_sdk/protocol.py

@@ -10,3 +10,5 @@ HARNESS_PROTOCOL = Statewire.Protocol(
         Subprotocol("context", record="ephemeral"),
     ),
 )
+
+HARNESS_THREADS_PROTOCOL = Statewire.Protocol("harness-sdk-threads", version="2026-09-13", min_version="2026-09-13")

harness_sdk_python-0.37.1/src/harness_sdk/threads.py

@@ -0,0 +1,170 @@
+"""HarnessThreads: a Statewire host serving one thread list over the
+``harness-sdk-threads`` protocol; the list instance is the store's only writer.
+
+.. versionadded:: alpha
+"""
+
+from datetime import datetime, timezone
+from typing import Any, Literal, NotRequired, Protocol, TypedDict
+
+from fastapi import HTTPException, Request
+from pinned import Attestation, AuthRejected, attestation, route
+from starlette.requests import HTTPConnection
+from statewire import Statewire, StatewireReject, command
+
+from .protocol import HARNESS_THREADS_PROTOCOL
+
+ThreadStatus = Literal["regular", "archived"]
+
+
+class ThreadRecord(TypedDict):
+    """One list entry; ``updatedAt`` is ISO-8601.
+
+    .. versionadded:: alpha
+    """
+
+    id: str
+    title: NotRequired[str]
+    status: ThreadStatus
+    updatedAt: str
+
+
+class UnknownThread(KeyError):
+    """The store has no thread with that id."""
+
+
+class DuplicateThread(ValueError):
+    """The store already has a thread with that id."""
+
+
+class ThreadStore(Protocol):
+    """Backing store of one thread list; ``list`` is sorted by ``updatedAt`` descending.
+
+    .. versionadded:: alpha
+    """
+
+    async def list(self) -> list[ThreadRecord]: ...
+    async def create(self, thread_id: str) -> None: ...
+    async def rename(self, thread_id: str, title: str) -> None: ...
+    async def set_status(self, thread_id: str, status: ThreadStatus) -> None: ...
+    async def delete(self, thread_id: str) -> None: ...
+    async def touch(self, thread_id: str, *, title: str | None = None) -> None:
+        """Upsert ``thread_id`` at the top of the list; ``title`` applies only while the thread has none."""
+        ...
+
+
+def _now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="milliseconds").replace("+00:00", "Z")
+
+
+class MemoryThreadStore:
+    """In-process ``ThreadStore``.
+
+    .. versionadded:: alpha
+    """
+
+    def __init__(self) -> None:
+        self._threads: dict[str, ThreadRecord] = {}
+
+    def _get(self, thread_id: str) -> ThreadRecord:
+        record = self._threads.get(thread_id)
+        if record is None:
+            raise UnknownThread(thread_id)
+        return record
+
+    async def list(self) -> list[ThreadRecord]:
+        return sorted((dict(r) for r in self._threads.values()), key=lambda r: r["updatedAt"], reverse=True)
+
+    async def create(self, thread_id: str) -> None:
+        if thread_id in self._threads:
+            raise DuplicateThread(thread_id)
+        self._threads[thread_id] = {"id": thread_id, "status": "regular", "updatedAt": _now()}
+
+    async def rename(self, thread_id: str, title: str) -> None:
+        self._get(thread_id)["title"] = title
+
+    async def set_status(self, thread_id: str, status: ThreadStatus) -> None:
+        self._get(thread_id)["status"] = status
+
+    async def delete(self, thread_id: str) -> None:
+        self._get(thread_id)
+        del self._threads[thread_id]
+
+    async def touch(self, thread_id: str, *, title: str | None = None) -> None:
+        record = self._threads.setdefault(thread_id, {"id": thread_id, "status": "regular", "updatedAt": ""})
+        record["updatedAt"] = _now()
+        if title is not None and "title" not in record:
+            record["title"] = title
+
+
+def _thread_id(params: Any) -> str:
+    if not isinstance(params, dict) or not isinstance(params.get("threadId"), str) or not params["threadId"]:
+        raise StatewireReject("threadId must be a non-empty string", code="invalid-params")
+    return params["threadId"]
+
+
+class HarnessThreads(Statewire):
+    """One thread list; ``thread_store()`` names its store (in-memory per instance by default).
+
+    .. versionadded:: alpha
+    """
+
+    protocols = (HARNESS_THREADS_PROTOCOL,)
+
+    def thread_store(self) -> ThreadStore:
+        return MemoryThreadStore()
+
+    async def lifespan(self):
+        self.store = self.thread_store()
+        self.state = {"threads": await self.store.list()}
+        yield
+
+    async def _apply(self, action: Any) -> None:
+        try:
+            await action
+        except UnknownThread as error:
+            raise StatewireReject(f"unknown thread {error.args[0]}", code="unknown-thread") from None
+        except DuplicateThread as error:
+            raise StatewireReject(f"thread {error.args[0]} already exists", code="duplicate-id") from None
+        self.state["threads"] = await self.store.list()
+
+    async def _instance_auth(self, conn: HTTPConnection) -> Attestation.Instance:
+        caller = attestation(conn)
+        if not isinstance(caller, Attestation.Instance):
+            raise AuthRejected("touch requires an attested instance caller", status_code=403)
+        return caller
+
+    @route.post("/touch", auth=_instance_auth)
+    async def touch(self, request: Request) -> dict[str, bool]:
+        """``POST /touch`` ``{"threadId", "title"?}`` from another instance: upsert at the top of the list."""
+        body = await request.json()
+        thread_id = body.get("threadId") if isinstance(body, dict) else None
+        title = body.get("title") if isinstance(body, dict) else None
+        if not isinstance(thread_id, str) or not thread_id or not (title is None or isinstance(title, str)):
+            raise HTTPException(status_code=400, detail="body must be {threadId: str, title?: str}")
+        await self._apply(self.store.touch(thread_id, title=title))
+        return {"ok": True}
+
+    @command("thread/create")
+    async def thread_create(self, params: Any) -> None:
+        await self._apply(self.store.create(_thread_id(params)))
+
+    @command("thread/rename")
+    async def thread_rename(self, params: Any) -> None:
+        thread_id = _thread_id(params)
+        title = params.get("title")
+        if not isinstance(title, str):
+            raise StatewireReject("title must be a string", code="invalid-params")
+        await self._apply(self.store.rename(thread_id, title))
+
+    @command("thread/archive")
+    async def thread_archive(self, params: Any) -> None:
+        await self._apply(self.store.set_status(_thread_id(params), "archived"))
+
+    @command("thread/unarchive")
+    async def thread_unarchive(self, params: Any) -> None:
+        await self._apply(self.store.set_status(_thread_id(params), "regular"))
+
+    @command("thread/delete")
+    async def thread_delete(self, params: Any) -> None:
+        await self._apply(self.store.delete(_thread_id(params)))

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/src/harness_sdk/wire.py

@@ -1,7 +1,7 @@
-"""HarnessMessages: the harness message tree on the wire. Interests are
-per-attach ephemeral documents under ``harness-sdk/interest``; the messages
-they cover are shared keyed ``harness-sdk`` documents included per attach;
-``harness-sdk/context`` is the synced client context.
+"""HarnessMessages: the harness message tree on the wire. Each attach's
+interests are one ephemeral main document under ``harness-sdk/interest``;
+the messages they cover are shared keyed ``harness-sdk`` documents included
+per attach; ``harness-sdk/context`` is the synced client context.
 """
 
 from functools import cached_property
@@ -10,20 +10,21 @@ from typing import Any
 from statepatch import plain
 from statewire import StatewireAttach, StatewireReject, command, synced_document
 
-from .interest import InterestError, check_request, covered, resolve
+from .interest import MAX_INTERESTS, InterestError, check_request, covered, head_request, resolve
 from .messages import MessageTree
 
 INTEREST = "harness-sdk/interest"
 CONTEXT = "harness-sdk/context"
-_REQUEST_KEYS = ("ns", "at", "before", "after", "follow")
+_EMPTY_WINDOW = {"chain": [], "more": {"before": False, "after": False}}
 
 
 class _Interests:
-    """One attach's interests: request and document proxy by id, plus its included message keys."""
+    """One attach's requests, its interest document proxy, and its included message keys."""
 
     def __init__(self, attach: StatewireAttach) -> None:
         self.attach = attach
-        self.requests: dict[str, tuple[dict[str, Any], Any]] = {}
+        self.requests: list[dict[str, Any]] = []
+        self.proxy: Any = None
         self.included: set[tuple[str, str]] = set()
 
 
@@ -32,6 +33,10 @@ class HarnessMessages:
 
     context = synced_document(CONTEXT)
 
+    @property
+    def state_key(self) -> tuple[str, ...]:
+        return (self.id,)
+
     @cached_property
     def tree(self) -> MessageTree:
         return MessageTree()
@@ -44,55 +49,52 @@ class HarnessMessages:
     def _mounted_messages(self) -> dict[tuple[str, str], Any]:
         return {}
 
+    def attaching(self, attach: StatewireAttach) -> None:
+        interests = self._interests[attach.id] = _Interests(attach)
+        interests.requests = [head_request()]
+        self.refresh_messages()
+
     def detached(self, attach: StatewireAttach) -> None:
         if self._interests.pop(attach.id, None) is not None:
             self.refresh_messages()
 
     @command("set", protocol=INTEREST)
-    async def _interest_set(self, id: str, request: Any, *, ctx: Any) -> None:
-        if not isinstance(id, str) or not id:
-            raise StatewireReject("interest id must be a non-empty string", code="invalid-interest")
+    async def _interest_set(self, requests: Any, *, ctx: Any) -> None:
+        if not isinstance(requests, list) or len(requests) > MAX_INTERESTS:
+            raise StatewireReject(
+                f"interests must be an array of at most {MAX_INTERESTS} requests", code="invalid-interest"
+            )
         try:
-            normalized = check_request(request)
-            resolution = resolve(self.tree, normalized)
+            normalized = [check_request(request) for request in requests]
+            for request in normalized:
+                resolve(self.tree, request)
         except InterestError as exc:
             raise StatewireReject(exc.message, code=exc.code) from None
-        interests = self._interests.get(ctx.attach.id)
-        if interests is None:
-            interests = self._interests[ctx.attach.id] = _Interests(ctx.attach)
-        existing = interests.requests.get(id)
-        if existing is None:
-            proxy = ctx.attach.mount(INTEREST, {**normalized, **resolution}, key=[self.id, id])
-        else:
-            proxy = existing[1]
-            for key in _REQUEST_KEYS:
-                if key in normalized:
-                    proxy[key] = normalized[key]
-                elif key in plain(proxy):
-                    del proxy[key]
-        interests.requests[id] = (normalized, proxy)
+        self._interests[ctx.attach.id].requests = normalized
         self.refresh_messages()
 
-    @command("remove", protocol=INTEREST)
-    async def _interest_remove(self, id: str, *, ctx: Any) -> None:
-        interests = self._interests.get(ctx.attach.id)
-        if interests is None or id not in interests.requests:
-            raise StatewireReject(f"unknown interest {id!r}", code="unknown-interest")
-        del interests.requests[id]
-        ctx.attach.unmount(INTEREST, key=[self.id, id])
-        self.refresh_messages()
+    def _windows(self, requests: list[dict[str, Any]]) -> list[dict[str, Any]]:
+        windows = []
+        for request in requests:
+            try:
+                resolution = resolve(self.tree, request)
+            except InterestError:
+                resolution = _EMPTY_WINDOW
+            windows.append({**request, **resolution})
+        return windows
 
     def refresh_messages(self) -> None:
         """Re-resolve every interest; mount, include, exclude and unmount message documents to match."""
         wanted: set[tuple[str, str]] = set()
         for interests in self._interests.values():
+            windows = self._windows(interests.requests)
+            if interests.proxy is None:
+                interests.proxy = interests.attach.mount(INTEREST, {"windows": windows}, main=True)
+            elif plain(interests.proxy)["windows"] != windows:
+                interests.proxy["windows"] = windows
             attach_wanted: set[tuple[str, str]] = set()
-            for request, proxy in interests.requests.values():
-                resolution = resolve(self.tree, request)
-                for key, value in resolution.items():
-                    if plain(proxy).get(key) != value:
-                        proxy[key] = value
-                attach_wanted |= covered(request, resolution)
+            for window in windows:
+                attach_wanted |= covered(window, window)
             for ns, message_id in attach_wanted - interests.included:
                 self._mount_message(ns, message_id)
                 interests.attach.include("harness-sdk", [self.id, ns, message_id])

harness_sdk_python-0.37.1/tests/test_threads.py

@@ -0,0 +1,169 @@
+"""Contract: HarnessThreads serves one ``harness-sdk-threads`` main document, newest first; its ``thread/*`` commands edit the list and ``POST /touch`` upserts from an attested sibling instance only."""
+
+import asyncio
+from contextlib import asynccontextmanager
+
+import httpx
+import pytest
+from fastapi import FastAPI
+from pinned import PinnedAPI, PinnedHost, PinnedWorker, route
+from statewire.protocol import Offer, VersionRange, headers as protocol_headers
+from statewire_helpers import apply_ops, cmd_on, stream_of
+
+from harness_sdk.deepagents_host import first_user_text
+from harness_sdk.messages import MessageTree
+from harness_sdk.threads import HarnessThreads
+
+pytestmark = pytest.mark.anyio
+
+NEGOTIATION = protocol_headers(VersionRange(), (Offer("harness-sdk-threads", VersionRange()),))
+
+
+class Toucher(PinnedAPI):
+    """A sibling host's instance touching the list at /threads/t1 through the cluster."""
+
+    @route.post("/touch")
+    async def touch(self, thread_id: str, title: str | None = None) -> dict:
+        body = {"threadId": thread_id, **({"title": title} if title is not None else {})}
+        response = await self.cluster.post("/threads/t1/touch", json=body)
+        return {"status": response.status_code}
+
+
+@asynccontextmanager
+async def thread_list():
+    worker = PinnedWorker()
+    lists = PinnedHost(HarnessThreads, worker=worker, namespace="/threads")
+    callers = PinnedHost(Toucher, worker=worker, namespace="/callers")
+    app = FastAPI()
+    app.include_router(worker)
+    app.include_router(lists)
+    app.include_router(callers)
+    async with lists.lifespan(app), callers.lifespan(app):
+        async with httpx.AsyncClient(transport=httpx.ASGITransport(app=app), base_url="http://test", headers=NEGOTIATION) as client:
+            yield app, client
+
+
+async def touch(client, thread_id, title=None):
+    params = {"thread_id": thread_id, **({"title": title} if title is not None else {})}
+    response = await client.post("/callers/c/touch", params=params)
+    assert response.json() == {"status": 200}, response.text
+
+
+def ids(state):
+    return [t["id"] for t in state["threads"]]
+
+
+async def attached(app, client_id="c1"):
+    stream = stream_of(app, client_id=client_id, headers=NEGOTIATION)
+    await stream.__aenter__()
+    snapshot = await stream.next_event()
+    state = apply_ops({}, snapshot)
+    return stream, state
+
+
+async def snapshot(app, client_id):
+    stream, state = await attached(app, client_id)
+    await stream.__aexit__(None, None, None)
+    return state
+
+
+async def synced(stream, state):
+    """Fold envelopes until one carries document ops."""
+    while True:
+        env = await stream.next_event()
+        if env.get("ops"):
+            for op in env["ops"]:
+                if op.get("op") == "replace" and op.get("path") == []:
+                    state.clear()
+                    state.update(op["value"])
+                else:
+                    apply_ops(state, [op])
+            return state
+
+
+def statement(seq, method, **params):
+    return {"seq": seq, "protocol": "harness-sdk-threads", "method": method, "params": [params]}
+
+
+async def test_snapshot_lists_newest_first():
+    async with thread_list() as (app, client):
+        await touch(client, "a", title="First")
+        await asyncio.sleep(0.002)
+        await touch(client, "b")
+        state = await snapshot(app, "c1")
+        assert ids(state) == ["b", "a"]
+        assert state["threads"][1] == {"id": "a", "title": "First", "status": "regular", "updatedAt": state["threads"][1]["updatedAt"]}
+
+
+async def test_commands_edit_the_document():
+    async with thread_list() as (app, client):
+        stream, _state = await attached(app)
+        try:
+            post = lambda seq, method, **params: cmd_on(  # noqa: E731
+                stream, client, statement(seq, method, **params), client_id="c1"
+            )
+            assert (await post(1, "thread/create", threadId="t1"))["type"] == "result"
+            assert (await post(2, "thread/rename", threadId="t1", title="Renamed"))["type"] == "result"
+            assert (await post(3, "thread/archive", threadId="t1"))["type"] == "result"
+            listed = (await snapshot(app, "c2"))["threads"]
+            assert listed[0]["title"] == "Renamed" and listed[0]["status"] == "archived"
+            assert (await post(4, "thread/unarchive", threadId="t1"))["type"] == "result"
+            assert (await snapshot(app, "c3"))["threads"][0]["status"] == "regular"
+            assert (await post(5, "thread/delete", threadId="t1"))["type"] == "result"
+            assert (await snapshot(app, "c4"))["threads"] == []
+        finally:
+            await stream.__aexit__(None, None, None)
+
+
+async def test_rejections():
+    async with thread_list() as (app, client):
+        await touch(client, "t1")
+        stream, _state = await attached(app)
+        try:
+            verdicts = [
+                await cmd_on(stream, client, statement(1, "thread/create", threadId="t1"), client_id="c1"),
+                await cmd_on(stream, client, statement(2, "thread/rename", threadId="zz", title="x"), client_id="c1"),
+                await cmd_on(stream, client, statement(3, "thread/archive", threadId=""), client_id="c1"),
+                await cmd_on(stream, client, statement(4, "thread/rename", threadId="t1", title=3), client_id="c1"),
+            ]
+            assert [(v["type"], v.get("code")) for v in verdicts] == [
+                ("rejected", "duplicate-id"),
+                ("rejected", "unknown-thread"),
+                ("rejected", "invalid-params"),
+                ("rejected", "invalid-params"),
+            ]
+        finally:
+            await stream.__aexit__(None, None, None)
+
+
+async def test_touch_from_a_sibling_instance_reaches_attached_streams():
+    async with thread_list() as (app, client):
+        stream, state = await attached(app)
+        try:
+            assert ids(state) == []
+            await touch(client, "t9", title="From the thread host")
+            await synced(stream, state)
+            assert ids(state) == ["t9"]
+            assert state["threads"][0]["title"] == "From the thread host"
+            await touch(client, "t9", title="Ignored: title is set once")
+            await synced(stream, state)
+            assert state["threads"][0]["title"] == "From the thread host"
+        finally:
+            await stream.__aexit__(None, None, None)
+
+
+async def test_touch_refuses_unattested_callers_and_bad_bodies():
+    async with thread_list() as (app, client):
+        response = await client.post("/threads/t1/touch", json={"threadId": "t1"})
+        assert response.status_code == 403
+        response = await client.post("/callers/c/touch", params={"thread_id": ""})
+        assert response.json() == {"status": 400}
+        assert ids(await snapshot(app, "c1")) == []
+
+
+def test_first_user_text_reads_the_head_chain():
+    tree = MessageTree()
+    tree.add("main", {"id": "u1", "parentId": None, "role": "user", "parts": [{"type": "text", "text": " Hello "}, {"type": "text", "text": "x" * 100}]})
+    tree.add("main", {"id": "a1", "parentId": "u1", "role": "assistant", "parts": []})
+    assert first_user_text(tree) == ("Hello  " + "x" * 100)[:80]
+    assert first_user_text(MessageTree()) is None

{harness_sdk_python-0.37.0 → harness_sdk_python-0.37.1}/tests/test_wire.py

@@ -1,4 +1,4 @@
-"""Contract: HarnessMessages serves interests as ephemeral documents, mounts and includes the covered messages per attach, and unmounts what no attach covers."""
+"""Contract: HarnessMessages serves each attach's interests as one ephemeral main document, mounts and includes the covered messages per attach, and unmounts what no attach covers."""
 
 import asyncio
 from typing import Any
@@ -60,8 +60,11 @@ class Wire:
                 self.docs[doc] = (protocol, key, client_apply_ops(value, [mutation]))
         self.answers.extend(envelope.get("cmd", []))
 
-    def keyed(self, protocol: str) -> dict[tuple[str, ...], Any]:
-        return {tuple(key): value for p, key, value in self.docs.values() if p == protocol and key is not None}
+    def messages(self, protocol: str) -> dict[tuple[str, ...], Any]:
+        return {tuple(key): value for p, key, value in self.docs.values() if p == protocol and key is not None and len(key) == 3}
+
+    def window(self, index: int) -> Any:
+        return next(value for p, _key, value in self.docs.values() if p == "harness-sdk/interest")["windows"][index]
 
     async def until(self, predicate, what: str) -> None:
         try:
@@ -80,13 +83,13 @@ async def test_interests_mount_covered_messages_follow_spawns_and_unmount_on_det
             await wire.pump()
             response = await post_frame(
                 client,
-                {"cmd": [{"protocol": "harness-sdk/interest", "method": "set", "params": ["i0", {"ns": "main", "before": 10, "follow": {"before": 10}}], "seq": 1}]},
+                {"cmd": [{"protocol": "harness-sdk/interest", "method": "set", "params": [[{"ns": "main", "before": 10, "follow": {"before": 10}}]], "seq": 1}]},
                 client_id="c1",
             )
             assert response.status_code == 200, response.text
-            await wire.until(lambda: len(wire.keyed("harness-sdk")) == 2, "messages included")
-            assert set(wire.keyed("harness-sdk")) == {("t1", "main", "u1"), ("t1", "main", "a1")}
-            interest = wire.keyed("harness-sdk/interest")[("t1", "i0")]
+            await wire.until(lambda: len(wire.messages("harness-sdk")) == 2, "messages included")
+            assert set(wire.messages("harness-sdk")) == {("t1", "main", "u1"), ("t1", "main", "a1")}
+            interest = wire.window(0)
             assert [e["id"] for e in interest["chain"]] == ["u1", "a1"]
             assert interest["follows"] == {}
 
@@ -96,10 +99,10 @@ async def test_interests_mount_covered_messages_follow_spawns_and_unmount_on_det
             host.tree.get("main", "a1")["parts"][0]["metadata"] = {"ns": "sub"}
             host.tree.add("sub", {"id": "s1", "parentId": None, "role": "user", "parts": [{"type": "text", "text": "go"}]})
             host.refresh_messages()
-            await wire.until(lambda: ("t1", "sub", "s1") in wire.keyed("harness-sdk"), "followed message included")
-            interest = wire.keyed("harness-sdk/interest")[("t1", "i0")]
+            await wire.until(lambda: ("t1", "sub", "s1") in wire.messages("harness-sdk"), "followed message included")
+            interest = wire.window(0)
             assert [e["id"] for e in interest["follows"]["sub"]["chain"]] == ["s1"]
-            assert wire.keyed("harness-sdk")[("t1", "main", "a1")]["parts"][0]["metadata"] == {"ns": "sub"}
+            assert wire.messages("harness-sdk")[("t1", "main", "a1")]["parts"][0]["metadata"] == {"ns": "sub"}
         async with asyncio.timeout(5):
             while host._interests:
                 await asyncio.sleep(0.01)