dv-pipecat-ai 0.0.85.dev848__tar.gz → 0.0.85.dev851__tar.gz

{dv_pipecat_ai-0.0.85.dev848 → dv_pipecat_ai-0.0.85.dev851}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev848
+Version: 0.0.85.dev851
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.85.dev848 → dv_pipecat_ai-0.0.85.dev851}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev848
+Version: 0.0.85.dev851
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.85.dev848 → dv_pipecat_ai-0.0.85.dev851}/src/pipecat/services/deepgram/stt.py

@@ -8,7 +8,11 @@
 
 import asyncio
 import logging
-from typing import AsyncGenerator, Dict, Optional
+import os
+import socket
+import time
+from typing import AsyncGenerator, Callable, Dict, Optional
+from urllib.parse import urlparse
 
 from loguru import logger
 
@@ -29,6 +33,155 @@ from pipecat.transcriptions.language import Language
 from pipecat.utils.time import time_now_iso8601
 from pipecat.utils.tracing.service_decorators import traced_stt
 
+_PROCESS_START_MONOTONIC = time.monotonic()
+
+
+def _read_first_numeric_file(paths):
+    for path in paths:
+        try:
+            with open(path, "r", encoding="utf-8") as file:
+                value = file.read().strip()
+        except FileNotFoundError:
+            continue
+        except OSError:
+            continue
+
+        if not value or value == "max":
+            return None
+
+        try:
+            return int(value)
+        except ValueError:
+            continue
+    return None
+
+
+def _read_proc_status_value(key):
+    try:
+        with open("/proc/self/status", "r", encoding="utf-8") as status_file:
+            for line in status_file:
+                if line.startswith(key):
+                    parts = line.split()
+                    if len(parts) >= 2:
+                        return int(parts[1]) * 1024  # kB -> bytes
+    except FileNotFoundError:
+        return None
+    except OSError:
+        return None
+    return None
+
+
+def _read_cpu_throttling():
+    paths = ["/sys/fs/cgroup/cpu.stat", "/sys/fs/cgroup/cpu/cpu.stat"]
+    for path in paths:
+        try:
+            with open(path, "r", encoding="utf-8") as cpu_file:
+                for line in cpu_file:
+                    if line.startswith("nr_throttled"):
+                        parts = line.split()
+                        if len(parts) >= 2:
+                            return int(parts[1])
+        except FileNotFoundError:
+            continue
+        except OSError:
+            continue
+    return None
+
+
+def _collect_runtime_diagnostics(
+    loop: Optional[asyncio.AbstractEventLoop] = None,
+    extra_context: Optional[Dict] = None,
+    context_provider: Optional[Callable[[], Dict]] = None,
+):
+    if loop is None:
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            loop = None
+
+    uptime_s = round(time.monotonic() - _PROCESS_START_MONOTONIC, 1)
+    rss_bytes = _read_proc_status_value("VmRSS:")
+    rss_mb = round(rss_bytes / (1024**2), 2) if rss_bytes else None
+
+    cgroup_usage_bytes = _read_first_numeric_file(
+        ["/sys/fs/cgroup/memory.current", "/sys/fs/cgroup/memory/memory.usage_in_bytes"]
+    )
+    cgroup_limit_bytes = _read_first_numeric_file(
+        ["/sys/fs/cgroup/memory.max", "/sys/fs/cgroup/memory/memory.limit_in_bytes"]
+    )
+    cgroup_usage_mb = (
+        round(cgroup_usage_bytes / (1024**2), 2) if cgroup_usage_bytes is not None else None
+    )
+    cgroup_limit_mb = (
+        round(cgroup_limit_bytes / (1024**2), 2) if cgroup_limit_bytes not in (None, 0) else None
+    )
+    cgroup_pct = (
+        round(cgroup_usage_bytes / cgroup_limit_bytes * 100, 2)
+        if cgroup_usage_bytes is not None and cgroup_limit_bytes not in (None, 0)
+        else None
+    )
+
+    try:
+        open_fds = len(os.listdir("/proc/self/fd"))
+    except Exception:
+        open_fds = None
+
+    pending_tasks = None
+    if loop:
+        try:
+            pending_tasks = len(asyncio.all_tasks(loop))
+        except Exception:
+            pending_tasks = None
+
+    suspected_cause = "unknown"
+    if cgroup_pct and cgroup_pct >= 90:
+        suspected_cause = "memory_pressure"
+    elif uptime_s < 180:
+        suspected_cause = "pod_cold_start"
+
+    diagnostics = {
+        "uptime_s": uptime_s,
+        "rss_mb": rss_mb,
+        "cgroup_usage_mb": cgroup_usage_mb,
+        "cgroup_limit_mb": cgroup_limit_mb,
+        "cgroup_usage_pct": cgroup_pct,
+        "open_fds": open_fds,
+        "pending_tasks": pending_tasks,
+        "suspected_cause": suspected_cause,
+    }
+    cpu_throttled = _read_cpu_throttling()
+    if cpu_throttled is not None:
+        diagnostics["cpu_nr_throttled"] = cpu_throttled
+
+    if context_provider:
+        try:
+            ctx = context_provider() or {}
+            if isinstance(ctx, dict):
+                diagnostics.update({k: v for k, v in ctx.items() if v is not None})
+        except Exception as exc:
+            diagnostics["context_provider_error"] = str(exc)
+
+    if extra_context:
+        diagnostics.update({k: v for k, v in extra_context.items() if v is not None})
+
+    return {k: v for k, v in diagnostics.items() if v is not None}
+
+
+def _derive_connect_endpoint(base_url: str):
+    if not base_url:
+        return "api.deepgram.com", 443
+
+    parsed = urlparse(base_url)
+    host = parsed.hostname or "api.deepgram.com"
+    if parsed.port:
+        port = parsed.port
+    elif parsed.scheme in ("https", "wss"):
+        port = 443
+    else:
+        port = 80
+    return host, port
+
+
 try:
     from deepgram import (
         AsyncListenWebSocketClient,
@@ -64,6 +217,7 @@ class DeepgramSTTService(STTService):
         addons: Optional[Dict] = None,
         max_connect_retries: int = 3,
         connect_timeout_s: float = 2.5,
+        diagnostics_context_provider: Optional[Callable[[], Dict]] = None,
         **kwargs,
     ):
         """Initialize the Deepgram STT service.
@@ -82,6 +236,9 @@ class DeepgramSTTService(STTService):
             max_connect_retries: Maximum number of connection attempts before giving up.
             connect_timeout_s: Maximum time in seconds to wait for a connection attempt.
                 Connection retries wait 100ms between attempts.
+            diagnostics_context_provider: Optional callable returning a dict with
+                additional runtime diagnostics (e.g., active call counts) to append
+                to warning logs.
             **kwargs: Additional arguments passed to the parent STTService.
         """
         sample_rate = sample_rate or (live_options.sample_rate if live_options else None)
@@ -125,6 +282,7 @@ class DeepgramSTTService(STTService):
         self.set_model_name(merged_options["model"])
         self._settings = merged_options
         self._addons = addons
+        self._diagnostics_context_provider = diagnostics_context_provider
 
         # Connection retry settings (100ms delay between retries)
         self._max_connect_retries = max_connect_retries
@@ -142,6 +300,7 @@ class DeepgramSTTService(STTService):
                 verbose=logging.ERROR,  # Enable error level and above logging
             ),
         )
+        self._connect_host, self._connect_port = _derive_connect_endpoint(base_url)
 
         if self.vad_enabled:
             self._register_event_handler("on_speech_started")
@@ -230,7 +389,10 @@ class DeepgramSTTService(STTService):
     async def _connect(self):
         self.logger.debug("Attempting to connect to Deepgram...")
 
+        loop = asyncio.get_running_loop()
         for attempt in range(self._max_connect_retries):
+            attempt_started = time.perf_counter()
+            dns_ms = await self._measure_dns_resolution(loop)
             try:
                 # Clean up any previous connection attempt in background (non-blocking)
                 if hasattr(self, "_connection") and self._connection is not None:
@@ -266,18 +428,67 @@ class DeepgramSTTService(STTService):
                         timeout=self._connect_timeout_s,
                     )
                 except asyncio.TimeoutError:
+                    elapsed_ms = round((time.perf_counter() - attempt_started) * 1000, 2)
+                    diagnostics = _collect_runtime_diagnostics(
+                        loop,
+                        extra_context={
+                            "dns_ms": dns_ms,
+                            "connect_duration_ms": elapsed_ms,
+                        },
+                        context_provider=self._diagnostics_context_provider,
+                    )
                     self.logger.warning(
-                        f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} timed out after {self._connect_timeout_s} second(s)."
+                        (
+                            "Deepgram connection attempt {}/{} timed out after {:.2f} second(s). "
+                            "runtime_diagnostics={}"
+                        ),
+                        attempt + 1,
+                        self._max_connect_retries,
+                        self._connect_timeout_s,
+                        diagnostics,
                     )
                     start_result = False
                 except Exception as start_error:
+                    elapsed_ms = round((time.perf_counter() - attempt_started) * 1000, 2)
+                    diagnostics = _collect_runtime_diagnostics(
+                        loop,
+                        extra_context={
+                            "dns_ms": dns_ms,
+                            "connect_duration_ms": elapsed_ms,
+                        },
+                        context_provider=self._diagnostics_context_provider,
+                    )
                     self.logger.warning(
-                        f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} failed with an exception: {start_error}"
+                        (
+                            "Deepgram connection attempt {}/{} failed with an exception: {}. "
+                            "runtime_diagnostics={}"
+                        ),
+                        attempt + 1,
+                        self._max_connect_retries,
+                        start_error,
+                        diagnostics,
                     )
                     start_result = False
                 else:
                     if start_result:
-                        self.logger.info("Successfully connected to Deepgram.")
+                        elapsed_ms = round((time.perf_counter() - attempt_started) * 1000, 2)
+                        diagnostics = _collect_runtime_diagnostics(
+                            loop,
+                            extra_context={
+                                "dns_ms": dns_ms,
+                                "connect_duration_ms": elapsed_ms,
+                            },
+                            context_provider=self._diagnostics_context_provider,
+                        )
+                        self.logger.info(
+                            (
+                                "Successfully connected to Deepgram on attempt {} in {:.2f} ms. "
+                                "runtime_diagnostics={}"
+                            ),
+                            attempt + 1,
+                            elapsed_ms,
+                            diagnostics,
+                        )
                         return  # Exit the method on success
 
                 self.logger.warning(
@@ -285,8 +496,24 @@ class DeepgramSTTService(STTService):
                 )
 
             except Exception as e:
+                elapsed_ms = round((time.perf_counter() - attempt_started) * 1000, 2)
+                diagnostics = _collect_runtime_diagnostics(
+                    loop,
+                    extra_context={
+                        "dns_ms": dns_ms,
+                        "connect_duration_ms": elapsed_ms,
+                    },
+                    context_provider=self._diagnostics_context_provider,
+                )
                 self.logger.warning(
-                    f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} failed with an exception: {e}"
+                    (
+                        "Deepgram connection attempt {}/{} failed with an exception: {}. "
+                        "runtime_diagnostics={}"
+                    ),
+                    attempt + 1,
+                    self._max_connect_retries,
+                    e,
+                    diagnostics,
                 )
 
             # If this is not the last attempt, wait 100ms before retrying
@@ -300,6 +527,22 @@ class DeepgramSTTService(STTService):
         self.logger.error(error_msg)
         await self.push_error(ErrorFrame(error_msg, fatal=True))
 
+    async def _measure_dns_resolution(self, loop: Optional[asyncio.AbstractEventLoop]):
+        if not loop or not self._connect_host:
+            return None
+        try:
+            dns_task = loop.getaddrinfo(
+                self._connect_host,
+                self._connect_port,
+                type=socket.SOCK_STREAM,
+                proto=socket.IPPROTO_TCP,
+            )
+            start = time.perf_counter()
+            await asyncio.wait_for(dns_task, timeout=1.0)
+            return round((time.perf_counter() - start) * 1000, 2)
+        except Exception:
+            return None
+
     async def _disconnect(self):
         # Guard against missing connection instance and ensure proper async check
         connection: AsyncListenWebSocketClient = getattr(self, "_connection", None)

{dv_pipecat_ai-0.0.85.dev848 → dv_pipecat_ai-0.0.85.dev851}/src/pipecat/services/elevenlabs/stt.py

@@ -159,10 +159,16 @@ def language_to_elevenlabs_language(language: Language) -> Optional[str]:
     result = BASE_LANGUAGES.get(language)
 
     # If not found in base languages, try to find the base language from a variant
+    # For example, Language.EN_US (value "en-US") -> Language("en") -> "eng"
     if not result:
         lang_str = str(language.value)
-        base_code = lang_str.split("-")[0].lower()
-        result = base_code if base_code in BASE_LANGUAGES.values() else None
+        base_code = lang_str.split("-")[0]  # Get "en" from "en-US"
+        try:
+            base_language = Language(base_code)
+            result = BASE_LANGUAGES.get(base_language)
+        except (ValueError, KeyError):
+            # If base language not found in Language enum, return None
+            result = None
 
     return result
 
@@ -425,6 +431,7 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         self._pending_final_task: Optional[asyncio.Task] = None
         self._timestamp_merge_delay_s = 0.25
         self._ttfb_started = False
+        self._waiting_for_timestamps = False
 
     @property
     def commit_strategy(self) -> str:
@@ -474,7 +481,9 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         if isinstance(frame, UserStartedSpeakingFrame):
             if frame.emulated:
                 return
-            self._ttfb_started = False
+            # Start metrics and set flag to True so we can stop them later
+            await self.start_ttfb_metrics()
+            self._ttfb_started = True
             await self.start_processing_metrics()
         elif isinstance(frame, UserStoppedSpeakingFrame):
             if frame.emulated:
@@ -488,18 +497,28 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             yield None
             return
 
-        await self._ensure_connection()
+        if not await self._ensure_connection():
+            self.logger.error(f"{self} failed to establish connection, dropping audio")
+            yield None
+            return
+
         await self._send_audio_chunk(audio)
         yield None
 
-    async def _ensure_connection(self):
+    async def _ensure_connection(self) -> bool:
+        """Ensure WebSocket connection is established and ready.
+
+        Returns:
+            bool: True if connection is ready, False otherwise.
+        """
         if not self._websocket or self._websocket.state is State.CLOSED:
             await self._connect()
+        return self._websocket is not None and self._websocket.state is State.OPEN
 
     async def _connect(self):
         await self._connect_websocket()
-        if self._websocket and not self._receive_task:
-            self._receive_task = asyncio.create_task(self._receive_task_handler(self._report_error))
+        if self._websocket and self._websocket.state is State.OPEN and not self._receive_task:
+            self._receive_task = self.create_task(self._receive_task_handler(self._report_error))
 
     async def _disconnect(self):
         if self._receive_task:
@@ -512,23 +531,30 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
     async def _connect_websocket(self):
         try:
             if self._websocket and self._websocket.state is State.OPEN:
+                self.logger.debug(f"{self} already connected, skipping reconnection")
                 return
 
             ws_url = self._build_websocket_url()
             headers = {"xi-api-key": self._api_key}
-            self.logger.debug(f"Connecting to ElevenLabs realtime STT at {ws_url}")
+            self.logger.info(f"{self} connecting to ElevenLabs realtime STT (WebSocket URL built)")
             self._websocket = await websocket_connect(ws_url, additional_headers=headers)
+            self.logger.info(f"{self} successfully connected to ElevenLabs realtime STT")
             await self._call_event_handler("on_connected")
         except Exception as e:
             self.logger.error(f"{self} unable to connect to ElevenLabs realtime STT: {e}")
             self._websocket = None
+            if self._receive_task:
+                await self.cancel_task(self._receive_task)
+                self._receive_task = None
+            # Push error to pipeline so callers know the connection failed
+            await self.push_error(ErrorFrame(f"ElevenLabs connection failed: {e}", fatal=False))
             await self._call_event_handler("on_connection_error", f"{e}")
 
     async def _disconnect_websocket(self):
         try:
             await self.stop_all_metrics()
             if self._websocket and self._websocket.state is State.OPEN:
-                self.logger.debug("Disconnecting from ElevenLabs realtime STT")
+                self.logger.debug(f"{self} disconnecting from ElevenLabs realtime STT")
                 await self._websocket.close()
         except Exception as e:
             self.logger.error(f"{self} error closing ElevenLabs realtime websocket: {e}")
@@ -573,6 +599,10 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         }:
             fatal = message_type in {"auth_error", "quota_exceeded", "error"}
             description = data.get("error", data)
+            # Log full error details for debugging
+            self.logger.error(
+                f"{self} ElevenLabs error - Type: {message_type}, Fatal: {fatal}, Full data: {data}"
+            )
             await self.push_error(
                 ErrorFrame(f"ElevenLabs realtime error: {description}", fatal=fatal)
             )
@@ -588,7 +618,11 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             elevenlabs_language_code_to_language(data.get("language_code"))
             or self._language_override
         )
-        await self.stop_ttfb_metrics()
+
+        # Only stop TTFB metrics on first partial
+        if self._ttfb_started:
+            await self.stop_ttfb_metrics()
+            self._ttfb_started = False
 
         await self.push_frame(
             InterimTranscriptionFrame(
@@ -604,8 +638,10 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         if self._pending_final_message:
             await self._emit_transcription(self._pending_final_message)
             self._pending_final_message = None
+            self._waiting_for_timestamps = False
 
         self._pending_final_message = data
+        self._waiting_for_timestamps = True
         await self._schedule_pending_final_emit()
 
     async def _handle_committed_transcript_with_timestamps(self, data: Dict[str, Any]):
@@ -613,12 +649,16 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             merged = {**self._pending_final_message, **data}
             await self._emit_transcription(merged)
             await self._clear_pending_final()
+        elif self._waiting_for_timestamps:
+            # Late arrival after timeout - don't emit duplicate
+            self.logger.warning(f"{self} timestamps arrived after timeout, skipping duplicate")
+            self._waiting_for_timestamps = False
         else:
             await self._emit_transcription(data)
 
     async def _schedule_pending_final_emit(self):
         await self._clear_pending_final(timer_only=True)
-        self._pending_final_task = asyncio.create_task(self._emit_pending_after_delay())
+        self._pending_final_task = self.create_task(self._emit_pending_after_delay())
 
     async def _emit_pending_after_delay(self):
         try:
@@ -626,6 +666,7 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             if self._pending_final_message:
                 await self._emit_transcription(self._pending_final_message)
                 self._pending_final_message = None
+                self._waiting_for_timestamps = False
         except asyncio.CancelledError:
             pass
         finally:
@@ -638,6 +679,7 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
 
         if not timer_only:
             self._pending_final_message = None
+            self._waiting_for_timestamps = False
 
     async def _emit_transcription(self, data: Dict[str, Any]):
         text = (data.get("text") or data.get("transcript") or "").strip()
@@ -648,7 +690,11 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
             elevenlabs_language_code_to_language(data.get("language_code"))
             or self._language_override
         )
-        await self.stop_ttfb_metrics()
+
+        # TTFB should already be stopped by partial, but guard just in case
+        if self._ttfb_started:
+            await self.stop_ttfb_metrics()
+            self._ttfb_started = False
 
         frame = TranscriptionFrame(
             text,
@@ -666,28 +712,39 @@ class ElevenLabsRealtimeSTTService(WebsocketSTTService):
         if not audio or not self._websocket:
             return
 
-        if not self._ttfb_started:
-            await self.start_ttfb_metrics()
-            self._ttfb_started = True
-
-        payload = {
-            "message_type": "input_audio_chunk",
-            "audio_base_64": base64.b64encode(audio).decode("ascii"),
-            "commit": False,
-            "sample_rate": self.sample_rate,
-        }
-        await self._websocket.send(json.dumps(payload))
+        try:
+            payload = {
+                "message_type": "input_audio_chunk",
+                "audio_base_64": base64.b64encode(audio).decode("ascii"),
+                "commit": False,
+                "sample_rate": self.sample_rate,
+            }
+            await self._websocket.send(json.dumps(payload))
+        except Exception as e:
+            self.logger.error(f"{self} error sending audio chunk: {e}")
+            await self.push_error(ErrorFrame(f"Failed to send audio: {e}"))
+            # Trigger reconnection
+            await self._disconnect()
+            await self._connect()
 
     async def _send_commit(self):
         if not self._websocket:
             return
-        payload = {
-            "message_type": "input_audio_chunk",
-            "audio_base_64": "",
-            "commit": True,
-            "sample_rate": self.sample_rate,
-        }
-        await self._websocket.send(json.dumps(payload))
+
+        try:
+            payload = {
+                "message_type": "input_audio_chunk",
+                "audio_base_64": "",
+                "commit": True,
+                "sample_rate": self.sample_rate,
+            }
+            await self._websocket.send(json.dumps(payload))
+        except Exception as e:
+            self.logger.error(f"{self} error sending commit: {e}")
+            await self.push_error(ErrorFrame(f"Failed to send commit: {e}"))
+            # Trigger reconnection
+            await self._disconnect()
+            await self._connect()
 
     def _build_websocket_url(self) -> str:
         if not self.sample_rate: