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

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

@@ -34,6 +34,55 @@ jobs:
     - name: Checkout code
       uses: actions/checkout@v4
 
+    # - 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: 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"
+        
+    #     # 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"
+          
+    #       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
+
     - name: Authenticate to GCP using Workload Identity Federation
       id: auth
       uses: google-github-actions/auth@v2
@@ -134,9 +183,107 @@ jobs:
     - name: Deploy canary service
       if: github.ref == 'refs/heads/dv-main'
       run: |
+        echo "🚀 Deploying canary service..."
         helm upgrade --install ${HELM_RELEASE_NAME}-canary ./k8s/dv-pipecat \
           -f ./k8s/dv-pipecat/values-prod.yaml \
           -f ./k8s/dv-pipecat/values-canary.yaml \
           --set image.repository=$REGION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE_NAME \
           --set image.tag=$GITHUB_SHA \
-          --namespace default
+          --namespace default
+
+    # - name: Deployment validation
+    #   run: |
+    #     echo "🔍 Validating deployment..."
+        
+    #     if [ "${{ github.ref }}" == "refs/heads/dv-stage" ]; then
+    #       DEPLOYMENT_NAME="$HELM_RELEASE_NAME"
+    #       ENVIRONMENT="staging"
+    #     else
+    #       DEPLOYMENT_NAME="${HELM_RELEASE_NAME}-canary"
+    #       ENVIRONMENT="production-canary"
+    #     fi
+        
+    #     echo "📊 Checking deployment: $DEPLOYMENT_NAME"
+        
+    #     # Wait for deployment to be ready
+    #     kubectl rollout status deployment/$DEPLOYMENT_NAME --namespace=default --timeout=300s
+        
+    #     # Check pod status
+    #     READY_PODS=$(kubectl get deployment $DEPLOYMENT_NAME --namespace=default -o jsonpath='{.status.readyReplicas}')
+    #     DESIRED_PODS=$(kubectl get deployment $DEPLOYMENT_NAME --namespace=default -o jsonpath='{.spec.replicas}')
+        
+    #     echo "📈 Pod Status: $READY_PODS/$DESIRED_PODS ready"
+        
+    #     if [ "$READY_PODS" = "$DESIRED_PODS" ] && [ "$READY_PODS" -gt "0" ]; then
+    #       echo "✅ Deployment validation successful for $ENVIRONMENT"
+    #       echo "🎉 All $READY_PODS pods are ready and running"
+          
+    #       # Show running pods
+    #       echo "🔍 Running pods:"
+    #       kubectl get pods -l app.kubernetes.io/name=dv-pipecat --namespace=default
+          
+    #     else
+    #       echo "❌ Deployment validation failed for $ENVIRONMENT"
+    #       echo "🚨 Expected $DESIRED_PODS pods, but only $READY_PODS are ready"
+          
+    #       # Show pod details for debugging
+    #       echo "🔍 Pod details:"
+    #       kubectl get pods -l app.kubernetes.io/name=dv-pipecat --namespace=default
+    #       kubectl describe deployment/$DEPLOYMENT_NAME --namespace=default
+          
+    #       exit 1
+    #     fi
+
+    # - name: Package version verification
+    #   run: |
+    #     echo "🔍 Verifying deployment readiness..."
+        
+    #     if [ "${{ github.ref }}" == "refs/heads/dv-stage" ]; then
+    #       DEPLOYMENT_NAME="$HELM_RELEASE_NAME"
+    #     else
+    #       DEPLOYMENT_NAME="${HELM_RELEASE_NAME}-canary"
+    #     fi
+        
+    #     # Get a pod name from the deployment
+    #     POD_NAME=$(kubectl get pods -l app.kubernetes.io/name=dv-pipecat,app.kubernetes.io/instance=$DEPLOYMENT_NAME --namespace=default -o jsonpath='{.items[0].metadata.name}' 2>/dev/null || echo "")
+        
+    #     if [ -n "$POD_NAME" ]; then
+    #       echo "📦 Found running pod: $POD_NAME"
+    #       echo "📊 Expected pipecat version: $PIPECAT_VERSION"
+    #       echo "✅ Deployment verification completed"
+    #     else
+    #       echo "⚠️  Could not find running pod for verification"
+    #     fi
+
+    # - name: Deployment success notification
+    #   run: |
+    #     if [ "${{ github.ref }}" == "refs/heads/dv-stage" ]; then
+    #       ENVIRONMENT="🔧 Staging"
+    #       NEXT_STEP="Ready for production deployment to dv-main"
+    #     else
+    #       ENVIRONMENT="🚀 Production Canary"
+    #       NEXT_STEP="Ready for promotion to stable production"
+    #     fi
+        
+    #     echo "🎉 DEPLOYMENT SUCCESS!"
+    #     echo "   Environment: $ENVIRONMENT" 
+    #     echo "   Pipecat Version: $PIPECAT_VERSION"
+    #     echo "   Image: $REGION-docker.pkg.dev/$PROJECT_ID/$REPOSITORY/$IMAGE_NAME:$GITHUB_SHA"
+    #     echo "   Next Step: $NEXT_STEP"
+
+    # - name: Deployment failure notification
+    #   if: failure()
+    #   run: |
+    #     echo "❌ DEPLOYMENT FAILED!"
+    #     echo "🚨 The deployment encountered an error. Check the logs above for details."
+        
+    #     # Show recent events for debugging
+    #     echo "🔍 Recent Kubernetes events:"
+    #     kubectl get events --namespace=default --sort-by='.metadata.creationTimestamp' --field-selector type!=Normal | tail -10
+        
+    #     # Show deployment status
+    #     if [ "${{ github.ref }}" == "refs/heads/dv-stage" ]; then
+    #       kubectl describe deployment/$HELM_RELEASE_NAME --namespace=default || true
+    #     else
+    #       kubectl describe deployment/${HELM_RELEASE_NAME}-canary --namespace=default || true
+    #     fi

dv_pipecat_ai-0.0.74.dev623/.github/workflows/smart-auto-release.yml

@@ -0,0 +1,171 @@
+name: Smart Auto-Release on PR Merge
+
+on:
+  pull_request:
+    types: [closed]
+    branches: [dv-stage]
+
+env:
+  PACKAGE_NAME: "dv-pipecat-ai"
+  REQUIREMENTS_FILE: "examples/ringg-chatbot/remote-requirements.txt"
+
+jobs:
+  smart-release:
+    if: github.event.pull_request.merged == true
+    runs-on: ubuntu-latest
+    permissions:
+      contents: write
+      pull-requests: write
+
+    steps:
+    - name: Checkout code
+      uses: actions/checkout@v4
+      with:
+        fetch-depth: 0
+        token: ${{ secrets.GITHUB_TOKEN }}
+
+    - name: Set up Python
+      uses: actions/setup-python@v4
+      with:
+        python-version: '3.10'
+
+    - name: Install dependencies
+      run: |
+        python -m pip install --upgrade pip
+        pip install build twine requests packaging
+
+    - name: Check for src/pipecat changes
+      id: check-changes
+      run: |
+        echo "Checking for changes in src/pipecat..."
+        if git diff --name-only ${{ github.event.pull_request.base.sha }}..${{ github.event.pull_request.head.sha }} | grep -q "src/pipecat"; then
+          echo "HAS_PIPECAT_CHANGES=true" >> $GITHUB_OUTPUT
+          echo "✅ Found changes in src/pipecat"
+        else
+          echo "HAS_PIPECAT_CHANGES=false" >> $GITHUB_OUTPUT
+          echo "ℹ️  No changes in src/pipecat detected"
+        fi
+
+    - name: Get current versions
+      if: steps.check-changes.outputs.HAS_PIPECAT_CHANGES == 'true'
+      id: versions
+      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
+        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
+        else
+          echo "REQUIREMENTS_VERSION=0.0.0.dev0" >> $GITHUB_OUTPUT
+        fi
+        
+        echo "📊 Version Status:"
+        echo "   PyPI version: $PYPI_VERSION"
+        echo "   Requirements version: $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 }}"
+        
+        echo "🤔 Decision Logic:"
+        echo "   PyPI version: $PYPI_VERSION"
+        echo "   Requirements version: $REQUIREMENTS_VERSION"
+        
+        if [ "$PYPI_VERSION" = "$REQUIREMENTS_VERSION" ]; then
+          echo "SHOULD_RELEASE=true" >> $GITHUB_OUTPUT
+          echo "REASON=Versions match - auto-bumping needed" >> $GITHUB_OUTPUT
+          echo "✅ Decision: AUTO-RELEASE (versions match)"
+        else
+          echo "SHOULD_RELEASE=false" >> $GITHUB_OUTPUT
+          echo "REASON=Developer already updated version" >> $GITHUB_OUTPUT
+          echo "⏭️  Decision: SKIP (developer handled versioning)"
+        fi
+
+    - name: Skip release notification
+      if: steps.check-changes.outputs.HAS_PIPECAT_CHANGES == 'false' || steps.decision.outputs.SHOULD_RELEASE == 'false'
+      run: |
+        if [ "${{ steps.check-changes.outputs.HAS_PIPECAT_CHANGES }}" = "false" ]; then
+          echo "⏭️  SKIPPING: No src/pipecat changes detected"
+          SKIP_REASON="No src/pipecat changes in this PR"
+        else
+          echo "⏭️  SKIPPING: ${{ steps.decision.outputs.REASON }}"
+          SKIP_REASON="Developer already updated version"
+        fi
+        echo "Skip reason: $SKIP_REASON"
+
+    - name: Calculate new version
+      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..."
+        python -m build
+        echo "✅ Package built successfully"
+        ls -la dist/
+
+    - name: Publish to PyPI
+      if: steps.decision.outputs.SHOULD_RELEASE == 'true'
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}
+        print-hash: true
+        verbose: true
+
+    - 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"
+        
+        # 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 }}
+        
+        # Show the change
+        echo "📋 Updated requirements file:"
+        grep "${{ env.PACKAGE_NAME }}" ${{ env.REQUIREMENTS_FILE }}
+        
+        # Configure git
+        git config --local user.email "action@github.com"
+        git config --local user.name "GitHub Action"
+        
+        # Commit the change
+        git add ${{ env.REQUIREMENTS_FILE }}
+        git commit -m "🤖 Auto-bump pipecat version to $NEW_VERSION"
+        
+        # Push to dv-stage
+        git push origin HEAD:dv-stage
+
+    - name: Success notification
+      if: steps.decision.outputs.SHOULD_RELEASE == 'true'
+      run: |
+        NEW_VERSION="${{ steps.new-version.outputs.NEW_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 "   📝 Updated: ${{ env.REQUIREMENTS_FILE }}"
+        echo "   🚀 Deployment will proceed automatically"
+
+    - name: Error notification
+      if: failure() && steps.decision.outputs.SHOULD_RELEASE == 'true'
+      run: |
+        echo "❌ ERROR: Auto-release failed!"
+        echo "Check the workflow logs for details."

{dv_pipecat_ai-0.0.74.dev613 → dv_pipecat_ai-0.0.74.dev623}/CLAUDE.md

@@ -36,6 +36,30 @@ ruff check --select I
 ./scripts/pre-commit.sh
 ```
 
+### Release Management
+**🚀 Smart Auto-Release System** - Automated version management and deployment
+
+```bash
+# Developer workflow (unchanged):
+# 1. Make changes to src/pipecat
+# 2. Create PR to dv-stage → Merge
+# 3. Everything else is automatic!
+
+# Manual version utilities (if needed):
+python scripts/version-utils.py info      # Check version status
+python scripts/version-utils.py check     # Verify version consistency
+python scripts/version-utils.py update 0.0.75.dev123  # Manual version update
+```
+
+**How it works:**
+- ✅ **Auto-detects** when `src/pipecat` changes
+- ✅ **Smart versioning** - only releases when needed
+- ✅ **PyPI publishing** with error handling and retries
+- ✅ **Deployment coordination** with package verification
+- ✅ **Zero developer overhead** - respects manual versioning
+
+See **[docs/AUTO_RELEASE.md](docs/AUTO_RELEASE.md)** for complete documentation.
+
 ### Ringg Chatbot Development (Primary Codebase)
 The main development work happens in `examples/ringg-chatbot/`, which is a production telephony chatbot system.
 
@@ -252,6 +276,47 @@ For deep understanding of the Pipecat framework architecture:
   - AI services integration (LLMService, STTService, TTSService)
   - Complete code flow patterns and when to use different approaches
 
+## Performance & Async Requirements
+
+### Critical Performance Considerations
+
+**⚡ Async Processing - Never Block the Event Loop**
+- **MANDATORY**: All operations must be async and non-blocking
+- Use `await` for I/O operations (file reads, network calls, database queries)
+- Use `asyncio.create_task()` or `asyncio.gather()` for concurrent operations
+- Never use blocking calls like `time.sleep()` - use `asyncio.sleep()` instead
+- Avoid synchronous file I/O - use `aiofiles` or async equivalents
+- Database operations must use async drivers (asyncpg, aiomysql, etc.)
+
+**🎯 Ultra-Low Latency Voice AI**
+- **Target**: Minimize time from "user stops speaking" → "bot starts speaking"
+- **Critical Path**: STT processing → LLM response → TTS generation → audio output
+- Every millisecond matters for natural conversation flow
+- Optimize each pipeline stage for minimal latency:
+  - STT: Use streaming transcription services (Deepgram, AssemblyAI)
+  - LLM: Choose fast models, optimize prompts, use streaming responses
+  - TTS: Cache common responses, use low-latency providers (Cartesia, ElevenLabs)
+  - Audio: Minimize buffering, use real-time transport protocols
+
+### Async Best Practices
+```python
+# ✅ Good - Non-blocking async operations
+async def process_audio(audio_data):
+    tasks = [
+        asyncio.create_task(stt_service.transcribe(audio_data)),
+        asyncio.create_task(cache.get(cache_key))
+    ]
+    results = await asyncio.gather(*tasks)
+    return results
+
+# ❌ Bad - Blocking operations that freeze the event loop
+def process_audio_bad(audio_data):
+    time.sleep(0.1)  # Blocks entire event loop!
+    response = requests.get(url)  # Synchronous HTTP call
+    with open('file.txt', 'r') as f:  # Synchronous file I/O
+        data = f.read()
+```
+
 ## Common Gotchas
 
 - **For framework development**: Always activate virtual environment and use `pip install -e ".[provider,...]"`
@@ -259,4 +324,6 @@ For deep understanding of the Pipecat framework architecture:
 - Pre-commit hooks enforce code formatting with Ruff
 - Frame processors must handle both downstream and upstream flow
 - Pipeline lifecycle: StartFrame → processing → EndFrame/StopFrame
-- **Telephony**: WebSocket connections require proper call_id tracking and cleanup
+- **Telephony**: WebSocket connections require proper call_id tracking and cleanup
+- **Async**: Never block the event loop - use async/await for all I/O operations
+- **Latency**: Voice AI requires sub-second response times - optimize every pipeline stage

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

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

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

@@ -49,6 +49,7 @@ test-requirements.txt
 .github/workflows/publish.yaml
 .github/workflows/publish_test.yaml
 .github/workflows/set-traffic-split.yml
+.github/workflows/smart-auto-release.yml
 .github/workflows/tests.yaml
 create-new-machine/ansible.cfg
 create-new-machine/ansible_setup.sh

{dv_pipecat_ai-0.0.74.dev613 → dv_pipecat_ai-0.0.74.dev623}/src/pipecat/serializers/convox.py

@@ -5,6 +5,7 @@
 #
 
 import base64
+import datetime
 import json
 from typing import Optional
 
@@ -14,6 +15,7 @@ from pydantic import BaseModel
 from pipecat.audio.utils import create_default_resampler
 from pipecat.frames.frames import (
     AudioRawFrame,
+    CancelFrame,
     EndFrame,
     Frame,
     InputAudioRawFrame,
@@ -117,7 +119,7 @@ class ConVoxFrameSerializer(FrameSerializer):
             if self._call_ended:
                 logger.debug("🎵 CONVOX SERIALIZE: Skipping audio - call has ended")
                 return None
-                
+
             # Convert PCM audio to ConVox format
             data = frame.audio
             # logger.info(
@@ -134,11 +136,8 @@ class ConVoxFrameSerializer(FrameSerializer):
 
             # Encode as base64 for transmission
             payload = base64.b64encode(serialized_data).decode("ascii")
-            logger.info(f"🎵 CONVOX SERIALIZE: Base64 encoded - {len(payload)} characters")
 
             # ConVox expects play_audio event format according to the documentation
-            import datetime
-
             timestamp = datetime.datetime.now().isoformat()
 
             message = {
@@ -253,15 +252,11 @@ class ConVoxFrameSerializer(FrameSerializer):
         elif event == "end_call" or event == "call_end":
             logger.info("ConVox call end event received")
             self._call_ended = True
-            return EndFrame()
+            return CancelFrame()
 
         elif event == "failed":
             logger.info(f"ConVox failed event received: {message}")
             self._call_ended = True
-            return EndFrame()
-
-        else:
-            logger.debug(f"Unhandled ConVox event: {event}")
-            return None
+            return CancelFrame()
 
         return None

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

@@ -6,6 +6,7 @@
 
 """Deepgram speech-to-text service implementation."""
 
+import logging
 from typing import AsyncGenerator, Dict, Optional
 
 from loguru import logger
@@ -116,7 +117,11 @@ class DeepgramSTTService(STTService):
             api_key,
             config=DeepgramClientOptions(
                 url=base_url,
-                options={"keepalive": "true"},  # verbose=logging.DEBUG
+                options={
+                    "keepalive": "true",
+                    # "termination_exception_connect": True,  # Enable exception propagation
+                },
+                verbose=logging.ERROR,  # Enable warning level and above logging
             ),
         )
 

{dv_pipecat_ai-0.0.74.dev613 → dv_pipecat_ai-0.0.74.dev623}/src/pipecat/transports/network/fastapi_websocket.py

@@ -36,7 +36,7 @@ from pipecat.utils.asyncio.watchdog_async_iterator import WatchdogAsyncIterator
 
 try:
     from fastapi import WebSocket
-    from starlette.websockets import WebSocketState
+    from starlette.websockets import WebSocketDisconnect, WebSocketState
 except ModuleNotFoundError as e:
     logger.error(f"Exception: {e}")
     logger.error(
@@ -87,16 +87,22 @@ class FastAPIWebsocketClient:
                 else:
                     await self._websocket.send_text(data)
         except Exception as e:
-            logger.error(
-                f"{self} exception sending data: {e.__class__.__name__} ({e}), application_state: {self._websocket.application_state}",
-                call_id=self._conversation_id,
-            )
-            # TODO: Remove print statement
-            print("Exception sending data")
-            traceback.print_exc()
+            if isinstance(e, WebSocketDisconnect):
+                logger.warning(
+                    f"{self} WebSocket disconnected during send: {e}, application_state: {self._websocket.application_state}",
+                    call_id=self._conversation_id,
+                )
+            else:
+                logger.error(
+                    f"{self} exception sending data: {e.__class__.__name__} ({e}), application_state: {self._websocket.application_state}",
+                    call_id=self._conversation_id,
+                )
             # For some reason the websocket is disconnected, and we are not able to send data
-            # So let's properly handle it and disconnect the transport
-            if self._websocket.application_state == WebSocketState.DISCONNECTED:
+            # So let's properly handle it and disconnect the transport if it is not already disconnecting
+            if (
+                self._websocket.application_state == WebSocketState.DISCONNECTED
+                and not self.is_closing
+            ):
                 logger.warning(
                     "Closing already disconnected websocket!", call_id=self._conversation_id
                 )
@@ -109,8 +115,12 @@ class FastAPIWebsocketClient:
             return
         if self.is_connected and not self.is_closing:
             self._closing = True
-            await self._websocket.close()
-            await self.trigger_client_disconnected()
+            try:
+                await self._websocket.close()
+            except Exception as e:
+                logger.error(f"{self} exception while closing the websocket: {e}")
+            finally:
+                await self.trigger_client_disconnected()
 
     async def trigger_client_disconnected(self):
         await self._callbacks.on_client_disconnected(self._websocket)