rasa-pro 3.13.11__py3-none-any.whl → 3.14.0__py3-none-any.whl

rasa/core/channels/voice_stream/genesys.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import asyncio
 import base64
 import hashlib
@@ -21,6 +23,7 @@ from rasa.core.channels.voice_stream.call_state import (
     call_state,
 )
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
+from rasa.core.channels.voice_stream.util import repack_voice_credentials
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,
@@ -54,7 +57,7 @@ logger = structlog.get_logger(__name__)
 
 
 def map_call_params(data: Dict[Text, Any]) -> CallParameters:
-    """Map the twilio stream parameters to the CallParameters dataclass."""
+    """Map the Genesys parameters to the CallParameters dataclass."""
     parameters = data["parameters"]
     participant = parameters["participant"]
     # sent as {"ani": "tel:+491604697810"}
@@ -96,10 +99,11 @@ class GenesysInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, int]] = None,
         api_key: Optional[Text] = None,
         client_secret: Optional[Text] = None,
     ) -> None:
-        super().__init__(server_url, asr_config, tts_config)
+        super().__init__(server_url, asr_config, tts_config, interruptions)
         self.api_key = api_key
         self.client_secret = client_secret
 
@@ -107,7 +111,7 @@ class GenesysInputChannel(VoiceInputChannel):
     def from_credentials(
         cls,
         credentials: Optional[Dict[str, Any]],
-    ) -> "GenesysInputChannel":
+    ) -> GenesysInputChannel:
         """Create a channel from credentials dictionary.
 
         Args:
@@ -121,21 +125,21 @@ class GenesysInputChannel(VoiceInputChannel):
         Returns:
             GenesysInputChannel instance
         """
-        channel = super().from_credentials(credentials)
+        cls.validate_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials)
+        return cls(**new_creds)
 
-        # Check required Genesys-specific credentials
+    @classmethod
+    def validate_credentials(cls, credentials: Optional[Dict[str, Any]]) -> None:
+        """Validate the credentials for the Genesys voice channel."""
+        cls.validate_basic_credentials(credentials)
         if not credentials.get("api_key"):  # type: ignore[union-attr]
             raise InvalidConfigException(
                 "No API key given for Genesys voice channel (api_key)."
             )
 
-        # Update channel with Genesys-specific credentials
-        channel.api_key = credentials["api_key"]  # type: ignore[index,attr-defined]
-        channel.client_secret = credentials.get("client_secret")  # type: ignore[union-attr,attr-defined]
-
-        return channel  # type: ignore[return-value]
-
-    def _ensure_channel_data_initialized(self) -> None:
+    @staticmethod
+    def _ensure_channel_data_initialized() -> None:
         """Initialize Genesys-specific channel data if not already present.
 
         Genesys requires the server and client each maintain a
@@ -216,10 +220,10 @@ class GenesysInputChannel(VoiceInputChannel):
                 self.handle_ping(ws, data)
             elif msg_type == "playback_started":
                 logger.debug("genesys.handle_playback_started", message=data)
-                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = True
             elif msg_type == "playback_completed":
                 logger.debug("genesys.handle_playback_completed", message=data)
-                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = False
                 if call_state.should_hangup:
                     logger.info("genesys.hangup")
                     self.disconnect(ws, data)
@@ -271,7 +275,7 @@ class GenesysInputChannel(VoiceInputChannel):
 
     def handle_ping(self, ws: Websocket, message: dict) -> None:
         """Handle ping message from Genesys."""
-        response = {
+        response: Dict[str, Any] = {
             "version": "2",
             "type": "pong",
             "seq": self._get_next_sequence(),

rasa/core/channels/voice_stream/jambonz.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import audioop
 import json
 import uuid
@@ -20,6 +22,7 @@ from rasa.core.channels.voice_ready.utils import (
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import call_state
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
+from rasa.core.channels.voice_stream.util import repack_voice_credentials
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,
@@ -35,7 +38,7 @@ JAMBONZ_STREAMS_WEBSOCKET_PATH = "webhooks/jambonz_stream/websocket"
 
 
 def map_call_params(data: Dict[Text, str]) -> CallParameters:
-    """Map the twilio stream parameters to the CallParameters dataclass."""
+    """Map the Jambonz stream parameters to the CallParameters dataclass."""
     call_sid = data.get("callSid", "None")
     from_number = data.get("from", "Unknown")
     to_number = data.get("to")
@@ -78,6 +81,7 @@ class JambonzStreamInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, int]] = None,
         username: Optional[Text] = None,
         password: Optional[Text] = None,
     ) -> None:
@@ -87,14 +91,14 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             username: Optional username for basic auth
             password: Optional password for basic auth
         """
-        super().__init__(server_url, asr_config, tts_config)
+        super().__init__(server_url, asr_config, tts_config, interruptions)
         self.username = username
         self.password = password
 
     @classmethod
     def from_credentials(
         cls, credentials: Optional[Dict[Text, Any]]
-    ) -> "JambonzStreamInputChannel":
+    ) -> JambonzStreamInputChannel:
         """Create a channel from credentials dictionary.
 
         Args:
@@ -109,19 +113,18 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             JambonzStreamInputChannel instance
         """
         # Get common credentials from parent
-        channel = super().from_credentials(credentials)
+        cls.validate_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials)
+        return cls(**new_creds)
 
+    @classmethod
+    def validate_credentials(cls, credentials: Optional[Dict[Text, Any]]) -> None:
+        cls.validate_basic_credentials(credentials)
         # Check optional basic auth credentials
         username = credentials.get("username")  # type: ignore[union-attr]
         password = credentials.get("password")  # type: ignore[union-attr]
         validate_username_password_credentials(username, password, "Jambonz Stream")
 
-        # Update channel with auth credentials
-        channel.username = username  # type: ignore[attr-defined]
-        channel.password = password  # type: ignore[attr-defined]
-
-        return channel  # type: ignore[return-value]
-
     def _websocket_stream_url(self) -> str:
         """Returns the websocket stream URL."""
         # depending on the config value, the url might contain http as a
@@ -158,14 +161,14 @@ class JambonzStreamInputChannel(VoiceInputChannel):
         if data["type"] == "mark":
             if data["data"]["name"] == call_state.latest_bot_audio_id:
                 # Just finished streaming last audio bytes
-                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = False
                 if call_state.should_hangup:
                     logger.debug(
                         "jambonz.hangup", marker=call_state.latest_bot_audio_id
                     )
                     return EndConversationAction()
             else:
-                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = True
         elif data["event"] == "dtmf":
             # TODO: handle DTMF input
             logger.debug("jambonz.dtmf.received", dtmf=data["dtmf"])
@@ -183,6 +186,13 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
+    async def interrupt_playback(
+        self, ws: Websocket, call_parameters: CallParameters
+    ) -> None:
+        """Interrupt the current playback of audio."""
+        logger.debug("jambonz.interrupt_playback")
+        await ws.send(json.dumps({"type": "killAudio"}))
+
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:

rasa/core/channels/voice_stream/tts/deepgram.py

@@ -0,0 +1,140 @@
+import os
+from dataclasses import dataclass
+from typing import AsyncIterator, Dict, Optional
+from urllib.parse import urlencode
+
+import aiohttp
+import orjson
+import structlog
+from aiohttp import ClientConnectorError, ClientTimeout, WSMsgType
+
+from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
+from rasa.core.channels.voice_stream.tts.tts_engine import (
+    TTSEngine,
+    TTSEngineConfig,
+    TTSError,
+)
+from rasa.shared.constants import DEEPGRAM_API_KEY_ENV_VAR
+from rasa.shared.exceptions import ConnectionException
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class DeepgramTTSConfig(TTSEngineConfig):
+    model_id: Optional[str] = None
+    endpoint: Optional[str] = None
+
+
+class DeepgramTTS(TTSEngine[DeepgramTTSConfig]):
+    session: Optional[aiohttp.ClientSession] = None
+    required_env_vars = (DEEPGRAM_API_KEY_ENV_VAR,)
+    ws: Optional[aiohttp.ClientWebSocketResponse] = None
+
+    def __init__(self, config: Optional[DeepgramTTSConfig] = None):
+        super().__init__(config)
+        timeout = ClientTimeout(total=self.config.timeout)
+        # Have to create this class-shared session lazily at run time otherwise
+        # the async event loop doesn't work
+        if self.__class__.session is None or self.__class__.session.closed:
+            self.__class__.session = aiohttp.ClientSession(timeout=timeout)
+
+    @staticmethod
+    def get_request_headers(config: DeepgramTTSConfig) -> dict[str, str]:
+        deepgram_api_key = os.environ[DEEPGRAM_API_KEY_ENV_VAR]
+        return {
+            "Authorization": f"Token {deepgram_api_key!s}",
+        }
+
+    async def close_connection(self) -> None:
+        """Close WebSocket connection if it exists."""
+        if self.ws and not self.ws.closed:
+            await self.ws.close()
+            self.ws = None
+
+    def get_websocket_url(self, config: DeepgramTTSConfig) -> str:
+        """Build WebSocket URL with query parameters."""
+        base_url = config.endpoint
+        query_params = {
+            "model": config.model_id,
+            "encoding": "mulaw",
+            "sample_rate": "8000",
+        }
+        return f"{base_url}?{urlencode(query_params)}"
+
+    async def synthesize(
+        self, text: str, config: Optional[DeepgramTTSConfig] = None
+    ) -> AsyncIterator[RasaAudioBytes]:
+        """Generate speech from text using Deepgram WebSocket TTS API."""
+        config = self.config.merge(config)
+        headers = self.get_request_headers(config)
+        ws_url = self.get_websocket_url(config)
+
+        if self.session is None:
+            raise ConnectionException("Client session is not initialized")
+
+        try:
+            self.ws = await self.session.ws_connect(
+                ws_url,
+                headers=headers,
+                timeout=float(self.config.timeout),
+            )
+            await self.ws.send_json(
+                {
+                    "type": "Speak",
+                    "text": text,
+                }
+            )
+            await self.ws.send_json({"type": "Flush"})
+            async for msg in self.ws:
+                if msg.type == WSMsgType.BINARY:
+                    # Binary data is the raw audio
+                    yield self.engine_bytes_to_rasa_audio_bytes(msg.data)
+                elif msg.type == WSMsgType.TEXT:
+                    # Handle control messages if needed
+                    data = orjson.loads(msg.data)
+                    if data.get("type") == "Close":
+                        break
+                    elif data.get("type") == "Flushed":
+                        break  # End of stream
+                elif msg.type == WSMsgType.CLOSED:
+                    break
+                elif msg.type == WSMsgType.ERROR:
+                    structlogger.error(
+                        "deepgram.synthesize.ws.error", error=str(msg.data)
+                    )
+                    raise TTSError(f"WebSocket error: {msg.data}")
+
+            # Send a close message
+            if self.ws and not self.ws.closed:
+                await self.ws.send_json({"type": "Close"})
+
+        except ClientConnectorError as e:
+            structlogger.error("deepgram.synthesize.ws.connection_error", error=str(e))
+            raise TTSError(f"Failed to connect to Deepgram TTS service: {e}")
+        except TimeoutError as e:
+            structlogger.error("deepgram.synthesize.ws.timeout", error=str(e))
+            raise TTSError(f"Connection to Deepgram TTS service timed out: {e}")
+        except Exception as e:
+            structlogger.error("deepgram.synthesize.ws.error", error=str(e))
+            raise TTSError(f"Error during TTS synthesis: {e}")
+        finally:
+            # Ensure connection is closed
+            await self.close_connection()
+
+    def engine_bytes_to_rasa_audio_bytes(self, chunk: bytes) -> RasaAudioBytes:
+        """Convert the generated tts audio bytes into rasa audio bytes."""
+        # WebSocket returns raw audio bytes directly
+        return RasaAudioBytes(chunk)
+
+    @staticmethod
+    def get_default_config() -> DeepgramTTSConfig:
+        return DeepgramTTSConfig(
+            model_id="aura-2-andromeda-en",
+            endpoint="wss://api.deepgram.com/v1/speak",
+            timeout=30,
+        )
+
+    @classmethod
+    def from_config_dict(cls, config: Dict) -> "DeepgramTTS":
+        return cls(DeepgramTTSConfig.from_dict(config))

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -14,6 +14,9 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
+# Import twilio at module level to raise error if not installed
+from twilio.twiml.voice_response import VoiceResponse
+
 from rasa.core.channels import UserMessage
 from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
@@ -26,6 +29,7 @@ from rasa.core.channels.voice_ready.utils import (
 from rasa.core.channels.voice_stream.audio_bytes import RasaAudioBytes
 from rasa.core.channels.voice_stream.call_state import call_state
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine
+from rasa.core.channels.voice_stream.util import repack_voice_credentials
 from rasa.core.channels.voice_stream.voice_channel import (
     ContinueConversationAction,
     EndConversationAction,
@@ -104,6 +108,7 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        interruptions: Optional[Dict[str, int]] = None,
         username: Optional[Text] = None,
         password: Optional[Text] = None,
     ):
@@ -111,6 +116,7 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             server_url=server_url,
             asr_config=asr_config,
             tts_config=tts_config,
+            interruptions=interruptions,
         )
         self.username = username
         self.password = password
@@ -120,20 +126,20 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         cls,
         credentials: Optional[Dict[str, Any]],
     ) -> VoiceInputChannel:
-        credentials = credentials or {}
+        cls.validate_credentials(credentials)
+        new_creds = repack_voice_credentials(credentials)
+        return cls(**new_creds)
 
-        username = credentials.get("username")
-        password = credentials.get("password")
+    @classmethod
+    def validate_credentials(
+        cls,
+        credentials: Optional[Dict[str, Any]],
+    ) -> None:
+        cls.validate_basic_credentials(credentials)
+        username = credentials.get("username") if credentials else None
+        password = credentials.get("password") if credentials else None
         validate_username_password_credentials(username, password, "TwilioMediaStreams")
 
-        return cls(
-            credentials["server_url"],
-            credentials["asr"],
-            credentials["tts"],
-            username=username,
-            password=password,
-        )
-
     @classmethod
     def name(cls) -> str:
         return "twilio_media_streams"
@@ -142,7 +148,8 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         """Get the sender ID for the channel.
 
         Twilio Media Streams uses the Stream ID as Sender ID because
-        it is required in OutputChannel.send_text_message to send messages."""
+        it is required in OutputChannel.send_text_message to send messages.
+        """
         return call_parameters.stream_id  # type: ignore[return-value]
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
@@ -175,14 +182,14 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
         elif data["event"] == "mark":
             if data["mark"]["name"] == call_state.latest_bot_audio_id:
                 # Just finished streaming last audio bytes
-                call_state.is_bot_speaking = False  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = False
                 if call_state.should_hangup:
                     logger.debug(
                         "twilio_streams.hangup", marker=call_state.latest_bot_audio_id
                     )
                     return EndConversationAction()
             else:
-                call_state.is_bot_speaking = True  # type: ignore[attr-defined]
+                call_state.is_bot_speaking = True
         return ContinueConversationAction()
 
     def create_output_channel(
@@ -194,6 +201,20 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
             self.tts_cache,
         )
 
+    async def interrupt_playback(
+        self, ws: Websocket, call_parameters: CallParameters
+    ) -> None:
+        """Interrupt the current playback of audio."""
+        logger.debug("twilio_media_streams.interrupt_playback")
+        await ws.send(
+            json.dumps(
+                {
+                    "event": "clear",
+                    "streamSid": call_parameters.stream_id,
+                }
+            )
+        )
+
     def blueprint(
         self, on_new_message: Callable[[UserMessage], Awaitable[Any]]
     ) -> Blueprint:

rasa/core/channels/voice_stream/util.py

@@ -1,7 +1,7 @@
 import audioop
 import wave
 from dataclasses import asdict, dataclass
-from typing import Optional, Type, TypeVar
+from typing import Dict, Optional, Type, TypeVar
 
 import structlog
 
@@ -55,3 +55,13 @@ class MergeableConfig:
     @classmethod
     def from_dict(cls: Type[T], data: dict[str, Optional[str]]) -> T:
         return cls(**data)
+
+
+def repack_voice_credentials(
+    credentials: Dict[str, str],
+) -> Dict[str, str]:
+    """Repack voice credentials to ensure they are in the correct format."""
+    new_creds = {**credentials}
+    new_creds["asr_config"] = new_creds.pop("asr", None)
+    new_creds["tts_config"] = new_creds.pop("tts", None)
+    return new_creds