vision-agents-plugins-deepgram 0.1.9__tar.gz → 0.1.12__tar.gz

{vision_agents_plugins_deepgram-0.1.9 → vision_agents_plugins_deepgram-0.1.12}/.gitignore

@@ -84,3 +84,4 @@ stream-py/
 # Artifacts / assets
 *.pt
 *.kef
+*.onnx

vision_agents_plugins_deepgram-0.1.12/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: vision-agents-plugins-deepgram
+Version: 0.1.12
+Summary: Deepgram STT integration for Vision Agents
+Project-URL: Documentation, https://visionagents.ai/
+Project-URL: Website, https://visionagents.ai/
+Project-URL: Source, https://github.com/GetStream/Vision-Agents
+License-Expression: MIT
+Keywords: AI,STT,agents,deepgram,speech-to-text,transcription,voice agents
+Requires-Python: >=3.10
+Requires-Dist: deepgram-sdk==5.2.0
+Requires-Dist: numpy<2.3,>=2.2.6
+Requires-Dist: vision-agents
+Description-Content-Type: text/markdown
+
+# Deepgram Speech-to-Text Plugin
+
+A high-quality Speech-to-Text (STT) plugin for Vision agents that uses the Deepgram API.
+
+## Installation
+
+```bash
+uv add vision-agents-plugins-deepgram
+```
+
+## Docs
+
+- https://developers.deepgram.com/docs/flux/quickstart
+- https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py
+- https://github.com/deepgram/deepgram-python-sdk/tree/main

vision_agents_plugins_deepgram-0.1.12/README.md

@@ -0,0 +1,15 @@
+# Deepgram Speech-to-Text Plugin
+
+A high-quality Speech-to-Text (STT) plugin for Vision agents that uses the Deepgram API.
+
+## Installation
+
+```bash
+uv add vision-agents-plugins-deepgram
+```
+
+## Docs
+
+- https://developers.deepgram.com/docs/flux/quickstart
+- https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py
+- https://github.com/deepgram/deepgram-python-sdk/tree/main

{vision_agents_plugins_deepgram-0.1.9 → vision_agents_plugins_deepgram-0.1.12}/pyproject.toml

@@ -12,7 +12,7 @@ requires-python = ">=3.10"
 license = "MIT"
 dependencies = [
     "vision-agents",
-    "deepgram-sdk>=5.0.0,<5.1",
+    "deepgram-sdk==5.2.0",
     "numpy>=2.2.6,<2.3",
 ]
 

{vision_agents_plugins_deepgram-0.1.9 → vision_agents_plugins_deepgram-0.1.12}/vision_agents/plugins/deepgram/__init__.py

@@ -1,4 +1,4 @@
-from .stt import STT
+from .deepgram_stt import STT
 
 # Re-export under the new namespace for convenience
 __path__ = __import__("pkgutil").extend_path(__path__, __name__)

vision_agents_plugins_deepgram-0.1.12/vision_agents/plugins/deepgram/deepgram_stt.py

@@ -0,0 +1,270 @@
+import asyncio
+import logging
+import os
+from typing import Optional, Any
+
+from deepgram import AsyncDeepgramClient
+from deepgram.core import EventType
+from deepgram.extensions.types.sockets import ListenV2ControlMessage
+from deepgram.listen.v2.socket_client import AsyncV2SocketClient
+from getstream.video.rtc.track_util import PcmData
+
+from vision_agents.core import stt
+from vision_agents.core.stt import TranscriptResponse
+from vision_agents.core.edge.types import Participant
+
+logger = logging.getLogger(__name__)
+
+
+class STT(stt.STT):
+    """
+    Deepgram Speech-to-Text implementation using Flux model.
+
+    - https://developers.deepgram.com/docs/flux/quickstart
+    - https://github.com/deepgram/deepgram-python-sdk/blob/main/examples/listen/v2/connect/async.py
+    - https://github.com/deepgram/deepgram-python-sdk/tree/main
+    - https://github.com/deepgram-devs/deepgram-demos-flux-streaming-transcription/blob/main/main.py
+
+    Deepgram flux runs turn detection internally. So running turn detection in front of this is optional/not needed
+
+    - eot_threshold controls turn end sensitivity
+    - eager_eot_threshold controls eager turn ending (so you can already prepare the LLM response)
+    """
+
+    def __init__(
+        self,
+        api_key: Optional[str] = None,
+        model: str = "flux-general-en",
+        language: Optional[str] = None,
+        eot_threshold: Optional[float] = None,
+        eager_eot_threshold: Optional[float] = None,
+        client: Optional[AsyncDeepgramClient] = None,
+    ):
+        """
+        Initialize Deepgram STT.
+
+        Args:
+            api_key: Deepgram API key. If not provided, will use DEEPGRAM_API_KEY env var.
+            model: Model to use for transcription. Defaults to "flux-general-en".
+            language: Language code (e.g., "en", "es"). If not provided, auto-detection is used.
+            eot_threshold: End-of-turn threshold for determining when a turn is complete.
+            eager_eot_threshold: Eager end-of-turn threshold for faster turn detection.
+            client: Optional pre-configured AsyncDeepgramClient instance.
+        """
+        super().__init__(provider_name="deepgram")
+
+        if not api_key:
+            api_key = os.environ.get("DEEPGRAM_API_KEY")
+
+        if client is not None:
+            self.client = client
+        else:
+            # Initialize AsyncDeepgramClient with api_key as named parameter
+            if api_key:
+                self.client = AsyncDeepgramClient(api_key=api_key)
+            else:
+                self.client = AsyncDeepgramClient()
+
+        self.model = model
+        self.language = language
+        self.eot_threshold = eot_threshold
+        self.eager_eot_threshold = eager_eot_threshold
+        self._current_participant: Optional[Participant] = None
+        self.connection: Optional[AsyncV2SocketClient] = None
+        self._connection_ready = asyncio.Event()
+        self._connection_context: Optional[Any] = None
+        self._listen_task: Optional[asyncio.Task[Any]] = None
+
+    async def process_audio(
+        self,
+        pcm_data: PcmData,
+        participant: Optional[Participant] = None,
+    ):
+        """
+        Process audio data through Deepgram for transcription.
+
+        This method sends audio to the existing WebSocket connection. The connection
+        is started automatically on first use. Audio is automatically resampled to 16kHz.
+
+        Args:
+            pcm_data: The PCM audio data to process.
+            participant: Optional participant metadata (currently not used in streaming mode).
+        """
+        if self.closed:
+            logger.warning("Deepgram STT is closed, ignoring audio")
+            return
+
+        # Wait for connection to be ready
+        await self._connection_ready.wait()
+
+        # Double-check connection is still ready (could have closed while waiting)
+        if not self._connection_ready.is_set():
+            logger.warning("Deepgram connection closed while processing audio")
+            return
+
+        # Resample to 16kHz mono (recommended by Deepgram)
+        resampled_pcm = pcm_data.resample(16_000, 1)
+
+        # Convert int16 samples to bytes
+        audio_bytes = resampled_pcm.samples.tobytes()
+
+        self._current_participant = participant
+
+        if self.connection is not None:
+            await self.connection.send_media(audio_bytes)
+
+    async def start(self):
+        """
+        Start the Deepgram WebSocket connection and begin listening for transcripts.
+        """
+        if self.connection is not None:
+            logger.warning("Deepgram connection already started")
+            return
+
+        # Build connection parameters
+        connect_params = {
+            "model": self.model,
+            "encoding": "linear16",
+            "sample_rate": "16000",
+        }
+        
+        # Add optional parameters if specified
+        if self.eot_threshold is not None:
+            connect_params["eot_threshold"] = str(self.eot_threshold)
+        if self.eager_eot_threshold is not None:
+            connect_params["eager_eot_threshold"] = str(self.eager_eot_threshold)
+        
+        # Connect to Deepgram v2 listen WebSocket with timeout
+        self._connection_context = self.client.listen.v2.connect(**connect_params)
+        
+        # Add timeout for connection establishment
+        self.connection = await asyncio.wait_for(
+            self._connection_context.__aenter__(),
+            timeout=10.0
+        )
+
+        # Register event handlers
+        if self.connection is not None:
+            self.connection.on(EventType.OPEN, self._on_open)
+            self.connection.on(EventType.MESSAGE, self._on_message)
+            self.connection.on(EventType.ERROR, self._on_error)
+            self.connection.on(EventType.CLOSE, self._on_close)
+            
+            # Start listening for events
+            self._listen_task = asyncio.create_task(self.connection.start_listening())
+
+        # Mark connection as ready
+        self._connection_ready.set()
+
+    def _on_message(self, message):
+        """
+        Event handler for messages from Deepgram.
+        
+        Args:
+            message: The message object from Deepgram
+        """
+        # Extract message data
+        if not hasattr(message, "type"):
+            logger.warning(f"Received message without 'type' attribute: {message}")
+            return
+
+        # Handle TurnInfo messages (v2 API)
+        if message.type == "TurnInfo":
+            # Extract transcript text
+            transcript_text = getattr(message, "transcript", "").strip()
+
+            if not transcript_text:
+                return
+
+            # Get event type to determine if final or partial
+            # "StartOfTurn" and "Update" = partial, "EndOfTurn" = final
+            event = getattr(message, "event", "")
+
+            is_final = event == "EndOfTurn"
+
+            # Get end of turn confidence
+            end_of_turn_confidence = getattr(message, "end_of_turn_confidence", 0.0)
+
+            # Calculate average confidence from words
+            words = getattr(message, "words", [])
+            if words:
+                confidences = [w.confidence for w in words if hasattr(w, "confidence")]
+                avg_confidence = sum(confidences) / len(confidences) if confidences else 0.0
+            else:
+                avg_confidence = 0.0
+
+            # Get audio duration
+            audio_window_end = getattr(message, "audio_window_end", 0.0)
+            duration_ms = int(audio_window_end * 1000)
+
+            # Build response metadata
+            response_metadata = TranscriptResponse(
+                confidence=avg_confidence,
+                language=self.language or "auto",
+                audio_duration_ms=duration_ms,
+                model_name=self.model,
+                other={
+                    "end_of_turn_confidence": end_of_turn_confidence,
+                    "turn_index": getattr(message, "turn_index", None),
+                    "event": event,
+                }
+            )
+
+            # Use the participant from the most recent process_audio call
+            participant = self._current_participant
+
+            if participant is None:
+                logger.warning("Received transcript but no participant set")
+                return
+
+            if is_final:
+                # Final transcript (event == "EndOfTurn")
+                self._emit_transcript_event(
+                    transcript_text, participant, response_metadata
+                )
+            else:
+                # Partial transcript (event == "StartOfTurn" or "Update")
+                self._emit_partial_transcript_event(
+                    transcript_text, participant, response_metadata
+                )
+
+    def _on_open(self, message):
+        pass
+
+    def _on_error(self, error):
+        """
+        Event handler for errors from Deepgram.
+        
+        Args:
+            error: The error from Deepgram
+        """
+        logger.error(f"Deepgram WebSocket error: {error}")
+        raise Exception(f"Deepgram WebSocket error {error}")
+
+    def _on_close(self, error):
+        """
+        Event handler for connection close.
+        """
+        logger.warning(f"Deepgram WebSocket connection closed: {error}")
+        self._connection_ready.clear()
+
+    async def close(self):
+        """
+        Close the Deepgram connection and clean up resources.
+        """
+        # Mark as closed first
+        await super().close()
+
+        # Cancel listen task
+        if self._listen_task and not self._listen_task.done():
+            self._listen_task.cancel()
+            await asyncio.gather(self._listen_task, return_exceptions=True)
+
+        # Close connection
+        if self.connection and self._connection_context:
+            close_msg = ListenV2ControlMessage(type="CloseStream")
+            await self.connection.send_control(close_msg)
+            await self._connection_context.__aexit__(None, None, None)
+            self.connection = None
+            self._connection_context = None
+            self._connection_ready.clear()

vision_agents_plugins_deepgram-0.1.9/PKG-INFO

@@ -1,69 +0,0 @@
-Metadata-Version: 2.4
-Name: vision-agents-plugins-deepgram
-Version: 0.1.9
-Summary: Deepgram STT integration for Vision Agents
-Project-URL: Documentation, https://visionagents.ai/
-Project-URL: Website, https://visionagents.ai/
-Project-URL: Source, https://github.com/GetStream/Vision-Agents
-License-Expression: MIT
-Keywords: AI,STT,agents,deepgram,speech-to-text,transcription,voice agents
-Requires-Python: >=3.10
-Requires-Dist: deepgram-sdk<5.1,>=5.0.0
-Requires-Dist: numpy<2.3,>=2.2.6
-Requires-Dist: vision-agents
-Description-Content-Type: text/markdown
-
-# Deepgram Speech-to-Text Plugin
-
-A high-quality Speech-to-Text (STT) plugin for Vision agents that uses the Deepgram API.
-
-## Installation
-
-```bash
-uv add vision-agents-plugins-deepgram
-```
-
-## Usage
-
-```python
-from vision_agents.plugins import deepgram
-from getstream.video.rtc.track_util import PcmData
-
-# Initialize with API key from environment variable
-stt = deepgram.STT()
-
-# Or specify API key directly
-stt = deepgram.STT(api_key="your_deepgram_api_key")
-
-# Register event handlers
-@stt.on("transcript")
-def on_transcript(text, user, metadata):
-    print(f"Final transcript from {user}: {text}")
-
-@stt.on("partial_transcript")
-def on_partial(text, user, metadata):
-    print(f"Partial transcript from {user}: {text}")
-
-# Process audio
-pcm_data = PcmData(samples=b"\x00\x00" * 1000, sample_rate=48000, format="s16")
-await stt.process_audio(pcm_data)
-
-# When done
-await stt.close()
-```
-
-## Configuration Options
-
-- `api_key`: Deepgram API key (default: reads from `DEEPGRAM_API_KEY` environment variable)
-- `options`: Deepgram options for configuring the transcription.  
-See the [Deepgram Listen V1 Connect API documentation](https://github.com/deepgram/deepgram-python-sdk/blob/main/websockets-reference.md#%EF%B8%8F-parameters) for more details.
-- `sample_rate`: Sample rate of the audio in Hz (default: 16000)
-- `language`: Language code for transcription (default: "en-US")
-- `keep_alive_interval`: Interval in seconds to send keep-alive messages (default: 1.0s)
-- `connection_timeout`: Timeout to wait for the Deepgram connection to be established before skipping the  in seconds to send keep-alive messages (default: 15.0s)
-
-## Requirements
-
-- Python 3.10+
-- deepgram-sdk>=5.0.0,<5.1
-- numpy>=2.2.6,<2.3

vision_agents_plugins_deepgram-0.1.9/README.md

@@ -1,54 +0,0 @@
-# Deepgram Speech-to-Text Plugin
-
-A high-quality Speech-to-Text (STT) plugin for Vision agents that uses the Deepgram API.
-
-## Installation
-
-```bash
-uv add vision-agents-plugins-deepgram
-```
-
-## Usage
-
-```python
-from vision_agents.plugins import deepgram
-from getstream.video.rtc.track_util import PcmData
-
-# Initialize with API key from environment variable
-stt = deepgram.STT()
-
-# Or specify API key directly
-stt = deepgram.STT(api_key="your_deepgram_api_key")
-
-# Register event handlers
-@stt.on("transcript")
-def on_transcript(text, user, metadata):
-    print(f"Final transcript from {user}: {text}")
-
-@stt.on("partial_transcript")
-def on_partial(text, user, metadata):
-    print(f"Partial transcript from {user}: {text}")
-
-# Process audio
-pcm_data = PcmData(samples=b"\x00\x00" * 1000, sample_rate=48000, format="s16")
-await stt.process_audio(pcm_data)
-
-# When done
-await stt.close()
-```
-
-## Configuration Options
-
-- `api_key`: Deepgram API key (default: reads from `DEEPGRAM_API_KEY` environment variable)
-- `options`: Deepgram options for configuring the transcription.  
-See the [Deepgram Listen V1 Connect API documentation](https://github.com/deepgram/deepgram-python-sdk/blob/main/websockets-reference.md#%EF%B8%8F-parameters) for more details.
-- `sample_rate`: Sample rate of the audio in Hz (default: 16000)
-- `language`: Language code for transcription (default: "en-US")
-- `keep_alive_interval`: Interval in seconds to send keep-alive messages (default: 1.0s)
-- `connection_timeout`: Timeout to wait for the Deepgram connection to be established before skipping the  in seconds to send keep-alive messages (default: 15.0s)
-
-## Requirements
-
-- Python 3.10+
-- deepgram-sdk>=5.0.0,<5.1
-- numpy>=2.2.6,<2.3

vision_agents_plugins_deepgram-0.1.9/vision_agents/plugins/deepgram/stt.py

@@ -1,349 +0,0 @@
-import asyncio
-import contextlib
-import logging
-import os
-import time
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Tuple, Union
-
-import numpy as np
-import websockets
-from deepgram import AsyncDeepgramClient
-from deepgram.core.events import EventType
-from deepgram.extensions.types.sockets import (
-    ListenV1ControlMessage,
-    ListenV1MetadataEvent,
-    ListenV1ResultsEvent,
-    ListenV1SpeechStartedEvent,
-    ListenV1UtteranceEndEvent,
-)
-from deepgram.listen.v1.socket_client import AsyncV1SocketClient
-from getstream.video.rtc.track_util import PcmData
-
-from vision_agents.core import stt
-
-from .utils import generate_silence
-
-if TYPE_CHECKING:
-    from vision_agents.core.edge.types import Participant
-
-logger = logging.getLogger(__name__)
-
-
-class STT(stt.STT):
-    """
-    Deepgram-based Speech-to-Text implementation.
-
-    This implementation operates in asynchronous mode - it receives streaming transcripts
-    from Deepgram's WebSocket connection and emits events immediately as they arrive,
-    providing real-time responsiveness for live transcription scenarios.
-
-    Events:
-        - transcript: Emitted when a complete transcript is available.
-            Args: text (str), user_metadata (dict), metadata (dict)
-        - partial_transcript: Emitted when a partial transcript is available.
-            Args: text (str), user_metadata (dict), metadata (dict)
-        - error: Emitted when an error occurs during transcription.
-            Args: error (Exception)
-    """
-
-    def __init__(
-        self,
-        api_key: Optional[str] = None,
-        options: Optional[dict] = None,
-        sample_rate: int = 48000,
-        language: str = "en-US",
-        interim_results: bool = True,
-        client: Optional[AsyncDeepgramClient] = None,
-        keep_alive_interval: float = 1.0,
-        connection_timeout: float = 15.0,
-    ):
-        """
-        Initialize the Deepgram STT service.
-
-        Args:
-            api_key: Deepgram API key. If not provided, the DEEPGRAM_API_KEY
-                    environment variable will be used automatically.
-            options: Deepgram live transcription options
-            sample_rate: Sample rate of the audio in Hz (default: 48000)
-            language: Language code for transcription
-            interim_results: Whether to emit interim results (partial transcripts with the partial_transcript event).
-            connection_timeout: Time to wait for the Deepgram connection to be established.
-
-        """
-        super().__init__(sample_rate=sample_rate)
-
-        # If no API key was provided, check for DEEPGRAM_API_KEY in environment
-        if api_key is None:
-            api_key = os.environ.get("DEEPGRAM_API_KEY")
-            if not api_key:
-                logger.warning(
-                    "No API key provided and DEEPGRAM_API_KEY environment variable not found."
-                )
-
-        # Initialize DeepgramClient with the API key
-        logger.info("Initializing Deepgram client")
-        self.deepgram = (
-            client if client is not None else AsyncDeepgramClient(api_key=api_key)
-        )
-        self.dg_connection: Optional[AsyncV1SocketClient] = None
-
-        self.options = options or {
-            "model": "nova-2",
-            "language": language,
-            "encoding": "linear16",
-            "sample_rate": sample_rate,
-            "channels": 1,
-            "interim_results": interim_results,
-        }
-
-        # Track current user context for associating transcripts with users
-        self._current_user: Optional[Dict[str, Any]] = None
-
-        # Generate a silence audio to use as keep-alive message
-        self._keep_alive_data = generate_silence(
-            sample_rate=sample_rate, duration_ms=10
-        )
-        self._keep_alive_interval = keep_alive_interval
-
-        self._stack = contextlib.AsyncExitStack()
-        # An event to detect that the connection was established once.
-        self._connected_once = asyncio.Event()
-        # Time to wait for connection to be established before sending the event
-        self._connection_timeout = connection_timeout
-        self._last_sent_at = float("-inf")
-        # Lock to prevent concurrent connection opening
-        self._connect_lock = asyncio.Lock()
-
-        # Start the listener loop in the background
-        asyncio.create_task(self.start())
-
-    async def start(self):
-        """
-        Start the main task establishing the Deepgram connection and processing the events.
-        """
-        if self._is_closed:
-            logger.warning("Cannot setup connection - Deepgram instance is closed")
-            return None
-
-        # Establish a Deepgram connection.
-        # Use a lock to make sure it's established only once
-        async with self._connect_lock:
-            if self.dg_connection is not None:
-                logger.debug("Connection already set up, skipping initialization")
-                return None
-
-            try:
-                logger.info("Creating a Deepgram connection with options %s", self.options)
-                dg_connection = await self._stack.enter_async_context(
-                    self.deepgram.listen.v1.connect(**self.options)
-                )
-            except Exception as e:
-                # Log the error and set connection to None
-                logger.exception("Error setting up Deepgram connection")
-                self.dg_connection = None
-                # Emit error immediately
-                self._emit_error_event(e, "Deepgram connection setup")
-                raise
-            finally:
-                self._connected_once.set()
-
-        self.dg_connection = dg_connection
-        # Start the keep-alive loop to keep the connection open
-        asyncio.create_task(self._keepalive_loop())
-
-        # Register event handlers
-        self.dg_connection.on(
-            EventType.OPEN,
-            lambda msg: logger.debug(f"Deepgram connection opened. message={msg}"),
-        )
-        self.dg_connection.on(EventType.CLOSE, self._on_connection_close)
-        self.dg_connection.on(EventType.ERROR, self._on_connection_error)
-        self.dg_connection.on(EventType.MESSAGE, self._on_message)
-
-        # Start processing the events from Deepgram.
-        # This is a blocking call.
-        logger.debug("Listening to the events from a Deepgram connection")
-        await self.dg_connection.start_listening()
-        return None
-
-    async def started(self):
-        """
-        Wait until the Deepgram connection is established.
-        """
-        if self._connected_once.is_set():
-            return
-
-        await asyncio.wait_for(
-            self._connected_once.wait(), timeout=self._connection_timeout
-        )
-
-    async def close(self):
-        """Close the Deepgram connection and clean up resources."""
-        if self._is_closed:
-            logger.debug("Deepgram STT service already closed")
-            return
-
-        logger.info("Closing Deepgram STT service")
-        self._is_closed = True
-
-        # Close the Deepgram connection if it exists
-        if self.dg_connection:
-            logger.debug("Closing Deepgram connection")
-            try:
-                await self.dg_connection.send_control(
-                    ListenV1ControlMessage(type="CloseStream")
-                )
-                await self._stack.aclose()
-                self.dg_connection = None
-            except Exception:
-                logger.exception("Error closing Deepgram connection")
-
-    async def _on_message(
-        self,
-        message: ListenV1ResultsEvent
-        | ListenV1MetadataEvent
-        | ListenV1UtteranceEndEvent
-        | ListenV1SpeechStartedEvent,
-    ):
-        if message.type != "Results":
-            logger.debug(
-                "Received non-transcript message, skip processing. message=%s", message
-            )
-            return
-
-        transcript = message.dict()
-
-        # Get the transcript text from the response
-        alternatives = transcript.get("channel", {}).get("alternatives", [])
-        if not alternatives:
-            return
-
-        transcript_text = alternatives[0].get("transcript", "")
-        if not transcript_text:
-            return
-
-        # Check if this is a final result
-        is_final = transcript.get("is_final", False)
-
-        # Create metadata with useful information
-        metadata = {
-            "confidence": alternatives[0].get("confidence", 0),
-            "words": alternatives[0].get("words", []),
-            "is_final": is_final,
-            "channel_index": transcript.get("channel_index", 0),
-        }
-
-        # Emit immediately for real-time responsiveness
-        if is_final:
-            self._emit_transcript_event(transcript_text, self._current_user, metadata)
-        else:
-            self._emit_partial_transcript_event(
-                transcript_text, self._current_user, metadata
-            )
-
-        logger.debug(
-            "Received transcript",
-            extra={
-                "is_final": is_final,
-                "text_length": len(transcript_text),
-                "confidence": metadata["confidence"],
-            },
-        )
-
-    async def _on_connection_error(self, error: websockets.WebSocketException):
-        error_text = str(error) if error is not None else "Unknown error"
-        logger.error("Deepgram error received: %s", error_text)
-        # Emit error immediately
-        error_obj = Exception(f"Deepgram error: {error_text}")
-        self._emit_error_event(error_obj, "Deepgram connection")
-
-    async def _on_connection_close(self, message: Any):
-        logger.warning(f"Deepgram connection closed. message={message}")
-        await self.close()
-
-    async def _process_audio_impl(
-        self,
-        pcm_data: PcmData,
-        user_metadata: Optional[Union[Dict[str, Any], "Participant"]] = None,
-    ) -> Optional[List[Tuple[bool, str, Dict[str, Any]]]]:
-        """
-        Process audio data through Deepgram for transcription.
-
-        Args:
-            pcm_data: The PCM audio data to process.
-            user_metadata: Additional metadata about the user or session.
-
-        Returns:
-            None - Deepgram operates in asynchronous mode and emits events directly
-            when transcripts arrive from the streaming service.
-        """
-        if self._is_closed:
-            logger.warning("Deepgram connection is closed, ignoring audio")
-            return None
-
-        # Store the current user context for transcript events
-        self._current_user = user_metadata  # type: ignore[assignment]
-
-        # Check if the input sample rate matches the expected sample rate
-        if pcm_data.sample_rate != self.sample_rate:
-            logger.warning(
-                "Input audio sample rate (%s Hz) does not match the expected sample rate (%s Hz). "
-                "This may result in incorrect transcriptions. Consider resampling the audio.",
-                pcm_data.sample_rate,
-                self.sample_rate,
-            )
-
-        # Convert PCM data to bytes if needed
-        audio_data = pcm_data.samples
-        if not isinstance(audio_data, bytes):
-            # Convert numpy array to bytes
-            audio_data = audio_data.astype(np.int16).tobytes()
-
-        # Wait for the attempt to establish the connection
-        try:
-            await self.started()
-        except asyncio.TimeoutError:
-            logger.error(
-                f"Deepgram connection is not established within {self._connection_timeout} seconds. "
-                f"Skipping the audio package."
-            )
-            return None
-
-        # Send the audio data to Deepgram
-        logger.debug(
-            "Sending audio data to Deepgram",
-            extra={"audio_bytes": len(audio_data)},
-        )
-        await self._send_audio(audio_data)
-        return None
-
-    async def _send_audio(self, data: bytes):
-        if self.dg_connection is None:
-            logger.warning("Deepgram connection is not established")
-            return
-
-        try:
-            await self.dg_connection.send_media(data)
-            self._last_sent_at = time.time()
-        except Exception as e:
-            # Raise exception to be handled by base class
-            raise Exception(f"Deepgram audio transmission error: {e}") from e
-
-    async def _keepalive_loop(self):
-        """
-        Send the silence audio every `interval` seconds
-        to prevent Deepgram from closing the connection.
-        """
-        while not self._is_closed and self.dg_connection is not None:
-            if self._last_sent_at + self._keep_alive_interval <= time.time():
-                logger.debug("Sending keepalive packet to Deepgram...")
-                # Send audio silence to keep the connection open
-                await self._send_audio(self._keep_alive_data)
-                # Send keep-alive message as well
-                await self.dg_connection.send_control(
-                    ListenV1ControlMessage(type="KeepAlive")
-                )
-
-            # Sleep max for 1s to avoid missing the keep-alive schedule
-            timeout = min(self._keep_alive_interval, 1.0)
-            await asyncio.sleep(timeout)

vision_agents_plugins_deepgram-0.1.9/vision_agents/plugins/deepgram/utils.py

@@ -1,18 +0,0 @@
-import numpy as np
-
-
-def generate_silence(sample_rate: int, duration_ms: int) -> bytes:
-    """
-    Generate a silence of the given sample_rate and duration_ms.
-    """
-    # Audio parameters
-    channels = 1
-    sample_format = np.int16  # 16-bit signed PCM
-
-    # Number of samples = sample_rate * duration_seconds
-    num_samples = int(sample_rate * (duration_ms / 1000.0))
-
-    # Create silence raw bytes (s16 mono PCM)
-    pcm_bytes = np.zeros((num_samples, channels), dtype=sample_format).tobytes()
-    return pcm_bytes
-