dv-pipecat-ai 0.0.82.dev807__tar.gz → 0.0.82.dev815__tar.gz

{dv_pipecat_ai-0.0.82.dev807 → dv_pipecat_ai-0.0.82.dev815}/.github/workflows/github.yml

@@ -88,7 +88,7 @@ jobs:
         echo "📦 Required pipecat version: $PIPECAT_VERSION"
         
         # Verify package is available on PyPI with retry logic
-        MAX_ATTEMPTS=30
+        MAX_ATTEMPTS=2
         ATTEMPT=1
         PACKAGE_AVAILABLE=false
         

{dv_pipecat_ai-0.0.82.dev807 → dv_pipecat_ai-0.0.82.dev815}/PKG-INFO

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

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

@@ -202,6 +202,7 @@ src/pipecat/runner/run.py
 src/pipecat/runner/types.py
 src/pipecat/runner/utils.py
 src/pipecat/serializers/__init__.py
+src/pipecat/serializers/asterisk.py
 src/pipecat/serializers/base_serializer.py
 src/pipecat/serializers/convox.py
 src/pipecat/serializers/exotel.py

dv_pipecat_ai-0.0.82.dev815/src/pipecat/serializers/asterisk.py

@@ -0,0 +1,129 @@
+# asterisk_ws_serializer.py
+import base64
+import json
+from typing import Literal, Optional
+
+from pydantic import BaseModel
+
+from pipecat.audio.utils import create_stream_resampler, pcm_to_ulaw, ulaw_to_pcm
+from pipecat.frames.frames import (
+    AudioRawFrame,
+    CancelFrame,
+    EndFrame,
+    Frame,
+    InputAudioRawFrame,
+    StartFrame,
+    StartInterruptionFrame,
+    TransportMessageFrame,
+    TransportMessageUrgentFrame,
+)
+from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
+
+
+class AsteriskFrameSerializer(FrameSerializer):
+    class InputParams(BaseModel):
+        """Configuration parameters for AsteriskFrameSerializer.
+
+        Parameters:
+            telephony_encoding: The encoding used by the telephony system (e.g., "pcmu" for μ-law).
+            telephony_sample_rate: The sample rate used by the telephony system (e.g., 8000 Hz).
+            sample_rate: Optional override for pipeline input sample rate.
+            auto_hang_up: Whether to automatically terminate call on EndFrame.
+        """
+
+        # What the ADAPTER/Asterisk is sending/expecting on the wire:
+        # "pcmu" -> μ-law @ 8k; "pcm16" -> signed 16-bit @ 8k
+        telephony_encoding: Literal["pcmu", "pcm16"] = "pcmu"
+        telephony_sample_rate: int = 8000
+        sample_rate: Optional[int] = None  # pipeline input rate
+        auto_hang_up: bool = False  # no-op here; adapter handles hangup
+
+    def __init__(self, stream_id: str, params: Optional[InputParams] = None):
+        self._stream_id = stream_id
+        self._params = params or AsteriskFrameSerializer.InputParams()
+        self._tel_rate = self._params.telephony_sample_rate
+        self._sample_rate = 0
+        self._in_resampler = create_stream_resampler()
+        self._out_resampler = create_stream_resampler()
+
+    @property
+    def type(self) -> FrameSerializerType:
+        return FrameSerializerType.TEXT  # we send/recv JSON strings
+
+    async def setup(self, frame: 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:
+        # On pipeline end, ask bridge to hang up
+        if (
+            self._params.auto_hang_up
+            and not self._hangup_sent
+            and isinstance(frame, (EndFrame, CancelFrame))
+        ):
+            self._hangup_sent = True
+            return json.dumps({"event": "hangup"})
+        if isinstance(frame, StartInterruptionFrame):
+            return json.dumps({"event": "clear", "streamId": self._stream_id})
+        if isinstance(frame, AudioRawFrame):
+            pcm = frame.audio
+            if self._params.telephony_encoding == "pcmu":
+                ul = await pcm_to_ulaw(pcm, frame.sample_rate, self._tel_rate, self._out_resampler)
+                if not ul:
+                    return None
+                payload = base64.b64encode(ul).decode("utf-8")
+                return json.dumps(
+                    {
+                        "event": "media",
+                        "encoding": "pcmu",
+                        "sampleRate": self._tel_rate,
+                        "payload": payload,
+                    }
+                )
+            else:  # "pcm16"
+                # resample to 8k if needed, but data stays PCM16 bytes
+                pcm8 = await self._out_resampler.resample(pcm, frame.sample_rate, self._tel_rate)
+                if not pcm8:
+                    return None
+                payload = base64.b64encode(pcm8).decode("utf-8")
+                return json.dumps(
+                    {
+                        "event": "media",
+                        "encoding": "pcm16",
+                        "sampleRate": self._tel_rate,
+                        "payload": payload,
+                    }
+                )
+        if isinstance(frame, (TransportMessageFrame, TransportMessageUrgentFrame)):
+            return json.dumps(frame.message)
+        return None
+
+    # Adapter -> Pipecat (audio from caller)
+    async def deserialize(self, data: str | bytes) -> Frame | None:
+        try:
+            msg = json.loads(data)
+        except Exception:
+            return None
+        if msg.get("event") == "media":
+            enc = msg.get("encoding")
+            sr = int(msg.get("sampleRate", self._tel_rate))
+            raw = base64.b64decode(msg.get("payload", ""))
+            if not raw:
+                return None
+            if enc == "pcmu":
+                pcm = await ulaw_to_pcm(raw, sr, self._sample_rate, self._in_resampler)
+            elif enc == "pcm16":
+                # resample if pipeline rate != 8k
+                pcm = await self._in_resampler.resample(raw, sr, self._sample_rate)
+            else:
+                return None
+            if not pcm:
+                return None
+            return InputAudioRawFrame(audio=pcm, num_channels=1, sample_rate=self._sample_rate)
+        elif msg.get("event") == "dtmf":
+            # optional: map to InputDTMFFrame if you want
+            return None
+        elif msg.get("event") == "hangup":
+            # Bridge is hanging up; you can treat as EndFrame if you want.
+            return CancelFrame()
+        return None

{dv_pipecat_ai-0.0.82.dev807 → dv_pipecat_ai-0.0.82.dev815}/src/pipecat/services/vistaar/llm.py

@@ -13,6 +13,8 @@ from loguru import logger
 from pydantic import BaseModel, Field
 
 from pipecat.frames.frames import (
+    CancelFrame,
+    EndFrame,
     Frame,
     LLMFullResponseEndFrame,
     LLMFullResponseStartFrame,
@@ -68,6 +70,8 @@ class VistaarLLMService(LLMService):
         base_url: str = "https://vistaar.kenpath.ai/api",
         params: Optional[InputParams] = None,
         timeout: float = 30.0,
+        interim_timeout: float = 5.0,
+        interim_message: str = "एक क्षण थांबा, मी बघतो. ",
         **kwargs,
     ):
         """Initialize Vistaar LLM service.
@@ -76,6 +80,8 @@ class VistaarLLMService(LLMService):
             base_url: The base URL for Vistaar API. Defaults to "https://vistaar.kenpath.ai/api".
             params: Input parameters for model configuration and behavior.
             timeout: Request timeout in seconds. Defaults to 30.0 seconds.
+            interim_timeout: Time in seconds before sending interim message. Defaults to 3.0 seconds.
+            interim_message: Message to send if API takes longer than interim_timeout. Defaults to "एक क्षण थांबा, मी बघतो. ".
             **kwargs: Additional arguments passed to the parent LLMService.
         """
         super().__init__(**kwargs)
@@ -88,14 +94,18 @@ class VistaarLLMService(LLMService):
         self._session_id = params.session_id or str(uuid.uuid4())
         self._extra = params.extra if isinstance(params.extra, dict) else {}
         self._timeout = timeout
+        self._interim_timeout = interim_timeout
+        self._interim_message = interim_message
 
         # Create an async HTTP client
-        self._client = httpx.AsyncClient(timeout=httpx.Timeout(self._timeout))
+        self._client = httpx.AsyncClient(timeout=httpx.Timeout(self._timeout), verify=False)
 
         # Interruption handling state
         self._current_response = None  # Track current HTTP response stream
         self._is_interrupted = False  # Track if current generation was interrupted
         self._partial_response = []  # Track what was actually sent before interruption
+        self._interim_sent = False  # Track if interim message was sent
+        self._interim_task = None  # Track interim message task
 
         logger.info(
             f"Vistaar LLM initialized - Base URL: {self._base_url}, Session ID: {self._session_id}, Source Lang: {self._source_lang}, Target Lang: {self._target_lang}, Timeout: {self._timeout}s"
@@ -154,6 +164,11 @@ class VistaarLLMService(LLMService):
         # Set interruption flag
         self._is_interrupted = True
 
+        # Cancel interim message task if active
+        await self._cancel_interim_message_task(
+            "Cancelled interim message task - handling interruption"
+        )
+
         # Cancel ongoing HTTP response stream if active
         if self._current_response:
             try:
@@ -174,6 +189,19 @@ class VistaarLLMService(LLMService):
         # Clear current partial response
         self._partial_response = []
 
+    async def _send_interim_message(self):
+        """Send interim message after timeout."""
+        try:
+            await asyncio.sleep(self._interim_timeout)
+            if not self._is_interrupted and not self._interim_sent:
+                logger.info(f"Sending interim message after {self._interim_timeout}s timeout")
+                self._interim_sent = True
+                await self.push_frame(LLMTextFrame(text=self._interim_message))
+        except asyncio.CancelledError:
+            logger.debug("Interim message task cancelled")
+        except Exception as e:
+            logger.error(f"Error sending interim message: {e}")
+
     async def _stream_response(self, query: str) -> AsyncGenerator[str, None]:
         """Stream response from Vistaar API using Server-Sent Events.
 
@@ -205,6 +233,7 @@ class VistaarLLMService(LLMService):
         # Reset interruption state and partial response for new request
         self._is_interrupted = False
         self._partial_response = []
+        self._interim_sent = False
 
         try:
             # Use httpx to handle SSE streaming
@@ -268,6 +297,11 @@ class VistaarLLMService(LLMService):
             await self.start_processing_metrics()
             await self.start_ttfb_metrics()
 
+            # Start interim message task
+            self._interim_task = self.create_task(
+                self._send_interim_message(), "Vistaar LLM - _send_interim_message"
+            )
+
             first_chunk = True
             full_response = []
 
@@ -276,6 +310,10 @@ class VistaarLLMService(LLMService):
                 if first_chunk:
                     await self.stop_ttfb_metrics()
                     first_chunk = False
+                    # Cancel interim message task since we got first response
+                    await self._cancel_interim_message_task(
+                        "Cancelled interim message task - got first response"
+                    )
 
                 # Push each text chunk as it arrives
                 await self.push_frame(LLMTextFrame(text=text_chunk))
@@ -293,6 +331,10 @@ class VistaarLLMService(LLMService):
             logger.error(f"Vistaar traceback: {traceback.format_exc()}")
             raise
         finally:
+            # Clean up interim message task
+            await self._cancel_interim_message_task(
+                "Cancelled interim message task in finally block"
+            )
             await self.stop_processing_metrics()
             await self.push_frame(LLMFullResponseEndFrame())
 
@@ -308,7 +350,13 @@ class VistaarLLMService(LLMService):
         """
         await super().process_frame(frame, direction)
         context = None
-        if isinstance(frame, StartInterruptionFrame):
+        if isinstance(frame, (EndFrame, CancelFrame)):
+            await self._cancel_interim_message_task(
+                f"Cancelled interim message task - received {type(frame).__name__}"
+            )
+            await self.push_frame(frame, direction)
+            return
+        elif isinstance(frame, StartInterruptionFrame):
             await self._handle_interruption()
             await self.push_frame(frame, direction)
             return
@@ -375,3 +423,9 @@ class VistaarLLMService(LLMService):
             asyncio.create_task(self._client.aclose())
         except:
             pass
+
+    async def _cancel_interim_message_task(self, message: str = "Cancelled interim message task"):
+        if self._interim_task and not self._interim_task.done():
+            await self.cancel_task(self._interim_task)
+            self._interim_task = None
+            logger.debug(message)