dv-pipecat-ai 0.0.93.dev92__tar.gz → 0.0.93.dev96__tar.gz

{dv_pipecat_ai-0.0.93.dev92/src/dv_pipecat_ai.egg-info → dv_pipecat_ai-0.0.93.dev96}/PKG-INFO

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

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

@@ -252,6 +252,7 @@ src/pipecat/serializers/custom.py
 src/pipecat/serializers/exotel.py
 src/pipecat/serializers/knowlarity.py
 src/pipecat/serializers/livekit.py
+src/pipecat/serializers/maqsam.py
 src/pipecat/serializers/plivo.py
 src/pipecat/serializers/protobuf.py
 src/pipecat/serializers/tatatele.py

{dv_pipecat_ai-0.0.93.dev92 → dv_pipecat_ai-0.0.93.dev96}/src/dv_pipecat_ai.egg-info/scm_file_list.json

@@ -299,6 +299,7 @@
     "src/pipecat/serializers/voicelink.py",
     "src/pipecat/serializers/convox.py",
     "src/pipecat/serializers/exotel.py",
+    "src/pipecat/serializers/maqsam.py",
     "src/pipecat/serializers/protobuf.py",
     "src/pipecat/services/tts_service.py",
     "src/pipecat/services/mcp_service.py",

{dv_pipecat_ai-0.0.93.dev92 → dv_pipecat_ai-0.0.93.dev96}/src/dv_pipecat_ai.egg-info/scm_version.json

@@ -1,7 +1,7 @@
 {
   "tag": "0.0.92",
-  "distance": 92,
-  "node": "g37a2def940eb63431025b68fec77d0978932c38e",
+  "distance": 96,
+  "node": "gb8e2f839eec7d648f881f3cb917930f1e0b87afe",
   "dirty": false,
   "branch": "dv-stage",
   "node_date": "2026-06-25"

{dv_pipecat_ai-0.0.93.dev92 → dv_pipecat_ai-0.0.93.dev96}/src/pipecat/serializers/__init__.py

@@ -6,6 +6,7 @@ from .convox import ConVoxFrameSerializer
 from .custom import CustomFrameSerializer
 from .exotel import ExotelFrameSerializer
 from .knowlarity import KnowlarityFrameSerializer
+from .maqsam import MaqsamFrameSerializer
 from .plivo import PlivoFrameSerializer
 from .telnyx import TelnyxFrameSerializer
 from .tatatele import TataTeleFrameSerializer
@@ -23,6 +24,7 @@ __all__ = [
     "CustomFrameSerializer",
     "ExotelFrameSerializer",
     "KnowlarityFrameSerializer",
+    "MaqsamFrameSerializer",
     "PlivoFrameSerializer",
     "TataTeleFrameSerializer",
     "TelnyxFrameSerializer",

dv_pipecat_ai-0.0.93.dev96/src/pipecat/serializers/maqsam.py

@@ -0,0 +1,130 @@
+"""Maqsam Voice Agent WebSocket protocol serializer for Pipecat."""
+
+import base64
+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 create_stream_resampler, pcm_to_ulaw, ulaw_to_pcm
+from pipecat.frames.frames import (
+    AudioRawFrame,
+    CancelFrame,
+    EndFrame,
+    Frame,
+    InputAudioRawFrame,
+    InputDTMFFrame,
+    InterruptionFrame,
+    OutputTransportMessageFrame,
+    OutputTransportMessageUrgentFrame,
+    StartFrame,
+)
+from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
+
+
+class MaqsamFrameSerializer(FrameSerializer):
+    """Serializer for the Maqsam Voice Agent WebSocket protocol.
+
+    Converts between Pipecat frames and Maqsam's JSON messages. Every Maqsam message carries a
+    ``type`` key (no Twilio-style ``event`` field) and audio is Base64-encoded G.711 mu-law at
+    8000 Hz, mono.
+
+    Key differences from Twilio/VoiceLink:
+    - Messages are keyed by ``type`` (``audio.input`` / ``response.stream``), not ``event``.
+    - Audio: mu-law (PCMU), 8000 Hz (VoiceLink is A-law).
+    - Barge-in is signalled by ``speech.started`` (Maqsam then flushes already-sent bot audio),
+      which is the analog of Twilio's ``clear``.
+    - Audio messages carry no stream id; ``stream_sid`` is accepted for factory parity only.
+
+    The ``session.setup`` -> ``session.ready`` handshake and ``call.event`` (started) are handled
+    in the WebSocket connection handler before the Pipecat pipeline runs, not here.
+    """
+
+    class InputParams(BaseModel):
+        """Configuration for MaqsamFrameSerializer.
+
+        Parameters:
+            maqsam_sample_rate: Sample rate used by Maqsam, defaults to 8000 Hz.
+            sample_rate: Optional override for the pipeline input sample rate.
+            auto_hang_up: Send ``call.hangup`` to Maqsam on EndFrame/CancelFrame.
+        """
+
+        maqsam_sample_rate: int = 8000
+        sample_rate: Optional[int] = None
+        auto_hang_up: bool = True
+
+    def __init__(self, stream_sid: Optional[str] = None, params: Optional[InputParams] = None):
+        self._params = params or MaqsamFrameSerializer.InputParams()
+        self._stream_sid = stream_sid  # unused on the wire; kept for factory signature parity
+        self._maqsam_sample_rate = self._params.maqsam_sample_rate
+        self._sample_rate = 0  # pipeline input rate, resolved in setup()
+        self._input_resampler = create_stream_resampler()
+        self._output_resampler = create_stream_resampler()
+        self._hangup_attempted = False
+
+    @property
+    def type(self) -> FrameSerializerType:
+        return FrameSerializerType.TEXT
+
+    async def setup(self, frame: StartFrame):
+        self._sample_rate = self._params.sample_rate or frame.audio_in_sample_rate
+
+    async def serialize(self, frame: Frame) -> str | bytes | None:
+        if (
+            self._params.auto_hang_up
+            and not self._hangup_attempted
+            and isinstance(frame, (EndFrame, CancelFrame))
+        ):
+            # Normal end: tell Maqsam to hang up. Behaves like closing the socket, but explicit.
+            self._hangup_attempted = True
+            return json.dumps({"type": "call.hangup"})
+        elif isinstance(frame, InterruptionFrame):
+            # Customer barge-in: flush bot audio already buffered on Maqsam's side.
+            return json.dumps({"type": "speech.started"})
+        elif isinstance(frame, AudioRawFrame):
+            # Output: PCM at the frame's rate -> 8kHz mu-law for Maqsam.
+            serialized_data = await pcm_to_ulaw(
+                frame.audio, frame.sample_rate, self._maqsam_sample_rate, self._output_resampler
+            )
+            if serialized_data is None or len(serialized_data) == 0:
+                return None
+            payload = base64.b64encode(serialized_data).decode("utf-8")
+            return json.dumps({"type": "response.stream", "data": {"audio": payload}})
+        elif isinstance(frame, (OutputTransportMessageFrame, OutputTransportMessageUrgentFrame)):
+            # Lets the handler emit raw Maqsam control messages (call.mark, call.redirect, ...).
+            return json.dumps(frame.message)
+
+        return None
+
+    async def deserialize(self, data: str | bytes) -> Frame | None:
+        message = json.loads(data)
+        message_type = message.get("type")
+
+        if message_type == "audio.input":
+            payload_base64 = (message.get("data") or {}).get("audio")
+            if not payload_base64:
+                return None
+            payload = base64.b64decode(payload_base64)
+            # Input: Maqsam's 8kHz mu-law -> PCM at the pipeline input rate.
+            deserialized_data = await ulaw_to_pcm(
+                payload, self._maqsam_sample_rate, self._sample_rate, self._input_resampler
+            )
+            if deserialized_data is None or len(deserialized_data) == 0:
+                return None
+            return InputAudioRawFrame(
+                audio=deserialized_data, num_channels=1, sample_rate=self._sample_rate
+            )
+        elif message_type == "call.dtmf":
+            digit = (message.get("data") or {}).get("digit")
+            if digit is None:
+                return None
+            try:
+                return InputDTMFFrame(KeypadEntry(str(digit)))
+            except ValueError:
+                logger.warning(f"Invalid Maqsam DTMF digit received: {digit}")
+                return None
+
+        # call.mark echoes and any other control messages are handled outside the serializer.
+        return None