dv-pipecat-ai 0.0.85.dev841__tar.gz → 0.0.85.dev843__tar.gz

{dv_pipecat_ai-0.0.85.dev841 → dv_pipecat_ai-0.0.85.dev843}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev841
+Version: 0.0.85.dev843
 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.dev841 → dv_pipecat_ai-0.0.85.dev843}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev841
+Version: 0.0.85.dev843
 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.dev841 → dv_pipecat_ai-0.0.85.dev843}/src/pipecat/services/deepgram/stt.py

@@ -62,6 +62,8 @@ class DeepgramSTTService(STTService):
         sample_rate: Optional[int] = None,
         live_options: Optional[LiveOptions] = None,
         addons: Optional[Dict] = None,
+        max_connect_retries: int = 3,
+        connect_timeout_s: float = 2.5,
         **kwargs,
     ):
         """Initialize the Deepgram STT service.
@@ -77,6 +79,9 @@ class DeepgramSTTService(STTService):
             sample_rate: Audio sample rate. If None, uses default or live_options value.
             live_options: Deepgram LiveOptions for detailed configuration.
             addons: Additional Deepgram features to enable.
+            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.
             **kwargs: Additional arguments passed to the parent STTService.
         """
         sample_rate = sample_rate or (live_options.sample_rate if live_options else None)
@@ -121,9 +126,9 @@ class DeepgramSTTService(STTService):
         self._settings = merged_options
         self._addons = addons
 
-        # Connection retry settings
-        self._max_connect_retries = 3
-        self._connect_retry_delay_s = 0.1
+        # Connection retry settings (100ms delay between retries)
+        self._max_connect_retries = max_connect_retries
+        self._connect_timeout_s = connect_timeout_s
 
         self._client = DeepgramClient(
             api_key,
@@ -131,8 +136,8 @@ class DeepgramSTTService(STTService):
                 url=base_url,
                 options={
                     "keepalive": "true",
-                    "open_timeout": 3,  # Max wait for only 3 seconds for the connection to establish #
-                    # "termination_exception_connect": True,  # Enable exception propagation
+                    # Note: Connection timeout is enforced by asyncio.wait_for() in _connect()
+                    # with the connect_timeout_s parameter (default 2.0s)
                 },
                 verbose=logging.ERROR,  # Enable error level and above logging
             ),
@@ -227,6 +232,11 @@ class DeepgramSTTService(STTService):
 
         for attempt in range(self._max_connect_retries):
             try:
+                # Clean up any previous connection attempt in background (non-blocking)
+                if hasattr(self, "_connection") and self._connection is not None:
+                    old_conn = self._connection
+                    asyncio.create_task(self._cleanup_abandoned_connection(old_conn))
+
                 # Create a new connection object for a clean attempt
                 self._connection: AsyncListenWebSocketClient = self._client.listen.asyncwebsocket.v(
                     "1"
@@ -250,10 +260,25 @@ class DeepgramSTTService(STTService):
                         self._on_utterance_end,
                     )
 
-                # Attempt to start the connection (timeout handled by open_timeout config)
-                if await self._connection.start(options=self._settings, addons=self._addons):
-                    self.logger.info("Successfully connected to Deepgram.")
-                    return  # Exit the method on success
+                try:
+                    start_result = await asyncio.wait_for(
+                        self._connection.start(options=self._settings, addons=self._addons),
+                        timeout=self._connect_timeout_s,
+                    )
+                except asyncio.TimeoutError:
+                    self.logger.warning(
+                        f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} timed out after {self._connect_timeout_s} second(s)."
+                    )
+                    start_result = False
+                except Exception as start_error:
+                    self.logger.warning(
+                        f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} failed with an exception: {start_error}"
+                    )
+                    start_result = False
+                else:
+                    if start_result:
+                        self.logger.info("Successfully connected to Deepgram.")
+                        return  # Exit the method on success
 
                 self.logger.warning(
                     f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} failed."
@@ -264,17 +289,21 @@ class DeepgramSTTService(STTService):
                     f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} failed with an exception: {e}"
                 )
 
-            # If this is not the last attempt, wait briefly before retrying
+            # If this is not the last attempt, wait 100ms before retrying
             if attempt < self._max_connect_retries - 1:
-                self.logger.info(f"Retrying in {self._connect_retry_delay_s} second(s)...")
-                await asyncio.sleep(self._connect_retry_delay_s)
+                self.logger.info("Retrying in 0.1 second(s)...")
+                await asyncio.sleep(0.1)
 
-        self.logger.error(
+        error_msg = (
             f"{self}: unable to connect to Deepgram after {self._max_connect_retries} attempts."
         )
+        self.logger.error(error_msg)
+        await self.push_error(ErrorFrame(error_msg, fatal=True))
 
     async def _disconnect(self):
-        if self._connection.is_connected:
+        # Guard against missing connection instance and ensure proper async check
+        connection: AsyncListenWebSocketClient = getattr(self, "_connection", None)
+        if connection and await connection.is_connected():
             self.logger.debug("Disconnecting from Deepgram")
             # Deepgram swallows asyncio.CancelledError internally which prevents
             # proper cancellation propagation. This issue was found with
@@ -284,7 +313,25 @@ class DeepgramSTTService(STTService):
             # Deepgram disconnection was still finishing and therefore
             # preventing the task cancellation that occurs during `cleanup()`.
             # GH issue: https://github.com/deepgram/deepgram-python-sdk/issues/570
-            await self._connection.finish()
+            await connection.finish()
+
+    async def _cleanup_abandoned_connection(self, conn: AsyncListenWebSocketClient):
+        """Clean up abandoned connection attempt in background (non-blocking).
+
+        This prevents zombie connections from triggering spurious error events
+        when they eventually timeout and call _on_error().
+
+        Args:
+            conn: The abandoned connection object to clean up.
+        """
+        try:
+            # Try to finish with short timeout
+            await asyncio.wait_for(conn.finish(), timeout=5)
+            self.logger.debug("Successfully cleaned up abandoned connection")
+        except Exception as e:
+            # Ignore all cleanup errors - connection might not be fully started
+            # This is expected and fine - we just want best-effort cleanup
+            self.logger.debug(f"Abandoned connection cleanup failed: {e}")
 
     async def start_metrics(self):
         """Start TTFB and processing metrics collection."""

{dv_pipecat_ai-0.0.85.dev841 → dv_pipecat_ai-0.0.85.dev843}/src/pipecat/transports/base_input.py

@@ -299,7 +299,7 @@ class BaseInputTransport(FrameProcessor):
             await self._handle_user_interruption(VADState.QUIET, emulated=True)
         elif isinstance(frame, VADParamsUpdateFrame):
             if self.vad_analyzer:
-                self.vad_analyzer.set_params(frame.params)
+                self.vad_analyzer.set_params(frame.params, self.logger)
                 speech_frame = SpeechControlParamsFrame(
                     vad_params=frame.params,
                     turn_params=self._params.turn_analyzer.params
@@ -445,7 +445,10 @@ class BaseInputTransport(FrameProcessor):
             await self._handle_user_interruption(VADState.QUIET)
 
     async def _run_turn_analyzer(
-        self, frame: InputAudioRawFrame, vad_state: VADState, previous_vad_state: VADState
+        self,
+        frame: InputAudioRawFrame,
+        vad_state: VADState,
+        previous_vad_state: VADState,
     ):
         """Run turn analysis on audio frame and handle results."""
         is_speech = vad_state == VADState.SPEAKING or vad_state == VADState.STARTING