harness-sdk-python 0.31.2__tar.gz → 0.32.1__tar.gz

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.31.2
+Version: 0.32.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

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/pyproject.toml

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

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/src/harness_sdk/run_manager.py

@@ -342,7 +342,6 @@ class RunManager(Tray):
             "dispatching": dispatching,
             "stopping": stopping,
             "nextDispatch": nextDispatch,
-            "inputRequests": inputRequests,
             "error": error,
             "stopReason": stopReason,
         }
@@ -370,9 +369,14 @@ class RunManager(Tray):
         self.state["runId"] = self.id
         self._hydrate_machine()
         self._mirror_steer()
-        unsubscribe = self.steerQueue.subscribe(lambda _op: self._mirror_steer())
+        self._mirror_input()
+        unsubscribes = [
+            self.steerQueue.subscribe(lambda _op: self._mirror_steer()),
+            self.inputRequests.subscribe(lambda _op: self._mirror_input()),
+        ]
         yield
-        unsubscribe()
+        for unsubscribe in unsubscribes:
+            unsubscribe()
 
     class Thread(Protocol):
         """The thread projection RunManager reads; the host owns the tree."""
@@ -500,6 +504,14 @@ class RunManager(Tray):
     def _mirror_steer(self) -> None:
         self.steerView.value = [_public(item) for item in self.steerQueue.value]
 
+    def _mirror_input(self) -> None:
+        # None publishes as an absent key, matching the TS harness shape
+        requests = self.inputRequests.value
+        if requests is None:
+            self.state.pop("inputRequests", None)
+        else:
+            self.state["inputRequests"] = requests
+
     def _sync_steering(self) -> None:
         ctx = self._run_live
         if ctx is None:

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/src/harness_sdk/voice.py

@@ -7,9 +7,10 @@ lives in its own ephemeral tray, minted by ``voice/start`` and deleted when
 the session ends. The host implements ``VoiceManager.Host``: the seed read
 and the turn commit both stay host-owned.
 
-``voice/start {offer, tools?}`` seeds the provider from the thread
-transcript (at most 128 messages, tail taken), hands the client's frontend
-function tool definitions to the provider, and projects ``state["voice"] =
+``voice/start {offer}`` seeds the provider from the thread
+transcript (at most 128 messages, tail taken), hands the caller's frontend
+function tool definitions (the ``tools`` map the client's synced model
+context stores at ``ctx.caller.context``) to the provider, and projects ``state["voice"] =
 {clientId, status, toolCalls, activeTask}`` — the SDP answer rides only the command's
 result payload ``{answer}``. A named call matching a client-declared tool
 projects into ``toolCalls`` as ``{callId, name, arguments}``; the owning
@@ -74,28 +75,32 @@ def _reject(reason: str, message: str) -> StatewireReject:
     return StatewireReject(message, payload={"reason": reason})
 
 
-def _validated_tools(tools: Any) -> "list[VoiceManager.ToolDef]":
+def _context_tools(context: Any) -> "list[VoiceManager.ToolDef]":
+    tools = context.get("tools") if isinstance(context, dict) else None
     if tools is None:
         return []
-    if not isinstance(tools, list):
-        raise _reject("invalid-message", "tools must be a list")
-    names: set[str] = set()
-    for tool in tools:
+    if not isinstance(tools, dict):
+        raise _reject("invalid-message", "context tools must be a name-keyed object")
+    defs: "list[VoiceManager.ToolDef]" = []
+    for name, spec in tools.items():
         if (
-            not isinstance(tool, dict)
-            or not isinstance(tool.get("name"), str)
-            or tool["name"] == ""
-            or not isinstance(tool.get("description"), str)
-            or not isinstance(tool.get("parameters"), dict)
+            name == ""
+            or not isinstance(spec, dict)
+            or not isinstance(spec.get("description", ""), str)
+            or not isinstance(spec.get("parameters"), dict)
         ):
             raise _reject(
                 "invalid-message",
-                f"tools entries must be {{name, description, parameters}}, got {tool!r}",
+                f"context tools entries must be name -> {{description?, parameters}}, got {name!r}: {spec!r}",
             )
-        if tool["name"] in names:
-            raise _reject("invalid-message", f"duplicate tool name {tool['name']!r}")
-        names.add(tool["name"])
-    return tools
+        defs.append(
+            {
+                "name": name,
+                "description": spec.get("description", ""),
+                "parameters": spec["parameters"],
+            }
+        )
+    return defs
 
 
 def _capped_seed(seed: Any) -> "list[VoiceManager.SeedMessage]":
@@ -156,7 +161,7 @@ class VoiceManager(Tray):
         text: str
 
     class ToolDef(TypedDict):
-        """One frontend function tool the client declares at ``voice/start``."""
+        """One frontend function tool from the caller's synced model context."""
 
         name: str
         description: str
@@ -593,7 +598,7 @@ class VoiceManagerNamespace(TrayMapNamespace):
         offer = params.get("offer")
         if not isinstance(offer, str) or offer == "":
             raise _reject("invalid-message", "offer must be a non-empty SDP string")
-        tools = _validated_tools(params.get("tools"))
+        tools = _context_tools(ctx.caller.context)
         if self._starting:
             raise _reject("voice-active", "a voice session is already live")
         session = self.live()

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/tests/run_helpers.py

@@ -162,6 +162,7 @@ class RunDriver:
         self.client_id = client_id
         self._side_seqs: dict[str, int] = {}
         self._seq = 0
+        self._ctx_seq = 0
         self._res: dict[int, list[dict[str, Any]]] = {}
         self._posts: list["asyncio.Task[None]"] = []
         self.replica: dict[str, Any] = {}
@@ -180,6 +181,20 @@ class RunDriver:
     def _spawn(self, frame: dict[str, Any]) -> None:
         self._posts.append(asyncio.create_task(self._submit(frame)))
 
+    async def set_context(self, value: dict[str, Any]) -> None:
+        """Sync this client's stored context (one root replace), as contextSync does."""
+        self._ctx_seq += 1
+        await self._submit(
+            {
+                "ctx": [
+                    {
+                        "ops": [{"op": "replace", "path": [], "value": value}],
+                        "seq": self._ctx_seq,
+                    }
+                ]
+            }
+        )
+
     def post(self, method: str, params: Any = None) -> int:
         """Background frame POST; settle via ``res(seq)``."""
         self._seq += 1
@@ -393,7 +408,6 @@ def run_of(replica: dict[str, Any]) -> dict[str, Any]:
             "dispatching": None,
             "stopping": None,
             "nextDispatch": None,
-            "inputRequests": None,
             "error": None,
             "stopReason": None,
         }

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/tests/test_input_required.py

@@ -54,7 +54,7 @@ async def test_partial_answer_stays_parked_and_echoes_response():
         )
         assert res["type"] == "accepted"
         await drv.wait(
-            lambda s: "response" in run_of(s)["inputRequests"][0]
+            lambda s: "response" in run_of(s).get("inputRequests", [{}])[0]
         )
         assert drv.replica["status"] == "input-required"
         assert drv.run["inputRequests"][0]["response"] == {"output": "ok"}
@@ -82,7 +82,7 @@ async def test_completing_answer_resumes_with_ordered_responses():
             (tool_call("r1"), {"output": "ok"}, None),
             (approval("r2"), {"decision": "approve"}, None),
         )
-        assert drv.run["inputRequests"] is None
+        assert "inputRequests" not in drv.run
         resumed.applied()
         resumed.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -133,7 +133,7 @@ async def test_completing_batch_resumes_once_in_the_same_envelope():
         # the resume dispatched in the batch's own flush: by the time the accepts
         # settle the replica already shows the run in flight
         assert drv.replica["status"] == "running"
-        assert drv.run["inputRequests"] is None
+        assert "inputRequests" not in drv.run
         resumed = await script.next_call()
         assert resumed.ctx.trigger == "input-resume"
         assert [r["id"] for r, _, _ in resumed.ctx.input_outcomes] == ["r1", "r2"]
@@ -324,7 +324,7 @@ async def test_edit_while_parked_clears_requests_and_reruns():
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-edit"
         assert rerun.ctx.rollback_to is None
-        await drv.wait(lambda s: run_of(s)["inputRequests"] is None)
+        await drv.wait(lambda s: "inputRequests" not in run_of(s))
         rerun.applied()
         rerun.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -339,7 +339,7 @@ async def test_reload_while_parked_clears_requests_and_reruns():
         rerun = await script.next_call()
         assert rerun.ctx.trigger == "message-reload"
         assert rerun.ctx.rollback_to == "u1"
-        await drv.wait(lambda s: run_of(s)["inputRequests"] is None)
+        await drv.wait(lambda s: "inputRequests" not in run_of(s))
         rerun.applied()
         rerun.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -358,7 +358,7 @@ async def test_steer_add_while_parked_abandons_input_and_dispatches():
             (approval("r2"), None, None),
         )
         await drv.wait_status("running")
-        assert drv.run["inputRequests"] is None
+        assert "inputRequests" not in drv.run
         run.applied()
         run.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -379,7 +379,7 @@ async def test_steer_add_onto_nonempty_lane_while_parked_dispatches_whole_lane()
         assert [m["id"] for m in run.ctx.messages] == ["s1", "s2"]
         assert run.ctx.input_outcomes == ((tool_call("r1"), None, None),)
         await drv.wait_status("running")
-        assert drv.run["inputRequests"] is None
+        assert "inputRequests" not in drv.run
         run.applied()
         run.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -397,7 +397,7 @@ async def test_promote_to_steer_while_parked_abandons_input_and_dispatches():
         assert run.ctx.trigger == "message-send"
         assert [m["id"] for m in run.ctx.messages] == ["m2"]
         assert run.ctx.input_outcomes == ((tool_call("r1"), None, None),)
-        assert drv.run["inputRequests"] is None
+        assert "inputRequests" not in drv.run
         run.applied()
         run.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -430,7 +430,7 @@ async def test_steer_add_with_partial_answers_hands_over_the_answered_subset():
             (approval("r2"), None, None),
         )
         await drv.wait_status("running")
-        assert drv.run["inputRequests"] is None
+        assert "inputRequests" not in drv.run
         run.applied()
         run.finish(RunManager.Complete())
         await drv.wait_status("ready")
@@ -444,7 +444,7 @@ async def test_answer_meta_replicates_only_when_carried():
             "run/input",
             {"requestId": "r1", "response": {"output": "ok"}, "meta": {"src": "c1"}},
         )
-        await drv.wait(lambda s: "response" in run_of(s)["inputRequests"][0])
+        await drv.wait(lambda s: "response" in run_of(s).get("inputRequests", [{}])[0])
         assert drv.run["inputRequests"][0] == {
             **tool_call("r1"),
             "response": {"output": "ok"},

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/tests/test_restore.py

@@ -107,7 +107,7 @@ async def test_steer_after_a_restart_abandons_input_and_dispatches():
         assert [m["id"] for m in run.ctx.messages] == ["s1"]
         assert run.ctx.input_outcomes == ((tool_call("r1"), None, None),)
         await drv2.wait_status("running")
-        assert drv2.run["inputRequests"] is None
+        assert "inputRequests" not in drv2.run
         run.applied()
         run.finish(RunManager.Complete())
         await drv2.wait_status("ready")

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/tests/test_stopping_window.py

@@ -373,13 +373,14 @@ ENTRY_KEYS = {
     "dispatching",
     "stopping",
     "nextDispatch",
-    "inputRequests",
     "error",
     "stopReason",
 }
 
 
 async def test_entry_keys_are_always_present_and_null_when_empty():
+    """inputRequests is the one absent-when-empty key: present only while a
+    request set is open, matching the TS harness shape."""
     script = Script()
     async with run_host(script) as (drv, host):
         drv.post("run/enqueue", add("m1"))
@@ -388,7 +389,7 @@ async def test_entry_keys_are_always_present_and_null_when_empty():
         assert set(drv.run.keys()) == ENTRY_KEYS
         assert drv.run["dispatching"] is not None
         assert (drv.run["stopping"], drv.run["nextDispatch"]) == (None, None)
-        assert (drv.run["inputRequests"], drv.run["error"]) == (None, None)
+        assert drv.run["error"] is None
         call.applied()
         await drv.wait(lambda s: run_of(s)["dispatching"] is None)
         call.fail(RuntimeError("boom"))
@@ -396,5 +397,5 @@ async def test_entry_keys_are_always_present_and_null_when_empty():
         assert set(drv.run.keys()) == ENTRY_KEYS
         assert drv.run["error"] == {"message": "boom"}
         assert (drv.run["dispatching"], drv.run["stopping"]) == (None, None)
-        assert (drv.run["nextDispatch"], drv.run["inputRequests"]) == (None, None)
+        assert drv.run["nextDispatch"] is None
         assert (drv.run["queue"], drv.run["steerQueue"]) == ([], [])

{harness_sdk_python-0.31.2 → harness_sdk_python-0.32.1}/tests/test_voice_frontend_tools.py

@@ -1,5 +1,5 @@
-"""Frontend function tools contract: ``voice/start {tools}`` reaches the
-provider, matching calls project into ``state["voice"]["toolCalls"]``,
+"""Frontend function tools contract: the caller's synced context ``tools``
+map reaches the provider at ``voice/start``, matching calls project into ``state["voice"]["toolCalls"]``,
 ``voice/temp-frontend-tool-result`` answers them, and the delegated-task
 handler's ``call_frontend_tool`` rides the same projection."""
 
@@ -23,11 +23,13 @@ async def until(predicate, timeout: float = 5) -> None:
         assert asyncio.get_running_loop().time() < deadline, "condition never held"
         await asyncio.sleep(0.01)
 
-TOOL = {
-    "name": "get_local_time",
-    "description": "Read the user's local date and time.",
-    "parameters": {"type": "object", "properties": {}},
+TOOLS = {
+    "get_local_time": {
+        "description": "Read the user's local date and time.",
+        "parameters": {"type": "object", "properties": {}},
+    },
 }
+TOOL = {"name": "get_local_time", **TOOLS["get_local_time"]}
 
 
 def call_of(events, call_id: str = "call-1") -> None:
@@ -38,25 +40,34 @@ def call_of(events, call_id: str = "call-1") -> None:
     )
 
 
-async def test_start_passes_tools_to_the_provider():
+async def test_start_reads_tools_from_the_caller_context():
     bench = Bench()
     async with voice_host(bench) as (drv, _app):
-        rsp = await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context(
+            {"tools": {**TOOLS, "no_desc": {"parameters": {"type": "object"}}}}
+        )
+        rsp = await drv.command("voice/start", {"offer": OFFER})
         assert rsp["type"] == "accepted", rsp
-        assert bench.provider.calls[0] == ("start", OFFER, [], [TOOL])
+        assert bench.provider.calls[0] == (
+            "start",
+            OFFER,
+            [],
+            [TOOL, {"name": "no_desc", "description": "", "parameters": {"type": "object"}}],
+        )
 
 
-async def test_malformed_tools_reject_invalid_message():
+async def test_malformed_context_tools_reject_invalid_message():
     bench = Bench()
     async with voice_host(bench) as (drv, _app):
         for tools in (
-            "not-a-list",
-            [{"name": "", "description": "", "parameters": {}}],
-            [{"name": "a", "description": "d"}],
-            [TOOL, TOOL],
+            "not-a-map",
+            {"": {"description": "", "parameters": {}}},
+            {"a": {"description": "d"}},
+            {"a": "not-a-spec"},
         ):
+            await drv.set_context({"tools": tools})
             assert_rejected(
-                await drv.command("voice/start", {"offer": OFFER, "tools": tools}),
+                await drv.command("voice/start", {"offer": OFFER}),
                 "invalid-message",
             )
         assert bench.provider.calls == []
@@ -65,7 +76,8 @@ async def test_malformed_tools_reject_invalid_message():
 async def test_client_tool_call_projects_into_state():
     bench = Bench()
     async with voice_host(bench) as (drv, _app):
-        await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context({"tools": TOOLS})
+        await drv.command("voice/start", {"offer": OFFER})
         call_of(bench.events())
         await drv.wait(
             lambda s: (voice_of(s) or {}).get("toolCalls")
@@ -78,7 +90,8 @@ async def test_client_tool_call_projects_into_state():
 async def test_tool_result_forwards_and_clears_the_pending_call():
     bench = Bench()
     async with voice_host(bench) as (drv, _app):
-        await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context({"tools": TOOLS})
+        await drv.command("voice/start", {"offer": OFFER})
         call_of(bench.events())
         await drv.wait(lambda s: (voice_of(s) or {}).get("toolCalls") != [])
         rsp = await drv.command(
@@ -93,7 +106,8 @@ async def test_tool_result_forwards_and_clears_the_pending_call():
 async def test_unknown_call_id_rejects_unknown_tool_call():
     bench = Bench()
     async with voice_host(bench) as (drv, _app):
-        await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context({"tools": TOOLS})
+        await drv.command("voice/start", {"offer": OFFER})
         assert_rejected(
             await drv.command(
                 "voice/temp-frontend-tool-result",
@@ -113,7 +127,8 @@ async def test_executor_call_projects_and_the_result_resolves_the_await():
 
     bench.task_handler = handler
     async with voice_host(bench) as (drv, _app):
-        await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context({"tools": TOOLS})
+        await drv.command("voice/start", {"offer": OFFER})
         bench.events().task_requested("d1", "what time is it locally?")
         await drv.wait(lambda s: (voice_of(s) or {}).get("toolCalls") != [])
         [call] = drv.replica["voice"]["toolCalls"]
@@ -142,7 +157,8 @@ async def test_executor_call_with_undeclared_tool_raises_in_the_handler():
 
     bench.task_handler = handler
     async with voice_host(bench) as (drv, _app):
-        await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context({"tools": TOOLS})
+        await drv.command("voice/start", {"offer": OFFER})
         bench.events().task_requested("d1", "open up")
         await until(
             lambda: any(
@@ -170,7 +186,8 @@ async def test_session_end_fails_a_pending_executor_call():
 
     bench.task_handler = handler
     async with voice_host(bench) as (drv, _app):
-        await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context({"tools": TOOLS})
+        await drv.command("voice/start", {"offer": OFFER})
         bench.events().task_requested("d1", "what time is it?")
         await drv.wait(lambda s: (voice_of(s) or {}).get("toolCalls") != [])
         rsp = await drv.command("voice/end")
@@ -183,7 +200,8 @@ async def test_session_end_fails_a_pending_executor_call():
 async def test_tool_result_from_other_client_rejects_not_voice_owner():
     bench = Bench()
     async with voice_host(bench) as (drv, app):
-        await drv.command("voice/start", {"offer": OFFER, "tools": [TOOL]})
+        await drv.set_context({"tools": TOOLS})
+        await drv.command("voice/start", {"offer": OFFER})
         call_of(bench.events())
         await drv.wait(lambda s: (voice_of(s) or {}).get("toolCalls") != [])
         rsp = await side_command(