harness-sdk-python 0.32.0__tar.gz → 0.32.2__tar.gz

{harness_sdk_python-0.32.0 → harness_sdk_python-0.32.2}/PKG-INFO

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

{harness_sdk_python-0.32.0 → harness_sdk_python-0.32.2}/pyproject.toml

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

{harness_sdk_python-0.32.0 → harness_sdk_python-0.32.2}/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.32.0 → harness_sdk_python-0.32.2}/src/harness_sdk/voice.py

@@ -20,7 +20,10 @@ clears the entry. The session is bound to the issuing client's connection: ``voi
 provider ``closed`` event, or the owner staying detached past the
 ``departure_grace`` window (the host's ``client_departed`` hook starts the
 timer, the re-check runs at expiry) ends it; ``voice/start`` while the live
-session's owner is detached ends the orphan and starts the new session.
+session's owner is detached ends the orphan and starts the new session, and
+``voice/start`` from the owner itself supersedes its own session — the owner
+holds one media leg, so a fresh start is the definitive signal the old leg
+died.
 Provider turn
 events render live in ``state["messages"]`` through
 ``Host.upsert_ephemeral_message`` (message id = turn id), tagged
@@ -45,8 +48,8 @@ same ``toolCalls`` projection: the client's ``voice/temp-frontend-tool-result``
 resolves the await instead of forwarding to the provider, and session end
 fails outstanding awaits.
 
-Rejections: ``voice-active`` (a session is already live and its owner
-attached), ``no-voice``
+Rejections: ``voice-active`` (another client's session is live and its
+owner attached), ``no-voice``
 (no voice manager declared, or ``voice/end`` with no session),
 ``not-voice-owner`` (``voice/end`` from another client),
 ``voice-unavailable`` (the factory or ``provider.start`` raised).
@@ -602,12 +605,20 @@ class VoiceManagerNamespace(TrayMapNamespace):
         if self._starting:
             raise _reject("voice-active", "a voice session is already live")
         session = self.live()
-        if session is not None:
-            if self._api.has_subscriber(session.clientId.value):
-                raise _reject("voice-active", "a voice session is already live")
-            await session._end("connection-drop")
+        if (
+            session is not None
+            and session.clientId.value != ctx.caller.client_id
+            and self._api.has_subscriber(session.clientId.value)
+        ):
+            raise _reject("voice-active", "a voice session is already live")
         self._starting = True
         try:
+            if session is not None:
+                await session._end(
+                    "superseded"
+                    if session.clientId.value == ctx.caller.client_id
+                    else "connection-drop"
+                )
             seed = _capped_seed(await self._api.get_voice_seed())
             tray = await self.get_or_create(uuid4().hex)
             assert isinstance(tray, VoiceManager)

{harness_sdk_python-0.32.0 → harness_sdk_python-0.32.2}/tests/run_helpers.py

@@ -408,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.32.0 → harness_sdk_python-0.32.2}/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.32.0 → harness_sdk_python-0.32.2}/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.32.0 → harness_sdk_python-0.32.2}/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.32.0 → harness_sdk_python-0.32.2}/tests/test_voice.py

@@ -48,12 +48,53 @@ async def test_start_seeds_provider_and_projects_session():
         assert bench.contexts[0].client_id == drv.client_id
 
 
-async def test_start_while_active_rejects_voice_active():
+async def test_start_from_the_owner_supersedes_its_own_session():
     bench = Bench()
     async with voice_host(bench) as (drv, _app):
         await drv.command("voice/start", {"offer": OFFER})
+        superseded = bench.provider
+        bench.provider = FakeVoiceProvider()
+        rsp = await drv.command("voice/start", {"offer": OFFER})
+        assert rsp["type"] == "accepted", rsp
+        assert superseded.closed
+        await drv.wait(
+            lambda s: (voice_of(s) or {}).get("clientId") == drv.client_id
+            and (voice_of(s) or {}).get("status") == "live"
+        )
+
+
+async def test_overlapping_start_during_supersede_rejects_voice_active():
+    class SuspendedCloseProvider(FakeVoiceProvider):
+        def __init__(self):
+            super().__init__()
+            self.closing = asyncio.Event()
+            self.release = asyncio.Event()
+
+        async def close(self):
+            self.closing.set()
+            await self.release.wait()
+            await super().close()
+
+    bench = Bench(provider=SuspendedCloseProvider())
+    async with voice_host(bench) as (drv, app):
+        await drv.command("voice/start", {"offer": OFFER})
+        old = bench.provider
+        bench.provider = FakeVoiceProvider()
+        supersede = asyncio.ensure_future(
+            drv.command("voice/start", {"offer": OFFER})
+        )
+        await old.closing.wait()
         assert_rejected(
-            await drv.command("voice/start", {"offer": OFFER}), "voice-active"
+            await side_command(app, drv._client, "voice/start", {"offer": OFFER}),
+            "voice-active",
+        )
+        old.release.set()
+        rsp = await supersede
+        assert rsp["type"] == "accepted", rsp
+        assert [call[0] for call in bench.provider.calls] == ["start"]
+        await drv.wait(
+            lambda s: (voice_of(s) or {}).get("clientId") == drv.client_id
+            and (voice_of(s) or {}).get("status") == "live"
         )