dv-pipecat-ai 0.0.85.dev832__tar.gz → 0.0.85.dev834__tar.gz

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev832
+Version: 0.0.85.dev834
 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.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/processors/aggregators/llm_response.py

@@ -49,7 +49,6 @@ from pipecat.frames.frames import (
     OpenAILLMContextAssistantTimestampFrame,
     SpeechControlParamsFrame,
     StartFrame,
-    StartInterruptionFrame,
     TextFrame,
     TranscriptDropFrame,
     TranscriptionFrame,
@@ -473,8 +472,8 @@ class LLMUserContextAggregator(LLMContextResponseAggregator):
             frame: The frame to process.
             direction: The direction of frame flow in the pipeline.
         """
-        if isinstance(frame, StartInterruptionFrame):
-            self.logger.debug("Received StartInterruptionFrame")
+        if isinstance(frame, InterruptionFrame):
+            self.logger.debug("Received InterruptionFrame")
         await super().process_frame(frame, direction)
 
         if isinstance(frame, StartFrame):
@@ -560,7 +559,7 @@ class LLMUserContextAggregator(LLMContextResponseAggregator):
                         "Triggering interruption - pushing BotInterruptionFrame and aggregation"
                     )
                     # await self.push_frame(BotInterruptionFrame(), FrameDirection.UPSTREAM)
-                    await self.push_frame(StartInterruptionFrame(), FrameDirection.DOWNSTREAM)
+                    await self.push_frame(InterruptionFrame(), FrameDirection.DOWNSTREAM)
                     self.logger.debug("Pushed BotInterruptionFrame")
                 # No interruption config - normal behavior (always push aggregation)
                 await self._process_aggregation()
@@ -596,12 +595,8 @@ class LLMUserContextAggregator(LLMContextResponseAggregator):
         """Notify upstream processors that pending transcripts should be dropped."""
         if self._pending_transcription_ids:
             drop_frame = TranscriptDropFrame(transcript_ids=list(self._pending_transcription_ids))
-            self.logger.debug(
-                f"Dropping {len(self._pending_transcription_ids)} transcript chunk(s) due to {reason}"
-            )
             await self.push_frame(drop_frame, FrameDirection.UPSTREAM)
         self._pending_transcription_ids.clear()
-        self._aggregation = ""
 
     async def _start(self, frame: StartFrame):
         self._create_aggregation_task()

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/processors/dtmf_aggregator.py

@@ -1,3 +1,5 @@
+"""DTMF aggregator processor for collecting and flushing DTMF input digits."""
+
 import asyncio
 
 from pipecat.frames.frames import (
@@ -8,8 +10,8 @@ from pipecat.frames.frames import (
     EndFrame,
     Frame,
     InputDTMFFrame,
+    InterruptionFrame,
     StartDTMFCaptureFrame,
-    StartInterruptionFrame,
     TranscriptionFrame,
     WaitForDTMFFrame,
 )
@@ -19,10 +21,11 @@ from pipecat.utils.time import time_now_iso8601
 
 class DTMFAggregator(FrameProcessor):
     """Aggregates DTMF frames using idle wait logic.
+
     The aggregator accumulates digits from incoming InputDTMFFrame instances.
     It flushes the aggregated digits by emitting a TranscriptionFrame when:
       - No new digit arrives within the specified timeout period,
-      - The termination digit (“#”) is received, or
+      - The termination digit ("#") is received, or
       - The number of digits aggregated equals the configured 'digits' value.
     """
 
@@ -34,7 +37,9 @@ class DTMFAggregator(FrameProcessor):
         digits: int = None,
         **kwargs,
     ):
-        """:param timeout: Idle timeout in seconds before flushing the aggregated digits.
+        """Initialize the DTMF aggregator.
+
+        :param timeout: Idle timeout in seconds before flushing the aggregated digits.
         :param digits: Number of digits to aggregate before flushing.
         """
         super().__init__(**kwargs)
@@ -48,6 +53,7 @@ class DTMFAggregator(FrameProcessor):
         self._dtmf_capture_active = False
 
     async def process_frame(self, frame: Frame, direction: FrameDirection) -> None:
+        """Process incoming frames and handle DTMF input aggregation."""
         # Handle DTMF frames.
         await super().process_frame(frame, direction)
 
@@ -69,8 +75,8 @@ class DTMFAggregator(FrameProcessor):
             self._digit_event.set()  # Trigger the timeout handler
             await self._start_dtmf_capture()
             await self.push_frame(frame, direction)
-        elif isinstance(frame, StartInterruptionFrame):
-            self.logger.debug("Received StartInterruptionFrame")
+        elif isinstance(frame, InterruptionFrame):
+            self.logger.debug("Received InterruptionFrame")
             if self._aggregation:
                 await self.flush_aggregation()
             await self._end_dtmf_capture()
@@ -108,9 +114,7 @@ class DTMFAggregator(FrameProcessor):
         if "digits" in settings:
             new_digits = settings["digits"]
             if new_digits != self._digits:
-                self.logger.debug(
-                    f"Updating DTMF digits from {self._digits} to {new_digits}"
-                )
+                self.logger.debug(f"Updating DTMF digits from {self._digits} to {new_digits}")
                 self._digits = new_digits
                 settings_changed = True
 
@@ -125,9 +129,7 @@ class DTMFAggregator(FrameProcessor):
                 new_end_on = set(end_value)
 
             if new_end_on != self._end_on:
-                self.logger.debug(
-                    f"Updating DTMF end_on from {self._end_on} to {new_end_on}"
-                )
+                self.logger.debug(f"Updating DTMF end_on from {self._end_on} to {new_end_on}")
                 self._end_on = new_end_on
                 settings_changed = True
 
@@ -142,9 +144,7 @@ class DTMFAggregator(FrameProcessor):
                 new_reset_on = set(reset_value)
 
             if new_reset_on != self._reset_on:
-                self.logger.debug(
-                    f"Updating DTMF reset_on from {self._reset_on} to {new_reset_on}"
-                )
+                self.logger.debug(f"Updating DTMF reset_on from {self._reset_on} to {new_reset_on}")
                 self._reset_on = new_reset_on
                 settings_changed = True
 
@@ -183,9 +183,7 @@ class DTMFAggregator(FrameProcessor):
     def _create_aggregation_task(self, raise_timeout: bool = False) -> None:
         """Creates the aggregation task if it hasn't been created yet."""
         if not self._aggregation_task:
-            self._aggregation_task = self.create_task(
-                self._aggregation_task_handler(raise_timeout)
-            )
+            self._aggregation_task = self.create_task(self._aggregation_task_handler(raise_timeout))
 
     async def _stop_aggregation_task(self) -> None:
         """Stops the aggregation task."""
@@ -198,9 +196,7 @@ class DTMFAggregator(FrameProcessor):
         while True:
             try:
                 # Wait for a new digit signal with a timeout.
-                await asyncio.wait_for(
-                    self._digit_event.wait(), timeout=self._idle_timeout
-                )
+                await asyncio.wait_for(self._digit_event.wait(), timeout=self._idle_timeout)
                 self._digit_event.clear()
             except asyncio.TimeoutError:
                 # No new digit arrived within the timeout period; flush if needed
@@ -216,7 +212,7 @@ class DTMFAggregator(FrameProcessor):
             aggregated_frame.metadata["push_aggregation"] = True
 
             # Send interruption frame (as per original design)
-            await self.push_frame(StartInterruptionFrame(), FrameDirection.DOWNSTREAM)
+            await self.push_frame(InterruptionFrame(), FrameDirection.DOWNSTREAM)
 
             # Push the transcription frame
             await self.push_frame(aggregated_frame, FrameDirection.DOWNSTREAM)

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/serializers/asterisk.py

@@ -1,4 +1,6 @@
 # asterisk_ws_serializer.py
+"""Frame serializer for Asterisk WebSocket communication."""
+
 import base64
 import json
 from typing import Literal, Optional
@@ -12,8 +14,8 @@ from pipecat.frames.frames import (
     EndFrame,
     Frame,
     InputAudioRawFrame,
+    InterruptionFrame,
     StartFrame,
-    StartInterruptionFrame,
     TransportMessageFrame,
     TransportMessageUrgentFrame,
 )
@@ -21,6 +23,8 @@ from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializer
 
 
 class AsteriskFrameSerializer(FrameSerializer):
+    """Serializes Pipecat frames to/from Asterisk WebSocket JSON messages."""
+
     class InputParams(BaseModel):
         """Configuration parameters for AsteriskFrameSerializer.
 
@@ -39,6 +43,12 @@ class AsteriskFrameSerializer(FrameSerializer):
         auto_hang_up: bool = False  # no-op here; adapter handles hangup
 
     def __init__(self, stream_id: str, params: Optional[InputParams] = None):
+        """Initialize the Asterisk frame serializer.
+
+        Args:
+            stream_id: Unique identifier for the media stream.
+            params: Configuration parameters for the serializer.
+        """
         self._stream_id = stream_id
         self._params = params or AsteriskFrameSerializer.InputParams()
         self._tel_rate = self._params.telephony_sample_rate
@@ -49,13 +59,16 @@ class AsteriskFrameSerializer(FrameSerializer):
 
     @property
     def type(self) -> FrameSerializerType:
+        """Return the serializer type (TEXT for JSON messages)."""
         return FrameSerializerType.TEXT  # we send/recv JSON strings
 
     async def setup(self, frame: StartFrame):
+        """Setup the serializer with audio parameters from the StartFrame."""
         self._sample_rate = self._params.sample_rate or frame.audio_in_sample_rate
 
     # Pipecat -> Adapter (play to caller)
     async def serialize(self, frame: Frame) -> str | bytes | None:
+        """Serialize Pipecat frames to Asterisk WebSocket JSON messages."""
         # On pipeline end, ask bridge to hang up
         if (
             self._params.auto_hang_up
@@ -64,7 +77,7 @@ class AsteriskFrameSerializer(FrameSerializer):
         ):
             self._hangup_sent = True
             return json.dumps({"event": "hangup"})
-        if isinstance(frame, StartInterruptionFrame):
+        if isinstance(frame, InterruptionFrame):
             return json.dumps({"event": "clear", "streamId": self._stream_id})
         if isinstance(frame, AudioRawFrame):
             pcm = frame.audio
@@ -114,6 +127,7 @@ class AsteriskFrameSerializer(FrameSerializer):
 
     # Adapter -> Pipecat (audio from caller)
     async def deserialize(self, data: str | bytes) -> Frame | None:
+        """Deserialize Asterisk WebSocket JSON messages to Pipecat frames."""
         try:
             msg = json.loads(data)
         except Exception:

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/serializers/convox.py

@@ -22,9 +22,9 @@ from pipecat.frames.frames import (
     Frame,
     InputAudioRawFrame,
     InputDTMFFrame,
+    InterruptionFrame,
     KeypadEntry,
     StartFrame,
-    StartInterruptionFrame,
     TransportMessageFrame,
     TransportMessageUrgentFrame,
 )
@@ -117,7 +117,7 @@ class ConVoxFrameSerializer(FrameSerializer):
             self._call_ended = True
             # Return the callEnd event to be sent via the WebSocket
             return await self._send_call_end_event()
-        elif isinstance(frame, StartInterruptionFrame):
+        elif isinstance(frame, InterruptionFrame):
             # Clear/interrupt command for ConVox
             message = {
                 "event": "clear",

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/serializers/custom.py

@@ -28,8 +28,8 @@ from pipecat.frames.frames import (
     EndFrame,
     Frame,
     InputAudioRawFrame,
+    InterruptionFrame,
     StartFrame,
-    StartInterruptionFrame,
     TransportMessageFrame,
     TransportMessageUrgentFrame,
 )
@@ -121,7 +121,7 @@ class CustomFrameSerializer(FrameSerializer):
         Returns:
             Serialized data as JSON string, or None if the frame isn't handled.
         """
-        if isinstance(frame, StartInterruptionFrame):
+        if isinstance(frame, InterruptionFrame):
             # Send clear event to instruct client to discard buffered audio
             answer = {"event": "clear", "stream_sid": self._stream_sid}
             return json.dumps(answer)

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/services/sarvam/tts.py

@@ -23,7 +23,6 @@ from pipecat.frames.frames import (
     InterruptionFrame,
     LLMFullResponseEndFrame,
     StartFrame,
-    StartInterruptionFrame,
     TTSAudioRawFrame,
     TTSStartedFrame,
     TTSStoppedFrame,

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/services/vistaar/llm.py

@@ -14,15 +14,15 @@ from loguru import logger
 from pydantic import BaseModel, Field
 
 from pipecat.frames.frames import (
-    EndFrame,
     CancelFrame,
+    EndFrame,
     Frame,
+    InterruptionFrame,
     LLMFullResponseEndFrame,
     LLMFullResponseStartFrame,
     LLMMessagesFrame,
     LLMTextFrame,
     LLMUpdateSettingsFrame,
-    StartInterruptionFrame,
 )
 from pipecat.processors.aggregators.llm_response import (
     LLMAssistantAggregatorParams,
@@ -391,7 +391,7 @@ class VistaarLLMService(LLMService):
             )
             await self.push_frame(frame, direction)
             return
-        elif isinstance(frame, StartInterruptionFrame):
+        elif isinstance(frame, InterruptionFrame):
             await self._handle_interruption()
             await self.push_frame(frame, direction)
             return
@@ -467,4 +467,4 @@ class VistaarLLMService(LLMService):
 
     def can_generate_metrics(self) -> bool:
         """Check if this service can generate processing metrics."""
-        return True
+        return True

{dv_pipecat_ai-0.0.85.dev832 → dv_pipecat_ai-0.0.85.dev834}/src/pipecat/transports/base_output.py

@@ -50,6 +50,11 @@ from pipecat.utils.time import nanoseconds_to_seconds
 
 # TODO: When we use GeminiMultimodalLiveLLMService, we need to change this to 0.35 but that creates issue for faster TTS.
 BOT_VAD_STOP_SECS = 0.30
+# For the very first bot utterance (e.g., intro), we can safely
+# detect end-of-speech sooner to improve responsiveness for the
+# user’s first short reply. Keep conservative to avoid mid-utterance
+# false stops when TTS streams quickly.
+FIRST_BOT_VAD_STOP_SECS = 0.08
 
 
 class BaseOutputTransport(FrameProcessor):
@@ -406,6 +411,9 @@ class BaseOutputTransport(FrameProcessor):
             self._bot_speaking_frame_period = 0.2
             # Last time the bot actually spoke.
             self._bot_speech_last_time = 0
+            # Before the first stop event, we use a shorter silence
+            # threshold to make the first turn more responsive.
+            self._first_stop_pending = True
 
             self._audio_task: Optional[asyncio.Task] = None
             self._video_task: Optional[asyncio.Task] = None
@@ -631,6 +639,10 @@ class BaseOutputTransport(FrameProcessor):
 
             self._bot_speaking = False
 
+            # Mark that the first stop has been completed so subsequent
+            # stops use the regular (longer) VAD stop threshold.
+            self._first_stop_pending = False
+
             # Clean audio buffer (there could be tiny left overs if not multiple
             # to our output chunk size).
             self._audio_buffer = bytearray()
@@ -690,9 +702,14 @@ class BaseOutputTransport(FrameProcessor):
             async def without_mixer(vad_stop_secs: float) -> AsyncGenerator[Frame, None]:
                 while True:
                     try:
-                        frame = await asyncio.wait_for(
-                            self._audio_queue.get(), timeout=vad_stop_secs
+                        # Use a shorter timeout only for the first bot stop to
+                        # accelerate the initial turn handoff right after the intro.
+                        timeout = (
+                            FIRST_BOT_VAD_STOP_SECS
+                            if getattr(self, "_first_stop_pending", True)
+                            else BOT_VAD_STOP_SECS
                         )
+                        frame = await asyncio.wait_for(self._audio_queue.get(), timeout=timeout)
                         yield frame
                         self._audio_queue.task_done()
                     except asyncio.TimeoutError:
@@ -713,7 +730,13 @@ class BaseOutputTransport(FrameProcessor):
                     except asyncio.QueueEmpty:
                         # Notify the bot stopped speaking upstream if necessary.
                         diff_time = time.time() - last_frame_time
-                        if diff_time > vad_stop_secs:
+                        # Use a shorter threshold for the first stop only.
+                        current_stop_secs = (
+                            FIRST_BOT_VAD_STOP_SECS
+                            if getattr(self, "_first_stop_pending", True)
+                            else BOT_VAD_STOP_SECS
+                        )
+                        if diff_time > current_stop_secs:
                             await self._bot_stopped_speaking()
                         # Generate an audio frame with only the mixer's part.
                         frame = OutputAudioRawFrame(