livekit-plugins-turn-detector 1.3.9__tar.gz

livekit_plugins_turn_detector-1.3.9/.gitignore

@@ -0,0 +1,179 @@
+**/.vscode
+**/.DS_Store
+
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# trunk
+.trunk/
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+.idea/
+
+node_modules
+
+credentials.json
+pyrightconfig.json
+docs/
+
+# Database files
+*.db
+
+
+# Examples for development
+examples/dev/*

livekit_plugins_turn_detector-1.3.9/PKG-INFO

@@ -0,0 +1,98 @@
+Metadata-Version: 2.4
+Name: livekit-plugins-turn-detector
+Version: 1.3.9
+Summary: End of utterance detection for LiveKit Agents
+Project-URL: Documentation, https://docs.livekit.io
+Project-URL: Website, https://livekit.io/
+Project-URL: Source, https://github.com/livekit/agents
+Author-email: LiveKit <hello@livekit.io>
+License-Expression: Apache-2.0
+Keywords: ai,audio,livekit,realtime,video,voice,webrtc
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Topic :: Multimedia :: Sound/Audio
+Classifier: Topic :: Multimedia :: Video
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.9.0
+Requires-Dist: jinja2
+Requires-Dist: livekit-agents>=1.3.9
+Requires-Dist: numpy>=1.26
+Requires-Dist: onnxruntime>=1.18
+Requires-Dist: transformers<=4.57.1,>=4.47.1
+Description-Content-Type: text/markdown
+
+# Turn detector plugin for LiveKit Agents
+
+This plugin introduces end-of-turn detection for LiveKit Agents using a custom open-weight model to determine when a user has finished speaking.
+
+Traditional voice agents use VAD (voice activity detection) for end-of-turn detection. However, VAD models lack language understanding, often causing false positives where the agent interrupts the user before they finish speaking.
+
+By leveraging a language model specifically trained for this task, this plugin offers a more accurate and robust method for detecting end-of-turns.
+
+See [https://docs.livekit.io/agents/build/turns/turn-detector/](https://docs.livekit.io/agents/build/turns/turn-detector/) for more information.
+
+## Installation
+
+```bash
+pip install livekit-plugins-turn-detector
+```
+
+## Usage
+
+### Multilingual model
+
+We've trained a multilingual model that supports the following languages: `English, French, Spanish, German, Italian, Portuguese, Dutch, Chinese, Japanese, Korean, Indonesian, Russian, Turkish`
+
+The multilingual model requires ~400MB of RAM and completes inferences in ~25ms.
+
+```python
+from livekit.plugins.turn_detector.multilingual import MultilingualModel
+
+session = AgentSession(
+    ...
+    turn_detection=MultilingualModel(),
+)
+```
+
+### Usage with RealtimeModel
+
+The turn detector can be used even with speech-to-speech models such as OpenAI's Realtime API. You'll need to provide a separate STT to ensure our model has access to the text content.
+
+```python
+session = AgentSession(
+    ...
+    stt=deepgram.STT(model="nova-3", language="multi"),
+    llm=openai.realtime.RealtimeModel(),
+    turn_detection=MultilingualModel(),
+)
+```
+
+## Running your agent
+
+This plugin requires model files. Before starting your agent for the first time, or when building Docker images for deployment, run the following command to download the model files:
+
+```bash
+python my_agent.py download-files
+```
+
+## Downloaded model files
+
+Model files are downloaded to and loaded from the location specified by the `HF_HUB_CACHE` environment variable. If not set, this defaults to `$HF_HOME/hub` (typically `~/.cache/huggingface/hub`).
+
+For offline deployment, download the model files first while connected to the internet, then copy the cache directory to your deployment environment.
+
+## Model system requirements
+
+The end-of-turn model is optimized to run on CPUs with modest system requirements. It is designed to run on the same server hosting your agents.
+
+The model requires <500MB of RAM and runs within a shared inference server, supporting multiple concurrent sessions.
+
+## License
+
+The plugin source code is licensed under the Apache-2.0 license.
+
+The end-of-turn model is licensed under the [LiveKit Model License](https://huggingface.co/livekit/turn-detector/blob/main/LICENSE).

livekit_plugins_turn_detector-1.3.9/README.md

@@ -0,0 +1,71 @@
+# Turn detector plugin for LiveKit Agents
+
+This plugin introduces end-of-turn detection for LiveKit Agents using a custom open-weight model to determine when a user has finished speaking.
+
+Traditional voice agents use VAD (voice activity detection) for end-of-turn detection. However, VAD models lack language understanding, often causing false positives where the agent interrupts the user before they finish speaking.
+
+By leveraging a language model specifically trained for this task, this plugin offers a more accurate and robust method for detecting end-of-turns.
+
+See [https://docs.livekit.io/agents/build/turns/turn-detector/](https://docs.livekit.io/agents/build/turns/turn-detector/) for more information.
+
+## Installation
+
+```bash
+pip install livekit-plugins-turn-detector
+```
+
+## Usage
+
+### Multilingual model
+
+We've trained a multilingual model that supports the following languages: `English, French, Spanish, German, Italian, Portuguese, Dutch, Chinese, Japanese, Korean, Indonesian, Russian, Turkish`
+
+The multilingual model requires ~400MB of RAM and completes inferences in ~25ms.
+
+```python
+from livekit.plugins.turn_detector.multilingual import MultilingualModel
+
+session = AgentSession(
+    ...
+    turn_detection=MultilingualModel(),
+)
+```
+
+### Usage with RealtimeModel
+
+The turn detector can be used even with speech-to-speech models such as OpenAI's Realtime API. You'll need to provide a separate STT to ensure our model has access to the text content.
+
+```python
+session = AgentSession(
+    ...
+    stt=deepgram.STT(model="nova-3", language="multi"),
+    llm=openai.realtime.RealtimeModel(),
+    turn_detection=MultilingualModel(),
+)
+```
+
+## Running your agent
+
+This plugin requires model files. Before starting your agent for the first time, or when building Docker images for deployment, run the following command to download the model files:
+
+```bash
+python my_agent.py download-files
+```
+
+## Downloaded model files
+
+Model files are downloaded to and loaded from the location specified by the `HF_HUB_CACHE` environment variable. If not set, this defaults to `$HF_HOME/hub` (typically `~/.cache/huggingface/hub`).
+
+For offline deployment, download the model files first while connected to the internet, then copy the cache directory to your deployment environment.
+
+## Model system requirements
+
+The end-of-turn model is optimized to run on CPUs with modest system requirements. It is designed to run on the same server hosting your agents.
+
+The model requires <500MB of RAM and runs within a shared inference server, supporting multiple concurrent sessions.
+
+## License
+
+The plugin source code is licensed under the Apache-2.0 license.
+
+The end-of-turn model is licensed under the [LiveKit Model License](https://huggingface.co/livekit/turn-detector/blob/main/LICENSE).

livekit_plugins_turn_detector-1.3.9/livekit/plugins/turn_detector/__init__.py

@@ -0,0 +1,32 @@
+# Copyright 2023 LiveKit, Inc.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+"""Contextually-aware turn detection for LiveKit Agents
+
+See https://docs.livekit.io/agents/build/turns/turn-detector/ for more information.
+"""
+
+from .version import __version__
+
+__all__ = ["english", "multilingual", "__version__"]
+
+
+# Cleanup docs of unexported modules
+_module = dir()
+NOT_IN_ALL = [m for m in _module if m not in __all__]
+
+__pdoc__ = {}
+
+for n in NOT_IN_ALL:
+    __pdoc__[n] = False

livekit_plugins_turn_detector-1.3.9/livekit/plugins/turn_detector/base.py

@@ -0,0 +1,295 @@
+from __future__ import annotations
+
+import asyncio
+import json
+import logging
+import math
+import re
+import time
+import unicodedata
+from abc import ABC, abstractmethod
+from typing import Any
+
+from huggingface_hub import errors
+
+from livekit.agents import Plugin, llm
+from livekit.agents.inference_runner import _InferenceRunner
+from livekit.agents.ipc.inference_executor import InferenceExecutor
+from livekit.agents.job import get_job_context
+from livekit.agents.utils import hw
+
+from .log import logger
+from .models import HG_MODEL, MODEL_REVISIONS, ONNX_FILENAME, EOUModelType
+from .version import __version__
+
+MAX_HISTORY_TOKENS = 128
+MAX_HISTORY_TURNS = 6
+
+
+def _download_from_hf_hub(repo_id: str, filename: str, **kwargs: Any) -> str:
+    from huggingface_hub import hf_hub_download
+
+    try:
+        local_path = hf_hub_download(repo_id=repo_id, filename=filename, **kwargs)
+    except (errors.LocalEntryNotFoundError, OSError):
+        logger.error(
+            f'Could not find file "{filename}". '
+            "Make sure you have downloaded the model before running the agent. "
+            "Use `python3 your_agent.py download-files` to download the model."
+        )
+        raise RuntimeError(
+            "livekit-plugins-turn-detector initialization failed. "
+            f'Could not find file "{filename}".'
+        ) from None
+    return local_path
+
+
+class _EUORunnerBase(_InferenceRunner):
+    @classmethod
+    @abstractmethod
+    def model_type(cls) -> EOUModelType: ...
+
+    @classmethod
+    def model_revision(cls) -> str:
+        return MODEL_REVISIONS[cls.model_type()]
+
+    def _normalize_text(self, text: str) -> str:
+        if not text:
+            return ""
+
+        text = unicodedata.normalize("NFKC", text.lower())
+        text = "".join(
+            ch
+            for ch in text
+            if not (unicodedata.category(ch).startswith("P") and ch not in ["'", "-"])
+        )
+        text = re.sub(r"\s+", " ", text).strip()
+        return text
+
+    def _format_chat_ctx(self, chat_ctx: list[dict[str, Any]]) -> str:
+        new_chat_ctx = []
+        last_msg: dict[str, Any] | None = None
+        for msg in chat_ctx:
+            if not msg["content"]:
+                continue
+
+            content = self._normalize_text(msg["content"])
+
+            # need to combine adjacent turns together to match training data
+            if last_msg and last_msg["role"] == msg["role"]:
+                last_msg["content"] += f" {content}"
+            else:
+                msg["content"] = content
+                new_chat_ctx.append(msg)
+                last_msg = msg
+
+        convo_text = self._tokenizer.apply_chat_template(
+            new_chat_ctx, add_generation_prompt=False, add_special_tokens=False, tokenize=False
+        )
+
+        # remove the EOU token from current utterance
+        ix = convo_text.rfind("<|im_end|>")
+        text = convo_text[:ix]
+        return text  # type: ignore
+
+    def initialize(self) -> None:
+        logger = logging.getLogger("transformers")
+
+        class _SuppressSpecific(logging.Filter):
+            def filter(self, record: logging.LogRecord) -> bool:
+                msg = record.getMessage()
+                return not msg.startswith(
+                    "None of PyTorch, TensorFlow >= 2.0, or Flax have been found."
+                )
+
+        filt = _SuppressSpecific()
+        # filter this log since it conflicts with the console CLI (since it directly prints to stdout)
+        logger.addFilter(filt)
+        try:
+            import onnxruntime as ort  # type: ignore
+            from huggingface_hub import errors
+            from transformers import AutoTokenizer  # type: ignore
+        finally:
+            logger.removeFilter(filt)
+
+        revision = self.__class__.model_revision()
+        try:
+            local_path_onnx = _download_from_hf_hub(
+                HG_MODEL,
+                ONNX_FILENAME,
+                subfolder="onnx",
+                revision=revision,
+                local_files_only=True,
+            )
+            sess_options = ort.SessionOptions()
+            sess_options.intra_op_num_threads = max(
+                1, min(math.ceil(hw.get_cpu_monitor().cpu_count()) // 2, 4)
+            )
+            sess_options.inter_op_num_threads = 1
+            sess_options.add_session_config_entry("session.dynamic_block_base", "4")
+            self._session = ort.InferenceSession(
+                local_path_onnx, providers=["CPUExecutionProvider"], sess_options=sess_options
+            )
+            self._tokenizer = AutoTokenizer.from_pretrained(
+                HG_MODEL,
+                revision=revision,
+                local_files_only=True,
+                truncation_side="left",
+            )
+
+        except (errors.LocalEntryNotFoundError, OSError):
+            logger.error(
+                f"Could not find model {HG_MODEL} with revision {revision}. "
+                "Make sure you have downloaded the model before running the agent. "
+                "Use `python3 your_agent.py download-files` to download the models."
+            )
+            raise RuntimeError(
+                "livekit-plugins-turn-detector initialization failed. "
+                f"Could not find model {HG_MODEL} with revision {revision}."
+            ) from None
+
+    def run(self, data: bytes) -> bytes | None:
+        data_json = json.loads(data)
+        chat_ctx = data_json.get("chat_ctx", None)
+
+        if not chat_ctx:
+            raise ValueError("chat_ctx is required on the inference input data")
+
+        start_time = time.perf_counter()
+        text = self._format_chat_ctx(chat_ctx)
+        inputs = self._tokenizer(
+            text,
+            add_special_tokens=False,
+            return_tensors="np",
+            max_length=MAX_HISTORY_TOKENS,
+            truncation=True,
+        )
+        # run inference
+        outputs = self._session.run(None, {"input_ids": inputs["input_ids"].astype("int64")})
+        eou_probability = outputs[0].flatten()[-1]
+        end_time = time.perf_counter()
+
+        result: dict[str, Any] = {
+            "eou_probability": float(eou_probability),
+            "duration": round(end_time - start_time, 3),
+            "input": text,
+        }
+        return json.dumps(result).encode()
+
+    @classmethod
+    def _download_files(cls) -> None:
+        from transformers import AutoTokenizer
+
+        # ensure the tokenizer is downloaded
+        AutoTokenizer.from_pretrained(HG_MODEL, revision=cls.model_revision())
+        _download_from_hf_hub(
+            HG_MODEL, ONNX_FILENAME, subfolder="onnx", revision=cls.model_revision()
+        )
+        _download_from_hf_hub(HG_MODEL, "languages.json", revision=cls.model_revision())
+
+
+class EOUPlugin(Plugin):
+    def __init__(self, runner: type[_EUORunnerBase]) -> None:
+        super().__init__(__name__, __version__, __package__, logger)
+        self._runner_class = runner
+
+    def download_files(self) -> None:
+        self._runner_class._download_files()
+
+
+class EOUModelBase(ABC):
+    def __init__(
+        self,
+        model_type: EOUModelType = "en",  # default to smaller, english-only model
+        inference_executor: InferenceExecutor | None = None,
+        # if set, overrides the per-language threshold tuned for accuracy.
+        # not recommended unless you're confident in the impact.
+        unlikely_threshold: float | None = None,
+        load_languages: bool = True,
+    ) -> None:
+        self._model_type = model_type
+        self._executor = inference_executor or get_job_context().inference_executor
+        self._unlikely_threshold = unlikely_threshold
+        self._languages: dict[str, Any] = {}
+
+        if load_languages:
+            config_fname = _download_from_hf_hub(
+                HG_MODEL,
+                "languages.json",
+                revision=MODEL_REVISIONS[self._model_type],
+                local_files_only=True,
+            )
+            with open(config_fname) as f:
+                self._languages = json.load(f)
+
+    @property
+    def model(self) -> str:
+        return self._model_type
+
+    @property
+    def provider(self) -> str:
+        return "livekit"
+
+    @abstractmethod
+    def _inference_method(self) -> str: ...
+
+    async def unlikely_threshold(self, language: str | None) -> float | None:
+        if language is None:
+            return None
+
+        # try the full language code first
+        lang = language.lower()
+        lang_data = self._languages.get(lang)
+
+        # try the base language if the full language code is not found
+        if lang_data is None and "-" in lang:
+            base_lang = lang.split("-")[0]
+            lang_data = self._languages.get(base_lang)
+
+        if not lang_data:
+            return None
+
+        # if a custom threshold is provided, use it
+        if self._unlikely_threshold is not None:
+            return self._unlikely_threshold
+        else:
+            return lang_data["threshold"]  # type: ignore
+
+    async def supports_language(self, language: str | None) -> bool:
+        return await self.unlikely_threshold(language) is not None
+
+    # our EOU model inference should be fast, 3 seconds is more than enough
+    async def predict_end_of_turn(
+        self,
+        chat_ctx: llm.ChatContext,
+        *,
+        timeout: float | None = 3,
+    ) -> float:
+        messages: list[dict[str, Any]] = []
+        for item in chat_ctx.items:
+            if item.type != "message":
+                continue
+
+            if item.role not in ("user", "assistant"):
+                continue
+
+            text_content = item.text_content
+            if text_content:
+                messages.append(
+                    {
+                        "role": item.role,
+                        "content": text_content,
+                    }
+                )
+
+        messages = messages[-MAX_HISTORY_TURNS:]
+        json_data = json.dumps({"chat_ctx": messages}).encode()
+
+        result = await asyncio.wait_for(
+            self._executor.do_inference(self._inference_method(), json_data), timeout=timeout
+        )
+        assert result is not None, "end_of_utterance prediction should always returns a result"
+
+        result_json: dict[str, Any] = json.loads(result.decode())
+        logger.debug("eou prediction", extra=result_json)
+        return result_json["eou_probability"]  # type: ignore

livekit_plugins_turn_detector-1.3.9/livekit/plugins/turn_detector/english.py

@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from livekit.agents import Plugin
+from livekit.agents.inference_runner import _InferenceRunner
+
+from .base import EOUModelBase, EOUPlugin, _EUORunnerBase
+from .models import EOUModelType
+
+
+class _EUORunnerEn(_EUORunnerBase):
+    INFERENCE_METHOD = "lk_end_of_utterance_en"
+
+    @classmethod
+    def model_type(cls) -> EOUModelType:
+        return "en"
+
+    def _normalize_text(self, text: str) -> str:
+        """
+        The english model is trained on the original chat context without normalization.
+        """
+        if not text:
+            return ""
+
+        return text
+
+
+class EnglishModel(EOUModelBase):
+    def __init__(self, *, unlikely_threshold: float | None = None):
+        super().__init__(model_type="en", unlikely_threshold=unlikely_threshold)
+
+    def _inference_method(self) -> str:
+        return _EUORunnerEn.INFERENCE_METHOD
+
+
+_InferenceRunner.register_runner(_EUORunnerEn)
+Plugin.register_plugin(EOUPlugin(_EUORunnerEn))

livekit_plugins_turn_detector-1.3.9/livekit/plugins/turn_detector/log.py

@@ -0,0 +1,3 @@
+import logging
+
+logger = logging.getLogger("livekit.plugins.turn_detector")

livekit_plugins_turn_detector-1.3.9/livekit/plugins/turn_detector/models.py

@@ -0,0 +1,9 @@
+from typing import Literal
+
+EOUModelType = Literal["en", "multilingual"]
+MODEL_REVISIONS: dict[EOUModelType, str] = {
+    "en": "v1.2.2-en",
+    "multilingual": "v0.4.1-intl",
+}
+HG_MODEL = "livekit/turn-detector"
+ONNX_FILENAME = "model_q8.onnx"

livekit_plugins_turn_detector-1.3.9/livekit/plugins/turn_detector/multilingual.py

@@ -0,0 +1,116 @@
+from __future__ import annotations
+
+import os
+from time import perf_counter
+
+import aiohttp
+
+from livekit.agents import Plugin, get_job_context, llm, utils
+from livekit.agents.inference_runner import _InferenceRunner
+
+from .base import MAX_HISTORY_TURNS, EOUModelBase, EOUPlugin, _EUORunnerBase
+from .log import logger
+from .models import EOUModelType
+
+REMOTE_INFERENCE_TIMEOUT = 2
+
+
+class _EUORunnerMultilingual(_EUORunnerBase):
+    INFERENCE_METHOD = "lk_end_of_utterance_multilingual"
+
+    @classmethod
+    def model_type(cls) -> EOUModelType:
+        return "multilingual"
+
+
+class MultilingualModel(EOUModelBase):
+    def __init__(self, *, unlikely_threshold: float | None = None):
+        super().__init__(
+            model_type="multilingual",
+            unlikely_threshold=unlikely_threshold,
+            load_languages=_remote_inference_url() is None,
+        )
+
+    def _inference_method(self) -> str:
+        return _EUORunnerMultilingual.INFERENCE_METHOD
+
+    async def unlikely_threshold(self, language: str | None) -> float | None:
+        if not language:
+            return None
+
+        threshold = await super().unlikely_threshold(language)
+        if threshold is None:
+            try:
+                if url := _remote_inference_url():
+                    async with utils.http_context.http_session().post(
+                        url=url,
+                        json={
+                            "language": language,
+                        },
+                        timeout=aiohttp.ClientTimeout(total=REMOTE_INFERENCE_TIMEOUT),
+                    ) as resp:
+                        resp.raise_for_status()
+                        data = await resp.json()
+                        threshold = data.get("threshold")
+                        if threshold:
+                            self._languages[language] = {"threshold": threshold}
+            except Exception as e:
+                logger.warning("Error fetching threshold for language %s", language, exc_info=e)
+
+        return threshold
+
+    async def predict_end_of_turn(
+        self,
+        chat_ctx: llm.ChatContext,
+        *,
+        timeout: float | None = 3,
+    ) -> float:
+        url = _remote_inference_url()
+        if not url:
+            return await super().predict_end_of_turn(chat_ctx, timeout=timeout)
+
+        messages = chat_ctx.copy(
+            exclude_function_call=True, exclude_instructions=True, exclude_empty_message=True
+        ).truncate(max_items=MAX_HISTORY_TURNS)
+
+        ctx = get_job_context()
+        request = messages.to_dict(exclude_image=True, exclude_audio=True, exclude_timestamp=True)
+        request["jobId"] = ctx.job.id
+        request["workerId"] = ctx.worker_id
+        agent_id = os.getenv("LIVEKIT_AGENT_ID")
+        if agent_id:
+            request["agentId"] = agent_id
+
+        started_at = perf_counter()
+        async with utils.http_context.http_session().post(
+            url=url,
+            json=request,
+            timeout=aiohttp.ClientTimeout(total=REMOTE_INFERENCE_TIMEOUT),
+        ) as resp:
+            resp.raise_for_status()
+            data = await resp.json()
+            probability = data.get("probability")
+            if isinstance(probability, float) and probability >= 0:
+                logger.debug(
+                    "eou prediction",
+                    extra={
+                        "eou_probability": probability,
+                        "duration": perf_counter() - started_at,
+                    },
+                )
+                return probability
+            else:
+                # default to indicate no prediction
+                return 1
+
+
+def _remote_inference_url() -> str | None:
+    url_base = os.getenv("LIVEKIT_REMOTE_EOT_URL")
+    if not url_base:
+        return None
+    return f"{url_base}/eot/multi"
+
+
+if not _remote_inference_url():
+    _InferenceRunner.register_runner(_EUORunnerMultilingual)
+Plugin.register_plugin(EOUPlugin(_EUORunnerMultilingual))

livekit_plugins_turn_detector-1.3.9/livekit/plugins/turn_detector/version.py

@@ -0,0 +1,15 @@
+# Copyright 2023 LiveKit, Inc.
+
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+
+__version__ = "1.3.9"

livekit_plugins_turn_detector-1.3.9/pyproject.toml

@@ -0,0 +1,45 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "livekit-plugins-turn-detector"
+dynamic = ["version"]
+description = "End of utterance detection for LiveKit Agents"
+readme = "README.md"
+license = "Apache-2.0"
+requires-python = ">=3.9.0"
+authors = [{ name = "LiveKit", email = "hello@livekit.io" }]
+keywords = ["voice", "ai", "realtime", "audio", "video", "livekit", "webrtc"]
+classifiers = [
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: Apache Software License",
+    "Topic :: Multimedia :: Sound/Audio",
+    "Topic :: Multimedia :: Video",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3 :: Only",
+]
+dependencies = [
+    "livekit-agents>=1.3.9",
+    "transformers>=4.47.1,<=4.57.1",  # transformers 4.57.2 has a bug with local_files_only=True
+    "numpy>=1.26",
+    "onnxruntime>=1.18",
+    "jinja2",
+]
+
+[project.urls]
+Documentation = "https://docs.livekit.io"
+Website = "https://livekit.io/"
+Source = "https://github.com/livekit/agents"
+
+[tool.hatch.version]
+path = "livekit/plugins/turn_detector/version.py"
+
+[tool.hatch.build.targets.wheel]
+packages = ["livekit"]
+
+[tool.hatch.build.targets.sdist]
+include = ["/livekit"]