dv-pipecat-ai 0.0.74.dev623__tar.gz → 0.0.74.dev640__tar.gz

{dv_pipecat_ai-0.0.74.dev623 → dv_pipecat_ai-0.0.74.dev640}/.github/workflows/github.yml

@@ -31,57 +31,88 @@ jobs:
       id-token: write # Required for Workload Identity Federation
 
     steps:
+    - name: Wait for auto-release to complete
+      if: github.event_name == 'push'
+      run: |
+        echo "⏳ Waiting for auto-release workflow to complete..."
+        
+        # Wait up to 10 minutes for the auto-release workflow
+        MAX_WAIT_TIME=600  # 10 minutes in seconds
+        WAIT_INTERVAL=30   # Check every 30 seconds
+        ELAPSED_TIME=0
+        
+        while [ $ELAPSED_TIME -lt $MAX_WAIT_TIME ]; do
+          # Check if any workflow runs are still in progress for this commit
+          RUNNING_WORKFLOWS=$(gh api /repos/${{ github.repository }}/actions/runs \
+            --jq '.workflow_runs[] | select(.head_sha == "${{ github.sha }}" and .name == "Smart Auto-Release on PR Merge" and .status == "in_progress") | .id' | wc -l)
+          
+          if [ "$RUNNING_WORKFLOWS" -eq 0 ]; then
+            echo "✅ Auto-release workflow completed for commit ${{ github.sha }}"
+            break
+          fi
+          
+          echo "🔄 Auto-release still running, waiting ${WAIT_INTERVAL}s... (${ELAPSED_TIME}s elapsed)"
+          sleep $WAIT_INTERVAL
+          ELAPSED_TIME=$((ELAPSED_TIME + WAIT_INTERVAL))
+        done
+        
+        if [ $ELAPSED_TIME -ge $MAX_WAIT_TIME ]; then
+          echo "⚠️  Timeout waiting for auto-release workflow, proceeding anyway..."
+        fi
+      env:
+        GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
     - name: Checkout code
       uses: actions/checkout@v4
 
-    # - name: Set up Python
-    #   uses: actions/setup-python@v4
-    #   with:
-    #     python-version: '3.10'
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
 
-    # - name: Install Python dependencies
-    #   run: |
-    #     python -m pip install --upgrade pip
-    #     pip install requests packaging
+    - name: Install Python dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install requests packaging
 
-    # - name: Verify PyPI package availability
-    #   run: |
-    #     echo "🔍 Verifying PyPI package availability..."
+    - name: Verify PyPI package availability
+      run: |
+        echo "🔍 Verifying PyPI package availability..."
         
-    #     # Get version from remote-requirements.txt
-    #     PIPECAT_VERSION=$(grep "dv-pipecat-ai" examples/ringg-chatbot/remote-requirements.txt | sed -n 's/.*==\([^]]*\).*/\1/p')
-    #     echo "📦 Required pipecat version: $PIPECAT_VERSION"
+        # Get version from remote-requirements.txt
+        PIPECAT_VERSION=$(grep "dv-pipecat-ai" examples/ringg-chatbot/remote-requirements.txt | sed -n 's/.*==\([^]]*\).*/\1/p')
+        echo "📦 Required pipecat version: $PIPECAT_VERSION"
         
-    #     # Verify package is available on PyPI with retry logic
-    #     MAX_ATTEMPTS=30
-    #     ATTEMPT=1
-    #     PACKAGE_AVAILABLE=false
+        # Verify package is available on PyPI with retry logic
+        MAX_ATTEMPTS=30
+        ATTEMPT=1
+        PACKAGE_AVAILABLE=false
         
-    #     while [ $ATTEMPT -le $MAX_ATTEMPTS ]; do
-    #       echo "🔍 Attempt $ATTEMPT/$MAX_ATTEMPTS: Checking PyPI for dv-pipecat-ai==$PIPECAT_VERSION"
+        while [ $ATTEMPT -le $MAX_ATTEMPTS ]; do
+          echo "🔍 Attempt $ATTEMPT/$MAX_ATTEMPTS: Checking PyPI for dv-pipecat-ai==$PIPECAT_VERSION"
           
-    #       if python scripts/check-pypi-package.py dv-pipecat-ai "$PIPECAT_VERSION"; then
-    #         PACKAGE_AVAILABLE=true
-    #         echo "✅ PyPI package verification successful!"
-    #         break
-    #       else
-    #         if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
-    #           echo "❌ FAILED: Package dv-pipecat-ai==$PIPECAT_VERSION not available on PyPI after $MAX_ATTEMPTS attempts"
-    #           echo "🚨 This usually means:"
-    #           echo "   1. The auto-release workflow failed to publish"
-    #           echo "   2. PyPI is experiencing delays"
-    #           echo "   3. Version mismatch between requirements.txt and PyPI"
-    #           exit 1
-    #         else
-    #           WAIT_TIME=$((ATTEMPT * 10))
-    #           echo "⏳ Package not yet available, waiting ${WAIT_TIME}s before retry..."
-    #           sleep $WAIT_TIME
-    #         fi
-    #       fi
-    #       ATTEMPT=$((ATTEMPT + 1))
-    #     done
+          if python scripts/check-pypi-package.py dv-pipecat-ai "$PIPECAT_VERSION"; then
+            PACKAGE_AVAILABLE=true
+            echo "✅ PyPI package verification successful!"
+            break
+          else
+            if [ $ATTEMPT -eq $MAX_ATTEMPTS ]; then
+              echo "❌ FAILED: Package dv-pipecat-ai==$PIPECAT_VERSION not available on PyPI after $MAX_ATTEMPTS attempts"
+              echo "🚨 This usually means:"
+              echo "   1. The auto-release workflow failed to publish"
+              echo "   2. PyPI is experiencing delays"
+              echo "   3. Version mismatch between requirements.txt and PyPI"
+              exit 1
+            else
+              WAIT_TIME=$((ATTEMPT * 10))
+              echo "⏳ Package not yet available, waiting ${WAIT_TIME}s before retry..."
+              sleep $WAIT_TIME
+            fi
+          fi
+          ATTEMPT=$((ATTEMPT + 1))
+        done
         
-    #     echo "PIPECAT_VERSION=$PIPECAT_VERSION" >> $GITHUB_ENV
+        echo "PIPECAT_VERSION=$PIPECAT_VERSION" >> $GITHUB_ENV
 
     - name: Authenticate to GCP using Workload Identity Federation
       id: auth

{dv_pipecat_ai-0.0.74.dev623 → dv_pipecat_ai-0.0.74.dev640}/.github/workflows/smart-auto-release.yml

@@ -101,27 +101,38 @@ jobs:
         fi
         echo "Skip reason: $SKIP_REASON"
 
-    - name: Calculate new version
+    - name: Build package  
       if: steps.decision.outputs.SHOULD_RELEASE == 'true'
-      id: new-version
       run: |
-        CURRENT_VERSION="${{ steps.versions.outputs.PYPI_VERSION }}"
-        echo "📈 Calculating new version from: $CURRENT_VERSION"
-        
-        # Use helper script to increment version
-        NEW_VERSION=$(python scripts/increment-version.py "$CURRENT_VERSION")
-        
-        echo "NEW_VERSION=$NEW_VERSION" >> $GITHUB_OUTPUT
-        echo "🚀 New version will be: $NEW_VERSION"
-
-    - name: Build package
-      if: steps.decision.outputs.SHOULD_RELEASE == 'true'
-      run: |
-        echo "🔨 Building package..."
+        echo "🔨 Building package with setuptools_scm auto-versioning..."
         python -m build
         echo "✅ Package built successfully"
         ls -la dist/
 
+    - name: Extract actual built version
+      if: steps.decision.outputs.SHOULD_RELEASE == 'true'
+      id: extract-version
+      run: |
+        echo "📦 Extracting version from built package..."
+        
+        # Get the wheel filename and extract version
+        WHEEL_FILE=$(ls dist/*.whl | head -1)
+        BUILT_VERSION=$(echo "$WHEEL_FILE" | sed -E 's/.*-([0-9]+\.[0-9]+\.[0-9]+\.dev[0-9]+)-.*/\1/')
+        
+        echo "BUILT_VERSION=$BUILT_VERSION" >> $GITHUB_OUTPUT
+        echo "🔍 Actual built version: $BUILT_VERSION"
+        
+        # Verify this matches the tar.gz file too
+        TAR_FILE=$(ls dist/*.tar.gz | head -1)
+        TAR_VERSION=$(echo "$TAR_FILE" | sed -E 's/.*-([0-9]+\.[0-9]+\.[0-9]+\.dev[0-9]+)\.tar\.gz/\1/')
+        
+        if [ "$BUILT_VERSION" = "$TAR_VERSION" ]; then
+          echo "✅ Version consistency check passed: $BUILT_VERSION"
+        else
+          echo "❌ Version mismatch between wheel ($BUILT_VERSION) and tar ($TAR_VERSION)"
+          exit 1
+        fi
+
     - name: Publish to PyPI
       if: steps.decision.outputs.SHOULD_RELEASE == 'true'
       uses: pypa/gh-action-pypi-publish@release/v1
@@ -133,11 +144,11 @@ jobs:
     - name: Update remote-requirements.txt
       if: steps.decision.outputs.SHOULD_RELEASE == 'true'
       run: |
-        NEW_VERSION="${{ steps.new-version.outputs.NEW_VERSION }}"
-        echo "📝 Updating ${{ env.REQUIREMENTS_FILE }} with version $NEW_VERSION"
+        BUILT_VERSION="${{ steps.extract-version.outputs.BUILT_VERSION }}"
+        echo "📝 Updating ${{ env.REQUIREMENTS_FILE }} with actual built version $BUILT_VERSION"
         
         # Update the version in remote-requirements.txt
-        sed -i.bak "s/${{ env.PACKAGE_NAME }}\[.*\]==.*/${{ env.PACKAGE_NAME }}[daily,cartesia,openai,silero,deepgram,azure,elevenlabs,google,groq,sentry,soundfile]==$NEW_VERSION/" ${{ env.REQUIREMENTS_FILE }}
+        sed -i.bak "s/${{ env.PACKAGE_NAME }}\[.*\]==.*/${{ env.PACKAGE_NAME }}[daily,cartesia,openai,silero,deepgram,azure,elevenlabs,google,groq,sentry,soundfile]==$BUILT_VERSION/" ${{ env.REQUIREMENTS_FILE }}
         
         # Show the change
         echo "📋 Updated requirements file:"
@@ -149,7 +160,7 @@ jobs:
         
         # Commit the change
         git add ${{ env.REQUIREMENTS_FILE }}
-        git commit -m "🤖 Auto-bump pipecat version to $NEW_VERSION"
+        git commit -m "🤖 Auto-bump pipecat version to $BUILT_VERSION"
         
         # Push to dv-stage
         git push origin HEAD:dv-stage
@@ -157,10 +168,10 @@ jobs:
     - name: Success notification
       if: steps.decision.outputs.SHOULD_RELEASE == 'true'
       run: |
-        NEW_VERSION="${{ steps.new-version.outputs.NEW_VERSION }}"
+        BUILT_VERSION="${{ steps.extract-version.outputs.BUILT_VERSION }}"
         echo "🎉 SUCCESS: Auto-release completed!"
-        echo "   📦 Published: ${{ env.PACKAGE_NAME }} v$NEW_VERSION"
-        echo "   🔗 PyPI: https://pypi.org/project/${{ env.PACKAGE_NAME }}/$NEW_VERSION/"
+        echo "   📦 Published: ${{ env.PACKAGE_NAME }} v$BUILT_VERSION"
+        echo "   🔗 PyPI: https://pypi.org/project/${{ env.PACKAGE_NAME }}/$BUILT_VERSION/"
         echo "   📝 Updated: ${{ env.REQUIREMENTS_FILE }}"
         echo "   🚀 Deployment will proceed automatically"
 

{dv_pipecat_ai-0.0.74.dev623 → dv_pipecat_ai-0.0.74.dev640}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.74.dev623
+Version: 0.0.74.dev640
 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.74.dev623 → dv_pipecat_ai-0.0.74.dev640}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.74.dev623
+Version: 0.0.74.dev640
 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.74.dev623 → dv_pipecat_ai-0.0.74.dev640}/src/pipecat/serializers/convox.py

@@ -181,7 +181,12 @@ class ConVoxFrameSerializer(FrameSerializer):
             logger.error(f"Invalid JSON received from ConVox: {data}")
             return None
 
+        # Log all incoming events for debugging and monitoring
         event = message.get("event")
+        # logger.info(
+        #     f"📥 CONVOX INCOMING EVENT: {event} - stream_id: {self._stream_id}, call_id: {self._call_id}"
+        # )
+        # logger.info(f"📥 CONVOX FULL MESSAGE: {json.dumps(message, indent=2)}")
 
         if event == "media":
             # Handle incoming audio data
@@ -238,6 +243,10 @@ class ConVoxFrameSerializer(FrameSerializer):
             logger.info(f"ConVox stream started: {message}")
             return None
 
+        elif event == "bridge_connected":
+            logger.info(f"ConVox bridge connected: {message}")
+            return None
+
         elif event == "stop":
             # Handle stream stop event
             logger.info(f"ConVox stream stopped: {message}")
@@ -249,7 +258,7 @@ class ConVoxFrameSerializer(FrameSerializer):
             logger.error(f"ConVox error: {error_msg}")
             return None
 
-        elif event == "end_call" or event == "call_end":
+        elif event == "callEnd" or event == "call_end":
             logger.info("ConVox call end event received")
             self._call_ended = True
             return CancelFrame()
@@ -258,5 +267,9 @@ class ConVoxFrameSerializer(FrameSerializer):
             logger.info(f"ConVox failed event received: {message}")
             self._call_ended = True
             return CancelFrame()
+        # else:
+        #     logger.warning(
+        #         f"📥 CONVOX UNHANDLED EVENT: {event} - Full message: {json.dumps(message, indent=2)}"
+        #     )
 
         return None

{dv_pipecat_ai-0.0.74.dev623 → dv_pipecat_ai-0.0.74.dev640}/src/pipecat/services/deepgram/stt.py

@@ -6,6 +6,7 @@
 
 """Deepgram speech-to-text service implementation."""
 
+import asyncio
 import logging
 from typing import AsyncGenerator, Dict, Optional
 
@@ -113,15 +114,20 @@ class DeepgramSTTService(STTService):
         self._settings = merged_options
         self._addons = addons
 
+        # Connection retry settings
+        self._max_connect_retries = 3
+        self._connect_retry_delay_s = 0.1
+
         self._client = DeepgramClient(
             api_key,
             config=DeepgramClientOptions(
                 url=base_url,
                 options={
                     "keepalive": "true",
+                    "open_timeout": 3,  # Max wait for only 3 seconds for the connection to establish #
                     # "termination_exception_connect": True,  # Enable exception propagation
                 },
-                verbose=logging.ERROR,  # Enable warning level and above logging
+                verbose=logging.ERROR,  # Enable error level and above logging
             ),
         )
 
@@ -210,27 +216,55 @@ class DeepgramSTTService(STTService):
         yield None
 
     async def _connect(self):
-        self.logger.debug("Connecting to Deepgram")
+        self.logger.debug("Attempting to connect to Deepgram...")
 
-        self._connection: AsyncListenWebSocketClient = self._client.listen.asyncwebsocket.v("1")
+        for attempt in range(self._max_connect_retries):
+            try:
+                # Create a new connection object for a clean attempt
+                self._connection: AsyncListenWebSocketClient = self._client.listen.asyncwebsocket.v(
+                    "1"
+                )
 
-        self._connection.on(
-            LiveTranscriptionEvents(LiveTranscriptionEvents.Transcript), self._on_message
-        )
-        self._connection.on(LiveTranscriptionEvents(LiveTranscriptionEvents.Error), self._on_error)
+                # Register event handlers
+                self._connection.on(
+                    LiveTranscriptionEvents(LiveTranscriptionEvents.Transcript), self._on_message
+                )
+                self._connection.on(
+                    LiveTranscriptionEvents(LiveTranscriptionEvents.Error), self._on_error
+                )
 
-        if self.vad_enabled:
-            self._connection.on(
-                LiveTranscriptionEvents(LiveTranscriptionEvents.SpeechStarted),
-                self._on_speech_started,
-            )
-            self._connection.on(
-                LiveTranscriptionEvents(LiveTranscriptionEvents.UtteranceEnd),
-                self._on_utterance_end,
-            )
-
-        if not await self._connection.start(options=self._settings, addons=self._addons):
-            self.logger.error(f"{self}: unable to connect to Deepgram")
+                if self.vad_enabled:
+                    self._connection.on(
+                        LiveTranscriptionEvents(LiveTranscriptionEvents.SpeechStarted),
+                        self._on_speech_started,
+                    )
+                    self._connection.on(
+                        LiveTranscriptionEvents(LiveTranscriptionEvents.UtteranceEnd),
+                        self._on_utterance_end,
+                    )
+
+                # Attempt to start the connection (timeout handled by open_timeout config)
+                if await self._connection.start(options=self._settings, addons=self._addons):
+                    self.logger.info("Successfully connected to Deepgram.")
+                    return  # Exit the method on success
+
+                self.logger.warning(
+                    f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} failed."
+                )
+
+            except Exception as e:
+                self.logger.warning(
+                    f"Deepgram connection attempt {attempt + 1}/{self._max_connect_retries} failed with an exception: {e}"
+                )
+
+            # If this is not the last attempt, wait briefly before retrying
+            if attempt < self._max_connect_retries - 1:
+                self.logger.info(f"Retrying in {self._connect_retry_delay_s} second(s)...")
+                await asyncio.sleep(self._connect_retry_delay_s)
+
+        self.logger.error(
+            f"{self}: unable to connect to Deepgram after {self._max_connect_retries} attempts."
+        )
 
     async def _disconnect(self):
         if self._connection.is_connected: