livekit-plugins-volcenginee 1.3.7__tar.gz → 1.3.10__tar.gz

{livekit_plugins_volcenginee-1.3.7 → livekit_plugins_volcenginee-1.3.10}/PKG-INFO

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

{livekit_plugins_volcenginee-1.3.7 → livekit_plugins_volcenginee-1.3.10}/livekit/plugins/volcengine/llm.py

@@ -1,6 +1,8 @@
 from __future__ import annotations
 
+import asyncio
 import os
+import time
 from dataclasses import dataclass
 from typing import Any, Literal
 
@@ -110,6 +112,57 @@ 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.
+
+        Doubao's first call typically pays 1–3 s of model warm-up cost; a
+        discardable 1-token call ahead of the first real turn hides that
+        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.
+        """
+        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
+
+        async def _impl() -> None:
+            t0 = time.perf_counter()
+            try:
+                await self._client.chat.completions.create(
+                    model=model,
+                    messages=[{"role": "user", "content": "hi"}],
+                    max_tokens=1,
+                    stream=False,
+                )
+                logger.info(
+                    "llm prewarm: warmup call completed in %.0f ms",
+                    (time.perf_counter() - t0) * 1000,
+                )
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("llm prewarm failed: %s", exc)
+
+        self._prewarm_task = loop.create_task(_impl(), name="volcengine.llm.prewarm")
+
     def chat(
         self,
         *,

{livekit_plugins_volcenginee-1.3.7 → livekit_plugins_volcenginee-1.3.10}/livekit/plugins/volcengine/stt.py

@@ -225,12 +225,61 @@ class STT(stt.STT):
 
         self._session = http_session
         self._streams = weakref.WeakSet[SpeechStream]()
+        self._prewarm_task: asyncio.Task[None] | None = None
 
     def _ensure_session(self) -> aiohttp.ClientSession:
         if not self._session:
             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.
+        """
+        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:
+                session = self._ensure_session()
+                async with session.ws_connect(
+                    self._opts.get_ws_url(),
+                    headers=self._opts.get_ws_header(),
+                    max_msg_size=1000000000,
+                ) as ws:
+                    await ws.send_bytes(self._opts.get_ws_query_params())
+                    # Wait briefly so we also eat the auth roundtrip; the
+                    # server ack arrives within a few hundred ms.
+                    try:
+                        await asyncio.wait_for(ws.receive(), timeout=2.0)
+                    except asyncio.TimeoutError:
+                        pass
+                logger.info("stt prewarm: ws handshake completed")
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("stt prewarm failed: %s", exc)
+
+        self._prewarm_task = loop.create_task(_impl(), name="volcengine.stt.prewarm")
+
     async def _recognize_impl(
         self,
         buffer: AudioBuffer,

{livekit_plugins_volcenginee-1.3.7 → livekit_plugins_volcenginee-1.3.10}/livekit/plugins/volcengine/tts.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import asyncio
 import base64
 import gzip
 import json
@@ -164,12 +165,72 @@ class TTS(tts.TTS):
         self._session = http_session
         self._min_sentence_length = min_sentence_length
         self._streams = weakref.WeakSet[SynthesizeStream]()
+        self._prewarm_task: asyncio.Task[None] | None = None
 
     def _ensure_session(self) -> aiohttp.ClientSession:
         if self._session is None:
             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.
+
+        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.
+        """
+        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()
+            try:
+                session = self._ensure_session()
+                payload = self._opts.get_http_request("你好")
+                headers = self._opts.get_http_header()
+                async with session.post(
+                    self._opts.get_http_url(),
+                    json=payload,
+                    timeout=aiohttp.ClientTimeout(total=30, sock_connect=10),
+                    headers=headers,
+                ) as resp:
+                    await resp.read()
+                logger.info(
+                    "tts prewarm: warmup synthesize completed in %.0f ms",
+                    (time.perf_counter() - t0) * 1000,
+                )
+            except Exception as exc:  # noqa: BLE001
+                logger.warning("tts prewarm failed: %s", exc)
+
+        self._prewarm_task = loop.create_task(_impl(), name="volcengine.tts.prewarm")
+
     def synthesize(
         self, text, *, conn_options: APIConnectOptions = DEFAULT_API_CONNECT_OPTIONS
     ):

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

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

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

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