dv-pipecat-ai 0.0.85.dev818__py3-none-any.whl → 0.0.85.dev858__py3-none-any.whl

pipecat/processors/frame_processor.py

@@ -436,10 +436,53 @@ class FrameProcessor(BaseObject):
             if frame:
                 await self.push_frame(frame)
 
+    async def start_connection_metrics(self):
+        """Start connection establishment metrics collection."""
+        if self.can_generate_metrics() and self.metrics_enabled:
+            await self._metrics.start_connection_metrics()
+
+    async def stop_connection_metrics(
+        self, 
+        success: bool = True, 
+        error: str = None,
+        connection_type: str = None
+    ):
+        """Stop connection metrics collection and emit metrics frame.
+        
+        Args:
+            success: Whether the connection was successful.
+            error: Error message if connection failed.
+            connection_type: Type of connection (websocket, http, etc.).
+        """
+        if self.can_generate_metrics() and self.metrics_enabled:
+            frame = await self._metrics.stop_connection_metrics(success, error, connection_type)
+            if frame:
+                await self.push_frame(frame)
+
+
+    async def start_reconnection_metrics(self):
+        """Start reconnection metrics collection."""
+        if self.can_generate_metrics() and self.metrics_enabled:
+            await self._metrics.start_reconnection_metrics()
+
+    async def stop_reconnection_metrics(self, success: bool = True, reason: str = None):
+        """Stop reconnection metrics collection and emit metrics frame.
+        
+        Args:
+            success: Whether the reconnection was successful.
+            reason: Reason for reconnection.
+        """
+        if self.can_generate_metrics() and self.metrics_enabled:
+            frame = await self._metrics.stop_reconnection_metrics(success, reason)
+            if frame:
+                await self.push_frame(frame)
+
+
     async def stop_all_metrics(self):
         """Stop all active metrics collection."""
         await self.stop_ttfb_metrics()
         await self.stop_processing_metrics()
+        await self.stop_connection_metrics()
 
     def create_task(self, coroutine: Coroutine, name: Optional[str] = None) -> asyncio.Task:
         """Create a new task managed by this processor.
@@ -591,7 +634,7 @@ class FrameProcessor(BaseObject):
 
     async def pause_processing_system_frames(self):
         """Pause processing of queued system frames."""
-        logger.trace(f"{self}: pausing system frame processing")
+        self.logger.trace(f"{self}: pausing system frame processing")
         self.__should_block_system_frames = True
         if self.__input_event:
             self.__input_event.clear()
@@ -811,8 +854,8 @@ class FrameProcessor(BaseObject):
         Returns:
             True if the processor has been started.
         """
-        if not self.__started:
-            logger.error(f"{self} Trying to process {frame} but StartFrame not received yet")
+        if not self.__started and not isinstance(frame, SystemFrame):
+            self.logger.error(f"{self} Trying to process {frame} but StartFrame not received yet")
         return self.__started
 
     def __create_input_task(self):
@@ -876,7 +919,7 @@ class FrameProcessor(BaseObject):
 
             await self._call_event_handler("on_after_process_frame", frame)
         except Exception as e:
-            logger.exception(f"{self}: error processing frame: {e}")
+            self.logger.exception(f"{self}: error processing frame: {e}")
             await self.push_error(ErrorFrame(str(e)))
 
     async def __input_frame_task_handler(self):
@@ -890,11 +933,11 @@ class FrameProcessor(BaseObject):
             (frame, direction, callback) = await self.__input_queue.get()
 
             if self.__should_block_system_frames and self.__input_event:
-                logger.trace(f"{self}: system frame processing paused")
+                self.logger.trace(f"{self}: system frame processing paused")
                 await self.__input_event.wait()
                 self.__input_event.clear()
                 self.__should_block_system_frames = False
-                logger.trace(f"{self}: system frame processing resumed")
+                self.logger.trace(f"{self}: system frame processing resumed")
 
             if isinstance(frame, SystemFrame):
                 await self.__process_frame(frame, direction, callback)
@@ -913,11 +956,11 @@ class FrameProcessor(BaseObject):
             (frame, direction, callback) = await self.__process_queue.get()
 
             if self.__should_block_frames and self.__process_event:
-                logger.trace(f"{self}: frame processing paused")
+                self.logger.trace(f"{self}: frame processing paused")
                 await self.__process_event.wait()
                 self.__process_event.clear()
                 self.__should_block_frames = False
-                logger.trace(f"{self}: frame processing resumed")
+                self.logger.trace(f"{self}: frame processing resumed")
 
             await self.__process_frame(frame, direction, callback)
 

pipecat/processors/metrics/frame_processor_metrics.py

@@ -20,6 +20,9 @@ from pipecat.metrics.metrics import (
     TTFBMetricsData,
     TTSUsageMetricsData,
 )
+from pipecat.metrics.connection_metrics import (
+    ConnectionMetricsData,
+)
 from pipecat.utils.asyncio.task_manager import BaseTaskManager
 from pipecat.utils.base_object import BaseObject
 
@@ -46,6 +49,13 @@ class FrameProcessorMetrics(BaseObject):
         self._last_ttfb_time = 0
         self._should_report_ttfb = True
         self._logger = logger
+        
+        # Connection metrics state
+        self._start_connection_time = 0
+        self._connection_attempts = 0
+        self._last_connection_error = None
+        self._reconnection_start_time = 0
+        self._reconnect_count = 0
 
     async def setup(self, task_manager: BaseTaskManager):
         """Set up the metrics collector with a task manager.
@@ -195,3 +205,101 @@ class FrameProcessorMetrics(BaseObject):
         )
         self._logger.debug(f"{self._processor_name()} usage characters: {characters.value}")
         return MetricsFrame(data=[characters])
+
+    async def start_connection_metrics(self):
+        """Start measuring connection establishment time."""
+        self._start_connection_time = time.time()
+        self._connection_attempts += 1
+        self._last_connection_error = None
+
+    async def stop_connection_metrics(
+        self, 
+        success: bool = True, 
+        error: str = None,
+        connection_type: str = None
+    ):
+        """Stop connection measurement and generate metrics frame.
+
+        Args:
+            success: Whether the connection was successful.
+            error: Error message if connection failed.
+            connection_type: Type of connection (websocket, http, etc.).
+
+        Returns:
+            MetricsFrame containing connection data, or None if not measuring.
+        """
+        if self._start_connection_time == 0:
+            return None
+
+        connect_time = time.time() - self._start_connection_time
+        
+        if not success:
+            self._last_connection_error = error
+        
+        logstr = f"{self._processor_name()} connection "
+        logstr += "successful" if success else f"failed: {error}"
+        logstr += f" (attempt #{self._connection_attempts}, {connect_time:.3f}s)"
+        
+        if success:
+            self._logger.debug(logstr)
+        else:
+            self._logger.warning(logstr)
+        
+        connection_data = ConnectionMetricsData(
+            processor=self._processor_name(),
+            model=self._model_name(),
+            connect_time=round(connect_time, 3),
+            success=success,
+            connection_attempts=self._connection_attempts,
+            error_message=error,
+            connection_type=connection_type
+        )
+        
+        self._start_connection_time = 0
+        return MetricsFrame(data=[connection_data])
+
+
+    async def start_reconnection_metrics(self):
+        """Start measuring reconnection downtime."""
+        self._reconnection_start_time = time.time()
+        self._reconnect_count += 1
+
+    async def stop_reconnection_metrics(
+        self, 
+        success: bool = True, 
+        reason: str = None
+    ):
+        """Stop reconnection measurement and generate metrics frame.
+
+        Args:
+            success: Whether the reconnection was successful.
+            reason: Reason for reconnection.
+
+        Returns:
+            MetricsFrame containing reconnection data, or None if not measuring.
+        """
+        if self._reconnection_start_time == 0:
+            return None
+
+        downtime = time.time() - self._reconnection_start_time
+        
+        logstr = f"{self._processor_name()} reconnection #{self._reconnect_count} "
+        logstr += "successful" if success else "failed"
+        logstr += f" (downtime: {downtime:.3f}s)"
+        if reason:
+            logstr += f" - {reason}"
+        
+        self._logger.debug(logstr)
+        
+        reconnection_data = ConnectionMetricsData(
+            processor=self._processor_name(),
+            model=self._model_name(),
+            reconnect_count=self._reconnect_count,
+            downtime=round(downtime, 3),
+            reconnect_success=success,
+            reason=reason
+        )
+        
+        self._reconnection_start_time = 0
+        return MetricsFrame(data=[reconnection_data])
+

pipecat/processors/transcript_processor.py

@@ -20,6 +20,7 @@ from pipecat.frames.frames import (
     EndFrame,
     Frame,
     InterruptionFrame,
+    TranscriptDropFrame,
     TranscriptionFrame,
     TranscriptionMessage,
     TranscriptionUpdateFrame,
@@ -44,6 +45,7 @@ class BaseTranscriptProcessor(FrameProcessor):
         super().__init__(**kwargs)
         self._processed_messages: List[TranscriptionMessage] = []
         self._register_event_handler("on_transcript_update")
+        self._register_event_handler("on_transcript_drop")
 
     async def _emit_update(self, messages: List[TranscriptionMessage]):
         """Emit transcript updates for new messages.
@@ -57,6 +59,19 @@ class BaseTranscriptProcessor(FrameProcessor):
             await self._call_event_handler("on_transcript_update", update_frame)
             await self.push_frame(update_frame)
 
+    async def _handle_transcript_drop(self, frame: TranscriptDropFrame):
+        """Handle transcript drop notifications by removing stored messages."""
+        if not frame.transcript_ids:
+            return
+
+        await self._call_event_handler("on_transcript_drop", frame)
+
+        drop_ids = set(frame.transcript_ids)
+        if drop_ids:
+            self._processed_messages = [
+                msg for msg in self._processed_messages if msg.message_id not in drop_ids
+            ]
+
 
 class UserTranscriptProcessor(BaseTranscriptProcessor):
     """Processes user transcription frames into timestamped conversation messages."""
@@ -72,9 +87,15 @@ class UserTranscriptProcessor(BaseTranscriptProcessor):
 
         if isinstance(frame, TranscriptionFrame):
             message = TranscriptionMessage(
-                role="user", user_id=frame.user_id, content=frame.text, timestamp=frame.timestamp
+                role="user",
+                user_id=frame.user_id,
+                content=frame.text,
+                timestamp=frame.timestamp,
+                message_id=frame.id,
             )
             await self._emit_update([message])
+        elif isinstance(frame, TranscriptDropFrame):
+            await self._handle_transcript_drop(frame)
 
         await self.push_frame(frame, direction)
 

pipecat/serializers/__init__.py

@@ -5,6 +5,7 @@ from .exotel import ExotelFrameSerializer
 from .plivo import PlivoFrameSerializer
 from .telnyx import TelnyxFrameSerializer
 from .twilio import TwilioFrameSerializer
+from .vi import VIFrameSerializer
 
 __all__ = [
     "FrameSerializer",
@@ -15,6 +16,7 @@ __all__ = [
     "PlivoFrameSerializer",
     "TelnyxFrameSerializer",
     "TwilioFrameSerializer",
+    "VIFrameSerializer",
 ]
 
 # Optional imports

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:

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",

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)