dv-pipecat-ai 0.0.85.dev861__tar.gz → 0.0.85.dev863__tar.gz

{dv_pipecat_ai-0.0.85.dev861/src/dv_pipecat_ai.egg-info → dv_pipecat_ai-0.0.85.dev863}/PKG-INFO

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev861
+Version: 0.0.85.dev863
 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.dev861 → dv_pipecat_ai-0.0.85.dev863}/src/dv_pipecat_ai.egg-info/SOURCES.txt

@@ -239,6 +239,7 @@ src/pipecat/runner/types.py
 src/pipecat/runner/utils.py
 src/pipecat/serializers/__init__.py
 src/pipecat/serializers/asterisk.py
+src/pipecat/serializers/asterisk_chan_websocket_original.py
 src/pipecat/serializers/base_serializer.py
 src/pipecat/serializers/convox.py
 src/pipecat/serializers/custom.py

{dv_pipecat_ai-0.0.85.dev861 → dv_pipecat_ai-0.0.85.dev863}/src/pipecat/frames/frames.py

@@ -1055,6 +1055,38 @@ class MetricsFrame(SystemFrame):
     data: List[MetricsData]
 
 
+@dataclass
+class FunctionCallTrackingFrame(SystemFrame):
+    """Frame for tracking completed function call execution details.
+    
+    Emitted when functions complete to track timing, parameters, 
+    responses, and status for analytics and debugging.
+    
+    Parameters:
+        message_id: ID of the transcript message that triggered this function
+        function_name: Name of the function being called
+        function_type: Type of function ('pre_call' or 'on_call')
+        node_id: Flow node that triggered the function (optional)
+        request_params: Parameters passed to the function
+        response_data: Response returned by the function
+        status_code: HTTP status code or function exit code
+        latency_ms: Function execution time in milliseconds
+        error_details: Error details if function failed
+        metadata: Additional metadata (e.g., query_kb top results)
+    """
+    
+    message_id: str = ""
+    function_name: str = ""
+    function_type: str = ""  # 'pre_call' or 'on_call'
+    node_id: Optional[str] = None
+    request_params: Optional[Dict[str, Any]] = None
+    response_data: Optional[Dict[str, Any]] = None
+    status_code: Optional[int] = None
+    latency_ms: Optional[float] = None
+    error_details: Optional[Dict[str, Any]] = None
+    metadata: Optional[Dict[str, Any]] = None
+
+
 @dataclass
 class FunctionCallFromLLM:
     """Represents a function call returned by the LLM.

{dv_pipecat_ai-0.0.85.dev861 → dv_pipecat_ai-0.0.85.dev863}/src/pipecat/processors/transcript_processor.py

@@ -11,6 +11,7 @@ transcript messages with timestamps, enabling conversation history tracking and
 """
 
 from typing import List, Optional
+import uuid
 
 from loguru import logger
 
@@ -91,7 +92,7 @@ class UserTranscriptProcessor(BaseTranscriptProcessor):
                 user_id=frame.user_id,
                 content=frame.text,
                 timestamp=frame.timestamp,
-                message_id=frame.id,
+                message_id=str(uuid.uuid4()),
             )
             await self._emit_update([message])
         elif isinstance(frame, TranscriptDropFrame):
@@ -190,6 +191,7 @@ class AssistantTranscriptProcessor(BaseTranscriptProcessor):
                     role="assistant",
                     content=content,
                     timestamp=self._aggregation_start_time,
+                    message_id=str(uuid.uuid4()),
                 )
                 await self._emit_update([message])
             else:

{dv_pipecat_ai-0.0.85.dev861 → dv_pipecat_ai-0.0.85.dev863}/src/pipecat/serializers/__init__.py

@@ -1,4 +1,5 @@
 from .base_serializer import FrameSerializer, FrameSerializerType
+from .asterisk import AsteriskFrameSerializer
 from .convox import ConVoxFrameSerializer
 from .custom import CustomFrameSerializer
 from .exotel import ExotelFrameSerializer
@@ -10,6 +11,7 @@ from .vi import VIFrameSerializer
 __all__ = [
     "FrameSerializer",
     "FrameSerializerType",
+    "AsteriskFrameSerializer",
     "ConVoxFrameSerializer",
     "CustomFrameSerializer",
     "ExotelFrameSerializer",

dv_pipecat_ai-0.0.85.dev863/src/pipecat/serializers/asterisk_chan_websocket_original.py

@@ -0,0 +1,339 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Asterisk WebSocket channel frame serialization interfaces for Pipecat."""
+
+import json
+from typing import Optional
+
+from loguru import logger
+from pydantic import BaseModel
+
+from pipecat.audio.dtmf.types import KeypadEntry
+from pipecat.audio.utils import (
+    alaw_to_pcm,
+    create_stream_resampler,
+    pcm_to_alaw,
+    pcm_to_ulaw,
+    ulaw_to_pcm,
+)
+from pipecat.frames.frames import (
+    AudioRawFrame,
+    CancelFrame,
+    EndFrame,
+    Frame,
+    InputAudioRawFrame,
+    InputDTMFFrame,
+    InputTransportMessageFrame,
+    InterruptionFrame,
+    StartFrame,
+)
+from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
+
+
+class AsteriskWsFrameSerializer(FrameSerializer):
+    """Serializer for Asterisk WebSocket channel frames.
+    
+    This serializer handles converting between Pipecat frames and Asterisk WebSocket
+    channel. It provides raw audio conversion (BINARY), and basic signalling(TEXT):
+        Asterisk to pipecat:
+            - when DTMF detected on Asterisk websocket channel we send InputDTMFFrame to pipecat.
+        Pipecat to Asterisk:
+            - when an EndFrame or CancelFrame is processed we send HANGUP to Asterisk websocket channel.
+            - when an InterruptionFrame is processed we send FLUSH_MEDIA to Asterisk websocket channel.
+    """
+
+    class InputParams(BaseModel):
+        """Configuration parameters for AsteriskFrameSerializer.
+        
+        Parameters:
+            asterisk_sample_rate: Sample rate used by Asterisk, defaults to 8000 Hz.
+            encoding: Audio encoding (e.g., "ulaw", "alaw", "slin").
+        """
+        asterisk_sample_rate: int = 8000
+        encoding: str = None  # None means autodetect from Asterisk MEDIA_START event
+
+    def __init__(self, params: Optional[InputParams] = None):
+        """Initialize the AsteriskFrameSerializer.
+        
+        Args:
+            params: Configuration parameters.
+        """
+        self._asterisk_command_format = None  # Will be set to "json" or "plain-text" after receiving the first MEDIA_START event
+        self._input_resampler = create_stream_resampler()
+        self._media_buffering_started = False
+        self._output_resampler = create_stream_resampler()
+        self._params = params or AsteriskWsFrameSerializer.InputParams()
+        self._pipeline_sample_rate = 0  # Will be populated during setup
+
+        self._asterisk_event_handlers = {
+            "MEDIA_START": self._handle_media_start,
+            "MEDIA_XOFF": self._handle_media_xoff,
+            "MEDIA_XON": self._handle_media_xon,
+            "DTMF_END": self._handle_dtmf_end,
+        }
+
+        async def raw_media_passthrough(data, in_sr, out_sr, resampler):
+            """Pass through raw media without any conversion but resample if needed."""
+            return await resampler.resample(data, in_sr, out_sr)
+
+        self._encoders = {
+            "pcmu": pcm_to_ulaw,
+            "pcma": pcm_to_alaw,
+            "pcm16": raw_media_passthrough,
+        }
+
+        self._decoders = {
+            "pcmu": ulaw_to_pcm,
+            "pcma": alaw_to_pcm,
+            "pcm16": raw_media_passthrough,
+        }
+
+    # Asterisk event handlers
+    def _handle_media_start(self, message: dict):
+        """MEDIA_START event handler.
+        
+        MEDIA_START event is the first event we receive from Asterisk, we use it in deserialize method to identity which message format is used by Asterisk (json of plain-text).
+        But besides that, if the encoding is not defined, we attempt to detect it from the MEDIA_START event.
+        There are a few potentially useful parameters provided by Asterisk in the MEDIA_START event message:
+          connection_id: A UUID that will be set on the MEDIA_WEBSOCKET_CONNECTION_ID channel variable.
+          channel: The channel name on Asterisk.
+          channel_id: The channel's unique id on Asterisk.
+          format: The audio format set on the channel.
+          optimal_frame_size: The optimal frame size from Astersisk's perspective. It's not important as we always use media buffering, Asterisk will reframe and retime the audio as needed.
+          ptime: The packetization rate in milliseconds. It's not important as we always use media buffering, Asterisk will reframe and retime the audio as needed.
+          channel_variables: An object containing the variables currently set on the channel. This can be very handy for moving data from dialplan variables to the pipeline.
+        So we send MEDIA_START event object to the pipeline as InputTransportMessageFrame.
+        
+        Args:
+            message: The dictionary representing of the MEDIA_START event message from Asterisk.
+        """
+        logger.info(f"Received MEDIA_START event from Asterisk: {message}")
+        logger.info(
+            f"Optional frame size for TTS: {message.get('optimal_frame_size')} bytes, ptime: {message.get('ptime')} ms, you might want to adjust your output trnasport parameters accordingly."
+        )
+        if self._params.encoding is None:
+            logger.info(
+                "Encoding is not provided, detecting Asterisk audio encoding from MEDIA_START event..."
+            )
+
+            format = message.get("format", "").strip().lower()
+            if format.startswith(
+                "slin"
+            ):  # asterisk slin format are like "slin12" or "slin16" .. "slin192"
+                _, bitrate = format.split("slin")
+                format = "slin"
+
+            if format in self._decoders:
+                self._params.encoding = format
+                logger.info(f"Detected Asterisk audio encoding: {self._params.encoding}")
+                if format.startswith("slin"):
+                    if bitrate:
+                        self._params.asterisk_sample_rate = int(bitrate) * 1000
+                    else:
+                        # in asterisk 'slin' assumes 8000 Hz if bitrate if not specified
+                        self._params.asterisk_sample_rate = 8000
+
+                    logger.info(
+                        f"Detected Asterisk audio format 'slin{bitrate}', setting asterisk_sample_rate to {self._params.asterisk_sample_rate}"
+                    )
+            else:
+                raise ValueError(
+                    f"Unsupported or missing audio encoding in Asterisk MEDIA_START event: {format}"
+                )
+        return InputTransportMessageFrame(message=message)
+
+    def _handle_media_xoff(self, message: dict):
+        """MEDIA_XOFF event handler.
+        
+        The Asterisk's channel driver will send this event to the app when the frame queue length reaches the high water (XOFF) level.
+        The app should then pause sending media. Any media sent after this has a high probability of being dropped.
+        Asterisk buffer is ~1000 frames by 20ms (160 bytes for ulaw/alaw at 8000Hz), so it's ~20 seconds of audio or 160KB,
+        but the messages is sent when the buffer reaches the high water mark of ~900 frames.
+        Currently, we don't have flow control implemented yet, so we just log the event.
+        
+        Args:
+            message: The dictionary representing of the MEDIA_XOFF event message from Asterisk.
+        """
+        logger.error(
+            f"Received MEDIA_XOFF event from Asterisk: {message}. Oops, we don't have flow control implemented yet, probably Asterisk will drop the following audio frames."
+        )
+        return None
+
+    def _handle_media_xon(self, message: dict):
+        """MEDIA_XON event handler.
+        
+        The Asterisk's channel driver will send this event to the app when the frame queue length drops below the low water (XON) level.
+        The app can then resume sending media.
+        
+        Args:
+            message: The dictionary representing of the MEDIA_XON event message from Asterisk.
+        """
+        logger.info(
+            f"Received MEDIA_XON event from Asterisk: {message}. Asterisk audio buffer is ready to receive audio again."
+        )
+        return None
+
+    def _handle_dtmf_end(self, message: dict) -> Optional[InputDTMFFrame]:
+        """DTMF_END event handler.
+        
+        Handles DTMF_END events from Asterisk and converts them to InputDTMFFrame.
+        
+        Args:
+            message: The dictionary representing of the DTMF_END event message from Asterisk.
+        Returns:
+            An InputDTMFFrame if a valid DTMF digit is found, otherwise None.
+        """
+        digit = message.get("digit")
+        if digit:
+            logger.info(f"DTMF received: {digit}")
+            try:
+                return InputDTMFFrame(KeypadEntry(digit))
+            except ValueError:
+                # Handle case where string doesn't match any enum value
+                logger.warning(f"Invalid DTMF digit received: {digit}")
+                return None
+        return None
+
+    @property
+    def type(self) -> FrameSerializerType:
+        """Get the serialization type supported by this serializer.
+        Returns:
+            Always returns FrameSerializerType.MIXED.
+            It's not used by the serializer websocket transport and defined for compatibility with base class.
+        """
+        return FrameSerializerType.MIXED
+
+    async def setup(self, frame: StartFrame):
+        """Initialize the serializer with startup configuration.
+        Defined to set the pipeline input sample rate for resampling.
+        Args:
+            frame: StartFrame containing initialization parameters.
+        """
+        self._pipeline_sample_rate = frame.audio_in_sample_rate
+
+    async def serialize(self, frame: Frame) -> str | bytes | None:
+        """Convert a frame to its serialized representation sutable for Asterisk WebSocket channel.
+        Args:
+            frame: The frame to serialize.
+        Returns:
+            Serialized frame data as string, bytes, or None if serialization fails.
+        """
+        if isinstance(frame, AudioRawFrame):
+            data = frame.audio
+
+            encoding = self._params.encoding.strip().lower()
+
+            try:
+                encoder = self._encoders[encoding]
+            except KeyError as e:
+                raise ValueError(f"Unsupported encoding: {self._params.encoding}") from e
+
+            serialized_data = await encoder(
+                data,
+                frame.sample_rate,
+                self._params.asterisk_sample_rate,
+                self._output_resampler,
+            )
+
+            if serialized_data is None or len(serialized_data) == 0:
+                return None
+
+            # Asterisk media WebSocket channels require "START_MEDIA_BUFFERING" to enable audio buffering before sending it to Asterisk core.
+            # When media buffering is enabled, we can send raw binary audio in messages of arbitrary sizes, and Asterisk will frame them properly
+            # and it will generate silence to the channel if the buffer is empty and there is no audio to send.
+            # For our use case, it is crucial, as we can send audio frames of arbitrary sizes from Pipecat to Asterisk without worrying about framing/timing.
+            # Without media buffering enabled, Asterisk expects audio frames of specific sizes and timings, which complicates the implementation a lot,
+            # and probably not a good idea in general for TCP-based transports such as websockets.
+            # Therefore, we always send the "START_MEDIA_BUFFERING" command on before the first audio frame we send to Asterisk.
+
+            if not self._media_buffering_started:
+                self._media_buffering_started = True
+                command = (
+                    "START_MEDIA_BUFFERING"
+                    if self._asterisk_command_format == "plain-text"
+                    else '{"command": "START_MEDIA_BUFFERING"}'
+                )
+                return (command, serialized_data)
+
+            return serialized_data
+
+        elif isinstance(frame, InterruptionFrame):
+            return (
+                "FLUSH_MEDIA"
+                if self._asterisk_command_format == "plain-text"
+                else '{"command": "FLUSH_MEDIA"}'
+            )
+        elif isinstance(frame, (EndFrame, CancelFrame)):
+            return (
+                "HANGUP"
+                if self._asterisk_command_format == "plain-text"
+                else '{"command": "HANGUP"}'
+            )
+
+        # Return None for unhandled frames
+        return None
+
+    async def deserialize(self, data: str | bytes) -> Frame | None:
+        """Convert serialized data from Asterisk's websocket channel back to a frame object.
+        Args:
+            data: Serialized frame data as string or bytes.
+        Returns:
+            Reconstructed Frame object, or None if deserialization fails.
+        """
+        if isinstance(data, bytes):
+            # If data is bytes, it's audio data
+            try:
+                decoder = self._decoders[self._params.encoding.strip().lower()]
+            except KeyError as e:
+                raise ValueError(f"Unsupported encoding: {self._params.encoding}") from e
+
+            deserialized_data = await decoder(
+                data,
+                self._params.asterisk_sample_rate,
+                self._pipeline_sample_rate,
+                self._input_resampler,
+            )
+
+            if deserialized_data is None or len(deserialized_data) == 0:
+                return None
+
+            audio_frame = InputAudioRawFrame(
+                audio=deserialized_data, num_channels=1, sample_rate=self._pipeline_sample_rate
+            )
+
+            return audio_frame
+
+        elif isinstance(data, str):
+            # Identify the format of signalling event from Asterisk websocket channel message based
+            # on the first message in the channel: "MEDIA_START", it might be json or plain-text
+            if self._asterisk_command_format is None and "MEDIA_START" in data:
+                try:
+                    message = json.loads(data)
+                    if message.get("event") == "MEDIA_START":
+                        self._asterisk_command_format = "json"
+                except json.JSONDecodeError:
+                    self._asterisk_command_format = "plain-text"
+
+            # Parse the message - try JSON first, fall back to plain-text
+            event = {}
+            try:
+                event = json.loads(data)
+            except json.JSONDecodeError:
+                # Fall back to plain-text parsing (space-separated key:value pairs)
+                event_entries = data.split(" ")
+                event["event"] = event_entries[0]
+                for entry in event_entries[1:]:
+                    if ":" in entry:
+                        key, value = entry.split(":", 1)
+                        event[key] = value
+
+            handler = self._asterisk_event_handlers.get(event.get("event"))
+            if handler:
+                return handler(event)
+            else:
+                # we don't have a handler for this type of event
+                return None

{dv_pipecat_ai-0.0.85.dev861 → dv_pipecat_ai-0.0.85.dev863}/src/pipecat/serializers/base_serializer.py

@@ -18,10 +18,12 @@ class FrameSerializerType(Enum):
     Parameters:
         BINARY: Binary serialization format for compact representation.
         TEXT: Text-based serialization format for human-readable output.
+        MIXED: Mixed format supporting both binary and text messages (e.g., Asterisk chan_websocket).
     """
 
     BINARY = "binary"
     TEXT = "text"
+    MIXED = "mixed"
 
 
 class FrameSerializer(ABC):

{dv_pipecat_ai-0.0.85.dev861 → dv_pipecat_ai-0.0.85.dev863}/src/pipecat/transports/websocket/fastapi.py

@@ -81,20 +81,28 @@ class FastAPIWebsocketClient:
     """WebSocket client wrapper for handling connections and message passing.
 
     Manages WebSocket state, message sending/receiving, and connection lifecycle
-    with support for both binary and text message types.
+    with support for binary, text, and mixed message types.
     """
 
-    def __init__(self, websocket: WebSocket, is_binary: bool, callbacks: FastAPIWebsocketCallbacks):
+    def __init__(
+        self,
+        websocket: WebSocket,
+        is_binary: bool,
+        callbacks: FastAPIWebsocketCallbacks,
+        is_mixed: bool = False,
+    ):
         """Initialize the WebSocket client.
 
         Args:
             websocket: The FastAPI WebSocket connection.
             is_binary: Whether to use binary message format.
             callbacks: Event callback functions.
+            is_mixed: Whether to use mixed mode (both binary and text messages).
         """
         self._websocket = websocket
         self._closing = False
         self._is_binary = is_binary
+        self._is_mixed = is_mixed
         self._callbacks = callbacks
         self._leave_counter = 0
         self._conversation_id = None
@@ -109,26 +117,56 @@ class FastAPIWebsocketClient:
         if _.metadata and "call_id" in _.metadata:
             self._conversation_id = _.metadata["call_id"]
 
+    async def _iter_mixed(self) -> typing.AsyncIterator[bytes | str]:
+        """Async generator for receiving mixed binary and text WebSocket messages.
+
+        Yields:
+            Either bytes or string based on message type.
+        """
+        while True:
+            message = await self._websocket.receive()
+            if message["type"] == "websocket.disconnect":
+                break
+            if "bytes" in message and message["bytes"] is not None:
+                yield message["bytes"]
+            elif "text" in message and message["text"] is not None:
+                yield message["text"]
+
     def receive(self) -> typing.AsyncIterator[bytes | str]:
         """Get an async iterator for receiving WebSocket messages.
 
         Returns:
             An async iterator yielding bytes or strings based on message type.
         """
+        if self._is_mixed:
+            return self._iter_mixed()
         return self._websocket.iter_bytes() if self._is_binary else self._websocket.iter_text()
 
-    async def send(self, data: str | bytes):
-        """Send data through the WebSocket connection.
+    async def _send_single(self, data: str | bytes):
+        """Send a single message through the WebSocket connection.
 
         Args:
             data: The data to send (string or bytes).
         """
+        if isinstance(data, bytes):
+            await self._websocket.send_bytes(data)
+        elif isinstance(data, str):
+            await self._websocket.send_text(data)
+
+    async def send(self, data: str | bytes | tuple):
+        """Send data through the WebSocket connection.
+
+        Args:
+            data: The data to send (string, bytes, or tuple for multiple messages).
+        """
         try:
             if self._can_send():
-                if self._is_binary:
-                    await self._websocket.send_bytes(data)
+                # Handle tuple of messages (e.g., for sending command + audio together)
+                if isinstance(data, tuple):
+                    for item in data:
+                        await self._send_single(item)
                 else:
-                    await self._websocket.send_text(data)
+                    await self._send_single(data)
         except Exception as e:
             if isinstance(e, WebSocketDisconnect):
                 logger.warning(
@@ -523,9 +561,11 @@ class FastAPIWebsocketTransport(BaseTransport):
         )
 
         is_binary = False
+        is_mixed = False
         if self._params.serializer:
             is_binary = self._params.serializer.type == FrameSerializerType.BINARY
-        self._client = FastAPIWebsocketClient(websocket, is_binary, self._callbacks)
+            is_mixed = self._params.serializer.type == FrameSerializerType.MIXED
+        self._client = FastAPIWebsocketClient(websocket, is_binary, self._callbacks, is_mixed)
 
         self._input = FastAPIWebsocketInputTransport(
             self, self._client, self._params, name=self._input_name