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

{dv_pipecat_ai-0.0.82.dev807 → dv_pipecat_ai-0.0.82.dev816}/.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
         
@@ -169,20 +169,36 @@ jobs:
       run: |
         echo "🔍 Checking if KEDA is already installed..."
         
+        # Ensure KEDA Helm repository exists and is up-to-date for both install and upgrade paths
+        if ! helm repo list | grep -q '^kedacore\s'; then
+          helm repo add kedacore https://kedacore.github.io/charts
+        else
+          # Force update in case URL changed or local cache is stale
+          helm repo add kedacore https://kedacore.github.io/charts --force-update
+        fi
+        helm repo update
+        
         # Install KEDA if needed
         if ! kubectl get deployment -n keda keda-operator >/dev/null 2>&1; then
           echo "🚀 Installing KEDA core..."
           
-          # Add KEDA Helm repository
-          helm repo add kedacore https://kedacore.github.io/charts
-          helm repo update
-          
-          # Install KEDA core (required before HTTP add-on)
-          helm install keda kedacore/keda --namespace keda --create-namespace --wait --timeout=5m
+          # Install KEDA core (required before HTTP add-on) with 30s HTTP timeout
+          helm install keda kedacore/keda --namespace keda --create-namespace --wait --timeout=5m \
+            --set operator.extraEnvs[0].name=KEDA_HTTP_DEFAULT_TIMEOUT \
+            --set operator.extraEnvs[0].value="30000"
             
-          echo "✅ KEDA core installation completed"
+          echo "✅ KEDA core installation completed with 30s HTTP timeout"
         else
           echo "✅ KEDA core already installed"
+          
+          # Update existing KEDA installation to ensure HTTP timeout is set
+          echo "🔄 Updating KEDA configuration to ensure 30s HTTP timeout..."
+          helm upgrade keda kedacore/keda --namespace keda --reuse-values \
+            --set operator.extraEnvs[0].name=KEDA_HTTP_DEFAULT_TIMEOUT \
+            --set operator.extraEnvs[0].value="30000" \
+            --wait --timeout=5m
+          
+          echo "✅ KEDA configuration updated with 30s HTTP timeout"
         fi
         
         # Verify KEDA CRDs are available

{dv_pipecat_ai-0.0.82.dev807 → dv_pipecat_ai-0.0.82.dev816}/.github/workflows/promote-prod.yml

@@ -15,6 +15,7 @@ env:
   HELM_RELEASE_NAME: dv-pipecat
   CLUSTER: desivocal-prod-us-e1-cluster
   CLUSTER_ZONE: us-east1
+  SECRETS_JSON: ${{ secrets.PROD_SECRETS_JSON }}
 
 jobs:
   promote:
@@ -25,6 +26,9 @@ jobs:
     steps:
     - uses: actions/checkout@v4
 
+    - name: Install jq
+      run: sudo apt-get update && sudo apt-get install -y jq
+
     - uses: google-github-actions/auth@v2
       with:
         workload_identity_provider: projects/623676891410/locations/global/workloadIdentityPools/desivocal-staging-pool/providers/github
@@ -51,8 +55,21 @@ jobs:
     # 1  roll stable Deployment to desired image
     - name: Upgrade stable release
       run: |
+        PROD_ADMIN_API_KEY=$(echo "$SECRETS_JSON" | jq -r '.ADMIN_API_KEY // empty')
+        if [ -z "$PROD_ADMIN_API_KEY" ]; then
+          echo "❌ ADMIN_API_KEY not found in SECRETS_JSON"
+          exit 1
+        fi
+        PROD_CALLING_BACKEND_URL=$(echo "$SECRETS_JSON" | jq -r '.CALLING_BACKEND_URL // empty')
+        if [ -z "$PROD_CALLING_BACKEND_URL" ]; then
+          echo "❌ CALLING_BACKEND_URL not found in SECRETS_JSON"
+          exit 1
+        fi
+        echo "🚀 Promoting to stable production..."
         helm upgrade $HELM_RELEASE_NAME ./k8s/dv-pipecat \
           -f ./k8s/dv-pipecat/values-prod.yaml \
           --set image.repository=$REGION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE_NAME \
           --set image.tag=${{ steps.tag.outputs.TAG }} \
+          --set ADMIN_API_KEY="${PROD_ADMIN_API_KEY}" \
+          --set CALLING_BACKEND_URL="${PROD_CALLING_BACKEND_URL}" \
           --namespace default

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.82.dev807
+Version: 0.0.82.dev816
 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.dev816/k8s/dv-pipecat/values-canary.yaml

@@ -0,0 +1,13 @@
+releaseTrack: canary
+replicaCount: 2
+
+env:
+  - name: LOGGER_NAME
+    value: "pipecat-canary"
+
+service:
+  create: false # So that canary will not create new service
+
+# Disable KEDA for canary - we only want production to be scaled
+keda:
+  enabled: false

{dv_pipecat_ai-0.0.82.dev807 → dv_pipecat_ai-0.0.82.dev816}/k8s/dv-pipecat/values-prod.yaml

@@ -76,11 +76,11 @@ keda:
 
   # Production-optimized scaling behavior to prevent fluctuations
   # Longer scale down stabilization to prevent rapid fluctuations
-  scaleDownStabilizationWindow: 900 # 15 minutes for production
+  scaleDownStabilizationWindow: 1800 # 30 minutes for production
   # Conservative scale down - only 25% at a time
   scaleDownPercent: 25
-  # Scale down every 2 minutes
-  scaleDownPeriod: 120
+  # Scale down every 10 minutes
+  scaleDownPeriod: 600
   # Faster scale up for production responsiveness
   scaleUpStabilizationWindow: 30
   # Aggressive scale up - 100% at a time

{dv_pipecat_ai-0.0.82.dev807 → dv_pipecat_ai-0.0.82.dev816}/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.dev816
 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.dev816}/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.dev816/src/pipecat/serializers/asterisk.py

@@ -0,0 +1,130 @@
+# 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()
+        self._hangup_sent = False
+
+    @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.dev816}/src/pipecat/services/tts_service.py

@@ -122,6 +122,9 @@ class TTSService(AIService):
         self._voice = None
         self._voice_clone_params = None
 
+        self._tracing_enabled: bool = False
+
+
         if text_filter:
             import warnings
 

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

@@ -30,13 +30,13 @@ from pipecat.processors.aggregators.openai_llm_context import (
     OpenAILLMContext,
     OpenAILLMContextFrame,
 )
+from pipecat.processors.frame_processor import FrameDirection
+from pipecat.services.llm_service import LLMService
 from pipecat.services.openai.llm import (
     OpenAIAssistantContextAggregator,
     OpenAIContextAggregatorPair,
     OpenAIUserContextAggregator,
 )
-from pipecat.processors.frame_processor import FrameDirection
-from pipecat.services.llm_service import LLMService
 
 
 class VistaarLLMService(LLMService):
@@ -68,6 +68,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 +78,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 +92,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 +162,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 +187,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 +231,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 +295,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 +308,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 +329,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 +348,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 +421,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)

dv_pipecat_ai-0.0.82.dev807/k8s/dv-pipecat/values-canary.yaml

@@ -1,9 +0,0 @@
-releaseTrack: canary
-replicaCount: 2
-
-env:
-  - name: LOGGER_NAME
-    value: "pipecat-canary"
-
-service:
-  create: false # So that canary will not create new service