livekit-plugins-duplexjev 0.1.0__tar.gz → 0.2.0__tar.gz

livekit_plugins_duplexjev-0.2.0/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.audio_cache/
+results/
+*.safetensors
+*.pt
+.DS_Store

livekit_plugins_duplexjev-0.2.0/CHANGELOG.md

@@ -0,0 +1,23 @@
+# Changelog
+
+## 0.2.0 (2026-10-13)
+
+- Turn-taking context: `detector.attach(session)` (or `detector.set_assistant_said(text)`) sends the agent's previous
+  message with every request. Needs a gateway from `duplexjev>=0.6`. On LiveKit eot-bench (English,
+  DuplexJev-32B-Para v1.2) false cut-offs at a 300 ms budget drop from 23.5% to 19.7%.
+
+## 0.1.1 (2026-10-12)
+
+- The turn probability is now P(finished) + P(backchannel): a short "ok" / "yeah" with nobody else talking also
+  ends the user's turn ("still talking" and "asking to wait" still hold the turn). On LiveKit eot-bench
+  (DuplexJev-32B-Turn, English) false cut-offs at a 300 ms budget drop from 37% to 30%; Smart Turn test-set accuracy
+  is unchanged.
+
+## 0.1.0 (2026-10-10)
+
+- First release: `duplexjev.TurnDetector`, an audio (streaming) turn detector for LiveKit Agents that asks a
+  DuplexJev gateway for the turn state of the current user turn.
+- Extra questions (emotion, non-verbal sound, barge-in, or your own) answered in the same request; see
+  `last_answers` / `on_answers`.
+- Optional backchannel opportunity from "What should the assistant do now?" (`backchannel_threshold`).
+- Tested with livekit-agents 1.8.6.

{livekit_plugins_duplexjev-0.1.0 → livekit_plugins_duplexjev-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: livekit-plugins-duplexjev
-Version: 0.1.0
+Version: 0.2.0
 Summary: Audio end-of-turn detection for LiveKit Agents with DuplexJev: turn state, emotion and non-verbal sounds from one request, no transcript needed.
 Project-URL: Homepage, https://github.com/adventists-ai/duplexjev/tree/main/integrations/livekit
 Project-URL: Models, https://huggingface.co/adventists-ai/DuplexJev-4B-Para
@@ -66,6 +66,18 @@ session = AgentSession(
 )
 ```
 
+**Give it the agent's last message** (new in 0.2.0). Turn-taking is clearly better when the model knows what the
+agent had just said. Keep a reference to the detector and attach it to the session once:
+
+```python
+detector = duplexjev.TurnDetector(api_url="http://localhost:8420")
+session = AgentSession(..., turn_handling={"turn_detection": detector})
+detector.attach(session)        # follows conversation_item_added; or detector.set_assistant_said(text)
+```
+
+It needs a gateway from `duplexjev>=0.6`. On LiveKit eot-bench (English, DuplexJev-32B-Para v1.2) this cuts false
+cut-offs at a 300 ms budget from 23.5% to 19.7%.
+
 `AgentSession(turn_detection=duplexjev.TurnDetector(), ...)` works too (LiveKit marks that argument as deprecated).
 A complete agent is in [`examples/agent.py`](examples/agent.py).
 
@@ -80,10 +92,10 @@ commits the turn, as with any turn detector, because the LLM needs the text.
 
 ## Run the model yourself (recommended for real-time)
 
-The default URL is our free trial API (rate limited to 30 requests per minute; the round trip from outside mainland China adds network latency). For a live agent, serve the model next to it (DuplexJev-4B-Para needs about 10 GB of GPU memory):
+The default URL is our free trial API (rate limited to 30 requests per minute; the round trip from outside mainland China adds network latency). For a live agent, serve the model next to it (DuplexJev-4B-Para needs about 10 GB of GPU memory; for the best turn-taking use DuplexJev-32B-Para v1.2 on one 80 GB GPU):
 
 ```bash
-pip install "vllm[audio]>=0.29" duplexjev-vllm "duplexjev[server]>=0.4.1"
+pip install "vllm[audio]>=0.29" duplexjev-vllm "duplexjev[server]>=0.6"
 vllm serve adventists-ai/DuplexJev-4B-Para --max-model-len 4096 --port 8000 &
 duplexjev gateway --vllm http://localhost:8000/v1 --port 8420
 ```

{livekit_plugins_duplexjev-0.1.0 → livekit_plugins_duplexjev-0.2.0}/README.md

@@ -40,6 +40,18 @@ session = AgentSession(
 )
 ```
 
+**Give it the agent's last message** (new in 0.2.0). Turn-taking is clearly better when the model knows what the
+agent had just said. Keep a reference to the detector and attach it to the session once:
+
+```python
+detector = duplexjev.TurnDetector(api_url="http://localhost:8420")
+session = AgentSession(..., turn_handling={"turn_detection": detector})
+detector.attach(session)        # follows conversation_item_added; or detector.set_assistant_said(text)
+```
+
+It needs a gateway from `duplexjev>=0.6`. On LiveKit eot-bench (English, DuplexJev-32B-Para v1.2) this cuts false
+cut-offs at a 300 ms budget from 23.5% to 19.7%.
+
 `AgentSession(turn_detection=duplexjev.TurnDetector(), ...)` works too (LiveKit marks that argument as deprecated).
 A complete agent is in [`examples/agent.py`](examples/agent.py).
 
@@ -54,10 +66,10 @@ commits the turn, as with any turn detector, because the LLM needs the text.
 
 ## Run the model yourself (recommended for real-time)
 
-The default URL is our free trial API (rate limited to 30 requests per minute; the round trip from outside mainland China adds network latency). For a live agent, serve the model next to it (DuplexJev-4B-Para needs about 10 GB of GPU memory):
+The default URL is our free trial API (rate limited to 30 requests per minute; the round trip from outside mainland China adds network latency). For a live agent, serve the model next to it (DuplexJev-4B-Para needs about 10 GB of GPU memory; for the best turn-taking use DuplexJev-32B-Para v1.2 on one 80 GB GPU):
 
 ```bash
-pip install "vllm[audio]>=0.29" duplexjev-vllm "duplexjev[server]>=0.4.1"
+pip install "vllm[audio]>=0.29" duplexjev-vllm "duplexjev[server]>=0.6"
 vllm serve adventists-ai/DuplexJev-4B-Para --max-model-len 4096 --port 8000 &
 duplexjev gateway --vllm http://localhost:8000/v1 --port 8420
 ```

{livekit_plugins_duplexjev-0.1.0 → livekit_plugins_duplexjev-0.2.0}/livekit/plugins/duplexjev/turn_detector.py

@@ -8,6 +8,10 @@ exposed on ``last_answers`` / ``on_answers``.
 This module implements LiveKit's *streaming* (audio) turn-detector protocol: ``AgentSession`` pushes every input
 audio frame into the stream, calls ``predict()`` once the VAD has seen ~200 ms of silence, and waits up to
 ``prediction_timeout`` for the resulting ``TurnDetectionEvent``.
+
+Turn-taking is markedly better when the model also knows what the agent had just said. Call
+``detector.attach(session)`` once after creating the ``AgentSession`` (it follows ``conversation_item_added``), or
+set it yourself with ``detector.set_assistant_said(text)``.
 """
 
 from __future__ import annotations
@@ -173,6 +177,27 @@ class TurnDetector:
         """Answers of the latest successful request: ``{id: {"answer", "confidence", "probs"}}``."""
         self.last_server_ms: float | None = None
         """Server-side model time of the latest request, in milliseconds."""
+        self.assistant_said: str = ""
+        """The agent's previous message, sent with every request (last 300 characters)."""
+
+    def set_assistant_said(self, text: str | None) -> None:
+        """What the agent said just before the user's current turn."""
+        self.assistant_said = " ".join((text or "").split())[-300:]
+
+    def attach(self, session: Any) -> None:
+        """Keep ``assistant_said`` up to date from an ``AgentSession``'s ``conversation_item_added`` events."""
+
+        def _on_item(ev: Any) -> None:
+            item = getattr(ev, "item", None)
+            if getattr(item, "role", None) != "assistant":
+                return
+            text = getattr(item, "text_content", None)
+            if callable(text):
+                text = text()
+            if text:
+                self.set_assistant_said(text)
+
+        session.on("conversation_item_added", _on_item)
 
     def _as_question(self, q: str | dict[str, Any]) -> dict[str, Any]:
         if isinstance(q, str):
@@ -366,6 +391,8 @@ class TurnDetectorStream:
         det = self._detector
         payload = {"audio_b64": base64.b64encode(wav).decode(), "format": "wav", "lang": det._lang,
                    "questions": det._questions}
+        if det.assistant_said:
+            payload["assistant_said"] = det.assistant_said
         try:
             async with self._http().post(
                 det._decide_url, json=payload, headers=det._headers,
@@ -377,7 +404,9 @@ class TurnDetectorStream:
                 data = await resp.json()
             answers: dict[str, Any] = data["answers"]
             probs = answers["turn"]["probs"]
-            p_finished = float(probs.get(TURN_QUESTION[det._lang]["options"][0], 0.0))
+            o = TURN_QUESTION[det._lang]["options"]
+            # finished + backchannel: a short "ok" / "yeah" with nobody else talking also ends the turn
+            p_finished = float(probs.get(o[0], 0.0)) + float(probs.get(o[2], 0.0))
         except asyncio.CancelledError:
             raise
         except Exception as e:  # network or server error: never block the conversation

livekit_plugins_duplexjev-0.2.0/livekit/plugins/duplexjev/version.py

@@ -0,0 +1 @@
+__version__ = "0.2.0"

{livekit_plugins_duplexjev-0.1.0 → livekit_plugins_duplexjev-0.2.0}/tests/test_turn_detector.py

@@ -172,3 +172,36 @@ async def test_agent_session_accepts_it(gateway):
     det = duplexjev.TurnDetector(api_url=gateway.url)
     session = AgentSession(turn_handling={"turn_detection": det})
     assert session.turn_detection is det
+
+
+async def test_assistant_said_is_sent_and_attach_follows_session(gateway):
+    det = duplexjev.TurnDetector(api_url=gateway.url)
+    stream = det.stream()
+    push(stream, 1.0)
+    await asyncio.wait_for(stream.predict(), 2)
+    assert "assistant_said" not in gateway.requests[-1]
+
+    handlers = {}
+
+    class FakeSession:
+        def on(self, name, fn):
+            handlers[name] = fn
+
+    class Item:
+        def __init__(self, role, text):
+            self.role, self.text_content = role, text
+
+    class Ev:
+        def __init__(self, item):
+            self.item = item
+
+    det.attach(FakeSession())
+    handlers["conversation_item_added"](Ev(Item("user", "hello")))
+    assert det.assistant_said == ""
+    handlers["conversation_item_added"](Ev(Item("assistant", "Sure,  what time\nworks for you?")))
+    assert det.assistant_said == "Sure, what time works for you?"
+    await asyncio.wait_for(stream.predict(), 2)
+    assert gateway.requests[-1]["assistant_said"] == "Sure, what time works for you?"
+    det.set_assistant_said("y" * 500)
+    assert len(det.assistant_said) == 300
+    await stream.aclose()

livekit_plugins_duplexjev-0.1.0/CHANGELOG.md

@@ -1,10 +0,0 @@
-# Changelog
-
-## 0.1.0 (2026-10-10)
-
-- First release: `duplexjev.TurnDetector`, an audio (streaming) turn detector for LiveKit Agents that asks a
-  DuplexJev gateway for the turn state of the current user turn.
-- Extra questions (emotion, non-verbal sound, barge-in, or your own) answered in the same request; see
-  `last_answers` / `on_answers`.
-- Optional backchannel opportunity from "What should the assistant do now?" (`backchannel_threshold`).
-- Tested with livekit-agents 1.8.6.

livekit_plugins_duplexjev-0.1.0/livekit/plugins/duplexjev/version.py

@@ -1 +0,0 @@
-__version__ = "0.1.0"