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

{dv_pipecat_ai-0.0.82.dev776 → 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
         
@@ -251,11 +251,17 @@ jobs:
           echo "❌ ADMIN_API_KEY not found in SECRETS_JSON"
           exit 1
         fi
+        STAGE_CALLING_BACKEND_URL=$(echo "$SECRETS_JSON" | jq -r '.CALLING_BACKEND_URL // empty')
+        if [ -z "$STAGE_CALLING_BACKEND_URL" ]; then
+          echo "❌ CALLING_BACKEND_URL not found in SECRETS_JSON"
+          exit 1
+        fi
         helm upgrade --install $HELM_RELEASE_NAME ./k8s/dv-pipecat \
           -f ./k8s/dv-pipecat/values-stage.yaml \
           --set image.repository=$REGION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE_NAME \
           --set image.tag=$GITHUB_SHA \
           --set ADMIN_API_KEY="${STAGE_ADMIN_API_KEY}" \
+          --set CALLING_BACKEND_URL="${STAGE_CALLING_BACKEND_URL}" \
           --namespace default
 
     # 2) **ONLY** when branch is dv-main: deploy/update the CANARY release
@@ -267,6 +273,11 @@ jobs:
           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 "🚀 Deploying canary service..."
         helm upgrade --install ${HELM_RELEASE_NAME}-canary ./k8s/dv-pipecat \
           -f ./k8s/dv-pipecat/values-prod.yaml \
@@ -274,6 +285,7 @@ jobs:
           --set image.repository=$REGION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE_NAME \
           --set image.tag=$GITHUB_SHA \
           --set ADMIN_API_KEY="${PROD_ADMIN_API_KEY}" \
+          --set CALLING_BACKEND_URL="${PROD_CALLING_BACKEND_URL}" \
           --namespace default
 
     # - name: Deployment validation

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev815}/.github/workflows/smart-auto-release.yml

@@ -53,40 +53,44 @@ jobs:
       run: |
         echo "Getting current versions..."
         
-        # Get latest PyPI version using helper script
-        PYPI_VERSION=$(python scripts/get-pypi-version.py ${{ env.PACKAGE_NAME }})
-        echo "PYPI_VERSION=$PYPI_VERSION" >> $GITHUB_OUTPUT
-        
-        # Get remote-requirements.txt version
+        # Get merged branch (dv-stage) requirements version
         if [ -f "${{ env.REQUIREMENTS_FILE }}" ]; then
-          REQUIREMENTS_VERSION=$(grep "${{ env.PACKAGE_NAME }}" ${{ env.REQUIREMENTS_FILE }} | sed -n 's/.*==\([^]]*\).*/\1/p')
-          echo "REQUIREMENTS_VERSION=$REQUIREMENTS_VERSION" >> $GITHUB_OUTPUT
+          MERGED_REQUIREMENTS_VERSION=$(grep "${{ env.PACKAGE_NAME }}" ${{ env.REQUIREMENTS_FILE }} | sed -n 's/.*==\([^]]*\).*/\1/p')
+          echo "MERGED_REQUIREMENTS_VERSION=$MERGED_REQUIREMENTS_VERSION" >> $GITHUB_OUTPUT
         else
-          echo "REQUIREMENTS_VERSION=0.0.0.dev0" >> $GITHUB_OUTPUT
+          echo "MERGED_REQUIREMENTS_VERSION=0.0.0.dev0" >> $GITHUB_OUTPUT
+        fi
+        
+        # Get base branch requirements version
+        git show ${{ github.event.pull_request.base.sha }}:${{ env.REQUIREMENTS_FILE }} > base_requirements.txt 2>/dev/null || echo "dv-pipecat-ai==0.0.0.dev0" > base_requirements.txt
+        BASE_REQUIREMENTS_VERSION=$(grep "${{ env.PACKAGE_NAME }}" base_requirements.txt | sed -n 's/.*==\([^]]*\).*/\1/p')
+        if [ -z "$BASE_REQUIREMENTS_VERSION" ]; then
+          BASE_REQUIREMENTS_VERSION="0.0.0.dev0"
         fi
+        echo "BASE_REQUIREMENTS_VERSION=$BASE_REQUIREMENTS_VERSION" >> $GITHUB_OUTPUT
         
         echo "📊 Version Status:"
-        echo "   PyPI version: $PYPI_VERSION"
-        echo "   Requirements version: $REQUIREMENTS_VERSION"
+        echo "   Base branch requirements version: $BASE_REQUIREMENTS_VERSION"
+        echo "   Merged branch requirements version: $MERGED_REQUIREMENTS_VERSION"
 
     - name: Decide release action
       if: steps.check-changes.outputs.HAS_PIPECAT_CHANGES == 'true'
       id: decision
       run: |
-        PYPI_VERSION="${{ steps.versions.outputs.PYPI_VERSION }}"
-        REQUIREMENTS_VERSION="${{ steps.versions.outputs.REQUIREMENTS_VERSION }}"
+        BASE_VERSION="${{ steps.versions.outputs.BASE_REQUIREMENTS_VERSION }}"
+        MERGED_VERSION="${{ steps.versions.outputs.MERGED_REQUIREMENTS_VERSION }}"
         
         echo "🤔 Decision Logic:"
-        echo "   PyPI version: $PYPI_VERSION"
-        echo "   Requirements version: $REQUIREMENTS_VERSION"
+        echo "   Base branch version: $BASE_VERSION"
+        echo "   Merged branch version: $MERGED_VERSION"
         
-        if [ "$PYPI_VERSION" = "$REQUIREMENTS_VERSION" ]; then
+        if [ "$BASE_VERSION" = "$MERGED_VERSION" ]; then
           echo "SHOULD_RELEASE=true" >> $GITHUB_OUTPUT
-          echo "REASON=Versions match - auto-bumping needed" >> $GITHUB_OUTPUT
-          echo "✅ Decision: AUTO-RELEASE (versions match)"
+          echo "REASON=Versions match between branches - auto-bumping needed" >> $GITHUB_OUTPUT
+          echo "✅ Decision: AUTO-RELEASE (versions match between branches)"
         else
           echo "SHOULD_RELEASE=false" >> $GITHUB_OUTPUT
-          echo "REASON=Developer already updated version" >> $GITHUB_OUTPUT
+          echo "REASON=Developer already updated version in this PR" >> $GITHUB_OUTPUT
           echo "⏭️  Decision: SKIP (developer handled versioning)"
         fi
 
@@ -98,7 +102,7 @@ jobs:
           SKIP_REASON="No src/pipecat changes in this PR"
         else
           echo "⏭️  SKIPPING: ${{ steps.decision.outputs.REASON }}"
-          SKIP_REASON="Developer already updated version"
+          SKIP_REASON="Developer already updated version in this PR"
         fi
         echo "Skip reason: $SKIP_REASON"
 

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev815}/.gitignore

@@ -6,7 +6,7 @@ venv
 .venv
 /.idea
 #*#
-data/
+# data/
 # Distribution / packaging
 .Python
 build/

{dv_pipecat_ai-0.0.82.dev776 → 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.dev776
+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.dev776 → dv_pipecat_ai-0.0.82.dev815}/k8s/dv-pipecat/templates/keda-scaledobject.yaml

@@ -44,11 +44,12 @@ spec:
       name: {{ include "dv-pipecat.fullname" . }}-http-auth
     metadata:
       # The URL of your API
-      url: "https://67397cb486a3.ngrok-free.app/ca/api/v0/admin/global/predicted-concurrency"
+      # url: "https://67397cb486a3.ngrok-free.app/ca/api/v0/admin/global/predicted-pods"
+      url: {{ .Values.CALLING_BACKEND_URL }}/admin/global/predicted-pods
       # The JMESPath to find the number in the JSON response  
-      valueLocation: {{ .Values.keda.jsonPath | default "concurrency" | quote }}
+      valueLocation: {{ .Values.keda.jsonPath | default "predicted_pods" | quote }}
       # This is the divisor. KEDA calculates: desired_pods = (api_value / targetValue)
-      targetValue: {{ .Values.keda.targetValue | default "5" | quote }}
+      targetValue: {{ .Values.keda.targetValue | default "1" | quote }}
       # Authentication configuration
       authMode: "apiKey"
       method: "header"

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev815}/k8s/dv-pipecat/values-prod.yaml

@@ -66,9 +66,9 @@ terminationGracePeriodSeconds: 270 # 4.5 minutes
 
 # KEDA Configuration for production
 keda:
-  enabled: false
-  jsonPath: "concurrency"
-  targetValue: "5"
+  enabled: true
+  jsonPath: "predicted_pods"
+  targetValue: "1"
   minReplicaCount: 4
   maxReplicaCount: 200
   pollingInterval: 60

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev815}/k8s/dv-pipecat/values-stage.yaml

@@ -61,10 +61,10 @@ terminationGracePeriodSeconds: 270 # 4.5 minutes
 # KEDA Configuration for staging
 keda:
   enabled: true
-  jsonPath: "concurrency"
-  targetValue: "5"
+  jsonPath: "predicted_pods"
+  targetValue: "1"
   minReplicaCount: 1
-  maxReplicaCount: 30
+  maxReplicaCount: 2
   pollingInterval: 30
   cooldownPeriod: 30
   # Staging-optimized scaling behavior to prevent fluctuations

{dv_pipecat_ai-0.0.82.dev776 → dv_pipecat_ai-0.0.82.dev815}/k8s/dv-pipecat/values.yaml

@@ -129,9 +129,9 @@ envFrom:
 keda:
   enabled: false
   # JSON path to extract the scheduled calls value
-  jsonPath: "concurrency"
+  jsonPath: "predicted_pods"
   # Target value for scaling (calls per pod)
-  targetValue: "5"
+  targetValue: "1"
   # HTTP method for API calls
   httpMethod: "GET"
   # Custom HTTP headers (optional)

{dv_pipecat_ai-0.0.82.dev776 → 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.dev776
+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.dev776 → 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
@@ -358,6 +359,8 @@ src/pipecat/services/together/__init__.py
 src/pipecat/services/together/llm.py
 src/pipecat/services/ultravox/__init__.py
 src/pipecat/services/ultravox/stt.py
+src/pipecat/services/vistaar/__init__.py
+src/pipecat/services/vistaar/llm.py
 src/pipecat/services/whisper/__init__.py
 src/pipecat/services/whisper/base_stt.py
 src/pipecat/services/whisper/stt.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.dev815/src/pipecat/services/vistaar/__init__.py

@@ -0,0 +1,5 @@
+"""Vistaar AI service implementations."""
+
+from .llm import VistaarLLMService
+
+__all__ = ["VistaarLLMService"]