harness-sdk-python 0.31.0__tar.gz → 0.31.1__tar.gz

{harness_sdk_python-0.31.0 → harness_sdk_python-0.31.1}/PKG-INFO

@@ -1,12 +1,12 @@
 Metadata-Version: 2.5
 Name: harness-sdk-python
-Version: 0.31.0
+Version: 0.31.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.15,>=0.14.0
-Requires-Dist: statewire<0.13,>=0.12.0
+Requires-Dist: statewire<0.13,>=0.12.3
 Provides-Extra: deepagents
 Requires-Dist: deepagents>=0.6.12; extra == 'deepagents'
 Requires-Dist: langchain-core>=0.3; extra == 'deepagents'

{harness_sdk_python-0.31.0 → harness_sdk_python-0.31.1}/pyproject.toml

@@ -1,11 +1,11 @@
 [project]
 name = "harness-sdk-python"
-version = "0.31.0"
+version = "0.31.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.12.0,<0.13", "pinned>=0.14.0,<0.15"]
+dependencies = ["statewire>=0.12.3,<0.13", "pinned>=0.14.0,<0.15"]
 
 [project.optional-dependencies]
 postgres = ["langgraph-checkpoint-postgres>=2.0.0"]

{harness_sdk_python-0.31.0 → harness_sdk_python-0.31.1}/src/harness_sdk/__init__.py

@@ -21,6 +21,7 @@ from .voice import (
     end_voice,
     start_voice,
     temp_frontend_tool_result,
+    voice_client_departed,
     voice_manager,
 )
 
@@ -47,5 +48,6 @@ __all__ = [
     "run_manager",
     "start_voice",
     "temp_frontend_tool_result",
+    "voice_client_departed",
     "voice_manager",
 ]

{harness_sdk_python-0.31.0 → harness_sdk_python-0.31.1}/src/harness_sdk/voice.py

@@ -16,7 +16,11 @@ projects into ``toolCalls`` as ``{callId, name, arguments}``; the owning
 client answers it with ``voice/temp-frontend-tool-result {call_id,
 output}``, which forwards through ``provider.return_tool_result`` and
 clears the entry. The session is bound to the issuing client's connection: ``voice/end`` from the owner, a
-provider ``closed`` event, or a connection drop ends it. Provider turn
+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.
+Provider turn
 events render live in ``state["messages"]`` through
 ``Host.upsert_ephemeral_message`` (message id = turn id), tagged
 ``ephemeral: true`` on the wire; each completed
@@ -40,7 +44,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), ``no-voice``
+Rejections: ``voice-active`` (a session is already 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).
@@ -111,7 +116,7 @@ class VoiceManager(Tray):
     buffer rendered live in ``state["messages"]``; completed turns commit
     per turn and ended sessions flush and self-delete."""
 
-    connection_poll = 0.5
+    departure_grace = 10.0
 
     clientId = observable(None)
     status = observable("connecting")
@@ -133,7 +138,7 @@ class VoiceManager(Tray):
         self._turns: list[dict[str, Any]] = []
         self._flushing = asyncio.Lock()
         self._ended = False
-        self._watcher: "asyncio.Task[Any] | None" = None
+        self._grace: "asyncio.Task[Any] | None" = None
         self._handoff_pending: list[dict[str, str]] = []
         self._seen_requests: set[str] = set()
         self._delegating = asyncio.Lock()
@@ -261,12 +266,18 @@ class VoiceManager(Tray):
         self._provider = provider
         self.status.value = "live"
         applied()
-        self._watcher = self._spawn(self._watch(caller))
         return {"answer": answer}
 
-    async def _watch(self, caller: Any) -> None:
-        while caller.is_connected:
-            await asyncio.sleep(self.connection_poll)
+    def client_departed(self) -> None:
+        if self._ended or self._grace is not None:
+            return
+        self._grace = self._spawn(self._departure_expired())
+
+    async def _departure_expired(self) -> None:
+        await asyncio.sleep(self.departure_grace)
+        self._grace = None
+        if self._host.has_subscriber(self.clientId.value):
+            return
         await self._background_end("connection-drop")
 
     async def _background_end(self, reason: str) -> None:
@@ -279,9 +290,9 @@ class VoiceManager(Tray):
         if self._ended:
             return
         self._ended = True
-        watcher, self._watcher = self._watcher, None
-        if watcher is not None and watcher is not asyncio.current_task():
-            watcher.cancel()
+        grace, self._grace = self._grace, None
+        if grace is not None and grace is not asyncio.current_task():
+            grace.cancel()
         provider, self._provider = self._provider, None
         if provider is not None:
             try:
@@ -560,6 +571,11 @@ class VoiceManagerNamespace(TrayMapNamespace):
         session = self._session
         return session if session is not None and not session._ended else None
 
+    def client_departed(self, client_id: str) -> None:
+        session = self.live()
+        if session is not None and session.clientId.value == client_id:
+            session.client_departed()
+
     def _mount(self, tray: VoiceManager) -> None:
         if tray.storage._restored:
             return  # a crash's leftover row: the pump finishes its delete unmounted
@@ -578,8 +594,13 @@ class VoiceManagerNamespace(TrayMapNamespace):
         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"))
-        if self._starting or self.live() is not None:
+        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")
         self._starting = True
         try:
             seed = _capped_seed(await self._api.get_voice_seed())
@@ -675,6 +696,13 @@ async def end_voice(host: Any, *, ctx: Any) -> None:
     return await namespace.end(ctx=ctx)
 
 
+def voice_client_departed(host: Any, client_id: str) -> None:
+    """The Statewire ``client_departed`` hook body: routes to the host's declared voice manager."""
+    namespace = _voice_of(host)
+    if namespace is not None:
+        namespace.client_departed(client_id)
+
+
 async def temp_frontend_tool_result(host: Any, params: Any, *, ctx: Any) -> None:
     """The ``voice/temp-frontend-tool-result`` command body: routes to the host's declared voice manager."""
     namespace = _voice_of(host)

{harness_sdk_python-0.31.0 → harness_sdk_python-0.31.1}/tests/test_voice.py

@@ -276,19 +276,23 @@ async def test_provider_closed_event_ends_and_commits():
         assert_rejected(await drv.command("voice/end"), "no-voice")
 
 
-async def test_connection_drop_ends_session(monkeypatch):
-    monkeypatch.setattr(VoiceManager, "connection_poll", 0.02)
+async def start_from_second_client(drv, stream, *, client_id="c2"):
+    await stream.next_event()
+    response = await post_frame(
+        drv._client,
+        {"cmd": [_statement("voice/start", {"offer": OFFER}, 1)]},
+        client_id=client_id,
+    )
+    assert response.status_code == 200, response.text
+    await drv.wait(lambda s: (voice_of(s) or {}).get("clientId") == client_id)
+
+
+async def test_connection_drop_ends_session_after_grace(monkeypatch):
+    monkeypatch.setattr(VoiceManager, "departure_grace", 0.05)
     bench = Bench()
     async with voice_host(bench) as (drv, app):
         async with stream_of(app, client_id="c2") as stream:
-            await stream.next_event()
-            response = await post_frame(
-                drv._client,
-                {"cmd": [_statement("voice/start", {"offer": OFFER}, 1)]},
-                client_id="c2",
-            )
-            assert response.status_code == 200, response.text
-            await drv.wait(lambda s: (voice_of(s) or {}).get("clientId") == "c2")
+            await start_from_second_client(drv, stream)
             events = bench.events()
             events.turn_started("t1", "user")
             events.turn_done("t1", "dropped mid-call")
@@ -299,6 +303,46 @@ async def test_connection_drop_ends_session(monkeypatch):
         ]
 
 
+async def test_reattach_within_grace_keeps_the_session(monkeypatch):
+    monkeypatch.setattr(VoiceManager, "departure_grace", 0.2)
+    bench = Bench()
+    async with voice_host(bench) as (drv, app):
+        async with stream_of(app, client_id="c2") as stream:
+            await start_from_second_client(drv, stream)
+        async with stream_of(app, client_id="c2") as stream:
+            await stream.next_event()
+            await asyncio.sleep(0.4)
+            await drv.wait(lambda s: (voice_of(s) or {}).get("status") == "live")
+            assert not bench.provider.closed
+
+
+async def test_start_over_a_detached_owner_replaces_the_session():
+    bench = Bench()
+    async with voice_host(bench) as (drv, app):
+        async with stream_of(app, client_id="c2") as stream:
+            await start_from_second_client(drv, stream)
+        orphaned = bench.provider
+        bench.provider = FakeVoiceProvider()
+        rsp = await drv.command("voice/start", {"offer": OFFER})
+        assert rsp["type"] == "accepted", rsp
+        assert orphaned.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_start_over_an_attached_owner_still_rejects_voice_active():
+    bench = Bench()
+    async with voice_host(bench) as (drv, app):
+        async with stream_of(app, client_id="c2") as stream:
+            await start_from_second_client(drv, stream)
+            assert_rejected(
+                await drv.command("voice/start", {"offer": OFFER}), "voice-active"
+            )
+            assert not bench.provider.closed
+
+
 async def test_seed_takes_the_128_tail():
     bench = Bench(transcript=[seed_message(i) for i in range(130)])
     async with voice_host(bench) as (drv, _app):

{harness_sdk_python-0.31.0 → harness_sdk_python-0.31.1}/tests/voice_helpers.py

@@ -16,6 +16,7 @@ from harness_sdk import (
     end_voice,
     start_voice,
     temp_frontend_tool_result,
+    voice_client_departed,
     voice_manager,
 )
 
@@ -139,6 +140,9 @@ def make_voice_host(bench: Bench, *, declare: bool = True):
         async def voice_tool_result(self, params, *, ctx):
             return await temp_frontend_tool_result(self, params, ctx=ctx)
 
+        def client_departed(self, client_id):
+            voice_client_departed(self, client_id)
+
     if not declare:
         return Host