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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.93.dev92
+Version: 0.0.93.dev97
 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.dev97/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.dev97
 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.dev97}/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.dev97}/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.dev97}/src/dv_pipecat_ai.egg-info/scm_version.json

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

{dv_pipecat_ai-0.0.93.dev92 → dv_pipecat_ai-0.0.93.dev97}/src/pipecat/processors/aggregators/llm_response.py

@@ -872,20 +872,6 @@ class LLMAssistantContextAggregator(LLMContextResponseAggregator):
         self._function_calls_in_progress: Dict[str, Optional[FunctionCallInProgressFrame]] = {}
         self._context_updated_tasks: Set[asyncio.Task] = set()
 
-        # Monotonic id of the current LLM response cycle, bumped on every
-        # LLMFullResponseStartFrame. Used to tell whether spoken text was
-        # produced in the SAME completion that issued a tool call (so it should
-        # be folded into that tool-call message) versus a later continuation
-        # response (which must remain a separate message). See
-        # `handle_function_call_in_progress` / `handle_aggregation` in the
-        # OpenAI subclass.
-        self._response_seq = 0
-        # Response-seq stamped onto the current text aggregation when it starts.
-        self._aggregation_seq: Optional[int] = None
-        # (message, response_seq) of a content-less tool-call message that may
-        # still absorb same-turn spoken text; consumed by `handle_aggregation`.
-        self._pending_tool_call_merge: Optional[tuple] = None
-
     @property
     def has_function_calls_in_progress(self) -> bool:
         """Check if there are any function calls currently in progress.
@@ -1100,7 +1086,6 @@ class LLMAssistantContextAggregator(LLMContextResponseAggregator):
 
     async def _handle_llm_start(self, _: LLMFullResponseStartFrame):
         self._started += 1
-        self._response_seq += 1
 
     async def _handle_llm_end(self, _: LLMFullResponseEndFrame):
         self._started -= 1
@@ -1112,21 +1097,6 @@ class LLMAssistantContextAggregator(LLMContextResponseAggregator):
         if isinstance(frame, TTSTextFrame) and not frame.add_to_llm_context:
             return
 
-        if not self._aggregation:
-            # First text frame of a new aggregation: remember which response
-            # cycle it belongs to, so we can later decide whether it should be
-            # folded into a same-turn tool-call message.
-            self._aggregation_seq = self._response_seq
-        elif self._aggregation_seq != self._response_seq:
-            # A newer response cycle produced text before the previous
-            # aggregation was flushed — e.g. a tool-result continuation (the
-            # FunctionCallResultFrame is a SystemFrame) racing a long TTS
-            # playback that is still holding the response-end / bot-stopped
-            # frames. The buffer now mixes two response cycles, so it must NOT
-            # be folded into the earlier turn's tool-call message; mark it
-            # un-mergeable.
-            self._aggregation_seq = None
-
         if self._params.expect_stripped_words:
             self._aggregation += f" {frame.text}" if self._aggregation else frame.text
         else:

{dv_pipecat_ai-0.0.93.dev92 → dv_pipecat_ai-0.0.93.dev97}/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.dev97/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

{dv_pipecat_ai-0.0.93.dev92 → dv_pipecat_ai-0.0.93.dev97}/src/pipecat/services/openai/llm.py

@@ -126,38 +126,6 @@ class OpenAIAssistantContextAggregator(LLMAssistantContextAggregator):
     tool usage tracking, and image message handling.
     """
 
-    async def handle_aggregation(self, aggregation: str):
-        """Add the aggregated assistant text to the context.
-
-        When the assistant speaks text AND issues a tool call in the same LLM
-        completion, the tool-call message (and its result) are written to the
-        context immediately, while this spoken-text aggregation is only flushed
-        when the bot stops speaking — i.e. after the tool result is already in
-        the context. Appending the text as a trailing message then produces a
-        scrambled order (assistant{tool_calls} -> tool{result} ->
-        assistant{text}) that makes the post-function continuation re-speak the
-        same line.
-
-        To keep OpenAI's canonical ordering (assistant{content, tool_calls} ->
-        tool{result}), fold the text into that content-less tool-call message
-        instead. Only do so when the text was produced in the SAME response
-        cycle that issued the call (``_aggregation_seq`` matches the seq stamped
-        on the pending tool call); text from a later continuation response is a
-        genuine reply to the result and is appended normally.
-        """
-        pending = self._pending_tool_call_merge
-        self._pending_tool_call_merge = None
-        if (
-            pending is not None
-            and pending[1] == self._aggregation_seq
-            and not pending[0].get("content")
-            and pending[0] in self._context.messages
-        ):
-            pending[0]["content"] = aggregation
-            return
-
-        self._context.add_message({"role": "assistant", "content": aggregation})
-
     async def handle_function_call_in_progress(self, frame: FunctionCallInProgressFrame):
         """Handle a function call in progress.
 
@@ -167,20 +135,21 @@ class OpenAIAssistantContextAggregator(LLMAssistantContextAggregator):
         Args:
             frame: Frame containing function call progress information.
         """
-        tool_call_message = {
-            "role": "assistant",
-            "tool_calls": [
-                {
-                    "id": frame.tool_call_id,
-                    "function": {
-                        "name": frame.function_name,
-                        "arguments": json.dumps(frame.arguments),
-                    },
-                    "type": "function",
-                }
-            ],
-        }
-        self._context.add_message(tool_call_message)
+        self._context.add_message(
+            {
+                "role": "assistant",
+                "tool_calls": [
+                    {
+                        "id": frame.tool_call_id,
+                        "function": {
+                            "name": frame.function_name,
+                            "arguments": json.dumps(frame.arguments),
+                        },
+                        "type": "function",
+                    }
+                ],
+            }
+        )
         self._context.add_message(
             {
                 "role": "tool",
@@ -189,17 +158,6 @@ class OpenAIAssistantContextAggregator(LLMAssistantContextAggregator):
             }
         )
 
-        # If the assistant also speaks text in this same response cycle, that
-        # text is committed only once the bot stops speaking — after this
-        # content-less tool-call message. Remember the first such call of the
-        # cycle so `handle_aggregation` can fold the spoken text into it instead
-        # of letting it land after the tool result. (See `handle_aggregation`.)
-        if (
-            self._pending_tool_call_merge is None
-            or self._pending_tool_call_merge[1] != self._response_seq
-        ):
-            self._pending_tool_call_merge = (tool_call_message, self._response_seq)
-
     async def handle_function_call_result(self, frame: FunctionCallResultFrame):
         """Handle the result of a function call.