livekit-plugins-volcenginee 1.3.9__tar.gz → 1.3.11__tar.gz

{livekit_plugins_volcenginee-1.3.9 → livekit_plugins_volcenginee-1.3.11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: livekit-plugins-volcenginee
-Version: 1.3.9
+Version: 1.3.11
 Summary: LiveKit Agent Plugins for Volcengine
 Author-email: linsanzhu <2287225730@qq.com>
 Keywords: audio,livekit,realtime,video,webrtc

{livekit_plugins_volcenginee-1.3.9 → livekit_plugins_volcenginee-1.3.11}/livekit/plugins/volcengine/llm.py

@@ -114,6 +114,15 @@ class LLM(llm.LLM):
 
         self._prewarm_task: asyncio.Task[None] | None = None
 
+    @property
+    def model(self) -> str:
+        """The underlying Doubao model name (e.g. ``"doubao-1-5-lite-32k-250115"``)."""
+        return self._opts.model
+
+    @property
+    def provider(self) -> str:
+        return "volcengine"
+
     def prewarm(self) -> None:
         """Issue a tiny 1-token chat completion to warm the model and prime
         the HTTP connection.
@@ -123,16 +132,16 @@ class LLM(llm.LLM):
         cost from the per-turn TTFT — the single largest knob for first-turn
         latency on this plugin. The cost is ~5–10 tokens per session start.
 
-        Mirrors the ``connection_pool.prewarm`` convention: schedule a
-        background task and return immediately.
+        Mirrors the ``connection_pool.prewarm`` convention when a running
+        event loop is available (schedule a background task and return
+        immediately). LiveKit Agents may call this synchronously from a
+        context without a running loop — in that case we fall back to
+        ``asyncio.run`` and execute the warmup to completion before
+        returning, so the first user turn still benefits from a warm model
+        + keep-alive connection.
         """
         if self._prewarm_task is not None and not self._prewarm_task.done():
             return
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            logger.debug("llm prewarm skipped: no running event loop")
-            return
 
         model = self._opts.model
 
@@ -152,6 +161,18 @@ class LLM(llm.LLM):
             except Exception as exc:  # noqa: BLE001
                 logger.warning("llm prewarm failed: %s", exc)
 
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No running event loop — run the warmup synchronously to
+            # completion. ``asyncio.run`` builds and tears down its own
+            # loop, so it's safe to call from a plain sync context.
+            try:
+                asyncio.run(_impl())
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("llm prewarm failed: %s", exc)
+            return
+
         self._prewarm_task = loop.create_task(_impl(), name="volcengine.llm.prewarm")
 
     def chat(

{livekit_plugins_volcenginee-1.3.9 → livekit_plugins_volcenginee-1.3.11}/livekit/plugins/volcengine/stt.py

@@ -232,23 +232,29 @@ class STT(stt.STT):
             self._session = utils.http_context.http_session()
         return self._session
 
+    @property
+    def model(self) -> str:
+        """The underlying ASR model name (e.g. ``"bigmodel"``)."""
+        return self._opts.model_name
+
+    @property
+    def provider(self) -> str:
+        return "volcengine"
+
     def prewarm(self) -> None:
         """Open the STT WebSocket and send the handshake payload so the first
         user turn doesn't pay the TLS + WS-upgrade + auth round-trip cost.
 
-        Mirrors the ``connection_pool.prewarm`` convention: schedule a
-        background task and return immediately. The framework calls this
-        synchronously before the session starts, so the actual WS work
-        happens concurrently while the user is still getting ready to
-        speak.
+        Mirrors the ``connection_pool.prewarm`` convention when a running
+        event loop is available (schedule a background task and return
+        immediately). LiveKit Agents may call this synchronously from a
+        context without a running loop, in which case we fall back to
+        ``asyncio.run`` and execute the warmup to completion before
+        returning — the framework still benefits because the next user
+        turn will reuse the now-warm DNS / TLS / WS-upgrade path.
         """
         if self._prewarm_task is not None and not self._prewarm_task.done():
             return
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            logger.debug("stt prewarm skipped: no running event loop")
-            return
 
         async def _impl() -> None:
             try:
@@ -269,6 +275,18 @@ class STT(stt.STT):
             except Exception as exc:  # noqa: BLE001
                 logger.warning("stt prewarm failed: %s", exc)
 
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No running event loop — run the warmup synchronously to
+            # completion. ``asyncio.run`` builds and tears down its own
+            # loop, so it's safe to call from a plain sync context.
+            try:
+                asyncio.run(_impl())
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("stt prewarm failed: %s", exc)
+            return
+
         self._prewarm_task = loop.create_task(_impl(), name="volcengine.stt.prewarm")
 
     async def _recognize_impl(

{livekit_plugins_volcenginee-1.3.9 → livekit_plugins_volcenginee-1.3.11}/livekit/plugins/volcengine/tts.py

@@ -172,6 +172,25 @@ class TTS(tts.TTS):
             self._session = utils.http_context.http_session()
         return self._session
 
+    @property
+    def model(self) -> str:
+        """The TTS model identifier, composed as ``"{resource_id}/{voice}"``.
+
+        Both pieces matter: ``resource_id`` selects the model family
+        (``"seed-tts-2.0"``, ``"seed-tts-1.0"``, ``"seed-icl-2.0"``, …) and
+        ``voice`` selects the speaker profile. The effective ``resource_id``
+        falls back to ``VOLCENGINE_TTS_RESOURCE_ID`` and then ``"seed-tts-2.0"``,
+        matching ``_TTSOptions.get_http_header``.
+        """
+        resource_id = self._opts.resource_id or os.getenv(
+            "VOLCENGINE_TTS_RESOURCE_ID", "seed-tts-2.0"
+        )
+        return f"{resource_id}/{self._opts.voice}"
+
+    @property
+    def provider(self) -> str:
+        return "volcengine"
+
     def prewarm(self) -> None:
         """Make a tiny HTTP synthesize call to prime the TLS connection and
         warm the TTS model.
@@ -179,16 +198,16 @@ class TTS(tts.TTS):
         Shaves the per-call TLS + model load cost off the first turn's TTS
         TTFB. The warmup text is two characters; the audio is discarded.
 
-        Mirrors the ``connection_pool.prewarm`` convention: schedule a
-        background task and return immediately.
+        LiveKit Agents invokes ``prewarm`` synchronously from a setup hook
+        that may run **without** a running event loop (e.g. when the user
+        calls it from a sync context, or before the worker's loop is up).
+        To stay useful in both contexts, we try a non-blocking
+        ``loop.create_task`` first; if no loop is running we fall back to
+        ``asyncio.run`` and execute the warmup synchronously to completion
+        before returning.
         """
         if self._prewarm_task is not None and not self._prewarm_task.done():
             return
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            logger.debug("tts prewarm skipped: no running event loop")
-            return
 
         async def _impl() -> None:
             t0 = time.perf_counter()
@@ -210,6 +229,18 @@ class TTS(tts.TTS):
             except Exception as exc:  # noqa: BLE001
                 logger.warning("tts prewarm failed: %s", exc)
 
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            # No running event loop — run the warmup synchronously to
+            # completion. ``asyncio.run`` builds and tears down its own
+            # loop, so it's safe to call from a plain sync context.
+            try:
+                asyncio.run(_impl())
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("tts prewarm failed: %s", exc)
+            return
+
         self._prewarm_task = loop.create_task(_impl(), name="volcengine.tts.prewarm")
 
     def synthesize(

livekit_plugins_volcenginee-1.3.11/livekit/plugins/volcengine/version.py

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

livekit_plugins_volcenginee-1.3.9/livekit/plugins/volcengine/version.py

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