rasa-pro 3.14.0.dev20250922__py3-none-any.whl → 3.14.0rc2__py3-none-any.whl

rasa/core/channels/studio_chat.py

@@ -93,12 +93,12 @@ class StudioTrackerUpdatePlugin:
         """Remove tasks that have already completed."""
         self.tasks = [task for task in self.tasks if not task.done()]
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_new_user_message(self, tracker: "DialogueStateTracker") -> None:
         """Triggers a tracker update notification after a new user message."""
         self.handle_tracker_update(tracker)
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_action_executed(self, tracker: "DialogueStateTracker") -> None:
         """Triggers a tracker update notification after an action is executed."""
         self.handle_tracker_update(tracker)
@@ -118,7 +118,7 @@ class StudioTrackerUpdatePlugin:
         self.tasks.append(task)
         self._cleanup_tasks()
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_server_stop(self) -> None:
         """Cancels all remaining tasks when the server stops."""
         self._cancel_tasks()
@@ -438,7 +438,7 @@ class StudioChatInput(SocketIOInput, VoiceInputChannel):
         if sid in self.active_connections:
             del self.active_connections[sid]
 
-    @hookimpl  # type: ignore[misc]
+    @hookimpl
     def after_server_stop(self) -> None:
         """Cleanup background tasks and active connections when the server stops."""
         structlogger.info("studio_chat.after_server_stop.cleanup")
@@ -533,7 +533,7 @@ class StudioVoiceOutputChannel(VoiceOutputChannel):
 
     def create_marker_message(self, recipient_id: str) -> Tuple[str, str]:
         message_id = uuid.uuid4().hex
-        marker_data = {"marker": message_id}
+        marker_data: Dict[str, Any] = {"marker": message_id}
 
         # Include comprehensive latency information if available
         latency_data = {
@@ -548,7 +548,7 @@ class StudioVoiceOutputChannel(VoiceOutputChannel):
 
         # Add latency data to marker if any metrics are available
         if latency_data:
-            marker_data["latency"] = latency_data  # type: ignore[assignment]
+            marker_data["latency"] = latency_data
 
         return json.dumps(marker_data), message_id
 

rasa/core/channels/telegram.py

@@ -4,6 +4,9 @@ import typing
 from copy import deepcopy
 from typing import Any, Awaitable, Callable, Dict, List, Optional, Text
 
+# Import aiogram at module level to raise error if not installed
+from aiogram import Bot
+from aiogram.types import Message, Update
 from sanic import Blueprint, response
 from sanic.request import Request
 from sanic.response import HTTPResponse
@@ -28,15 +31,7 @@ class TelegramOutput(OutputChannel):
         return "telegram"
 
     def __init__(self, access_token: Optional[Text]) -> None:
-        try:
-            from aiogram import Bot
-
-            self.bot = Bot(access_token)
-        except ImportError:
-            raise ImportError(
-                "To use the Telegram channel, please install the aiogram package "
-                "with 'pip install aiogram'"
-            )
+        self.bot = Bot(access_token)
 
     async def send_text_message(
         self, recipient_id: Text, text: Text, **kwargs: Any

rasa/core/channels/voice_stream/genesys.py

@@ -275,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/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,
@@ -145,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:

rasa/core/channels/voice_stream/voice_channel.py

@@ -38,6 +38,7 @@ from rasa.core.channels.voice_stream.call_state import (
 )
 from rasa.core.channels.voice_stream.tts.azure import AzureTTS
 from rasa.core.channels.voice_stream.tts.cartesia import CartesiaTTS
+from rasa.core.channels.voice_stream.tts.deepgram import DeepgramTTS
 from rasa.core.channels.voice_stream.tts.tts_cache import TTSCache
 from rasa.core.channels.voice_stream.tts.tts_engine import TTSEngine, TTSError
 from rasa.core.channels.voice_stream.util import (
@@ -133,6 +134,8 @@ def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
         return AzureTTS.from_config_dict(tts_config)
     elif name.lower() == "cartesia":
         return CartesiaTTS.from_config_dict(tts_config)
+    elif name.lower() == "deepgram":
+        return DeepgramTTS.from_config_dict(tts_config)
     else:
         mark_as_beta_feature("Custom TTS Engine")
         try:

rasa/core/concurrent_lock_store.py

@@ -6,6 +6,9 @@ from typing import Deque, Optional, Text
 import structlog
 from pydantic import ValidationError
 
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
     DEFAULT_SOCKET_TIMEOUT_IN_SECONDS,
@@ -108,6 +111,7 @@ class ConcurrentRedisLockStore(LockStore):
             redis_config = RedisConfig(
                 host=host,
                 port=port,
+                service_type=SupportedServiceType.LOCK_STORE,
                 db=db,
                 username=username,
                 password=password,
@@ -150,32 +154,45 @@ class ConcurrentRedisLockStore(LockStore):
                 ),
             )
 
-    def _get_keys_by_pattern(self, pattern: Text) -> list:
-        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
-        if self.deployment_mode == DeploymentMode.CLUSTER.value:
-            # In cluster mode, use SCAN to get keys more reliably
-            keys = []
-            cursor = 0
-
-            while True:
-                try:
-                    cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
-                    keys.extend(batch_keys)
+    def _scan_cluster_keys(self, pattern: Text) -> list:
+        """Scan keys in cluster mode with proper cursor handling."""
+        keys = []
+        cursor = 0
+
+        while True:
+            try:
+                cursor, batch_keys = self.red.scan(cursor, match=pattern, count=100)
+                keys.extend(batch_keys)
+
+                if isinstance(cursor, dict):
+                    # cursor is a dict mapping each node to its scan position. e.g
+                    # {'127.0.0.1:7000': 0, '127.0.0.1:7001': 5, '127.0.0.1:7002': 0}
+                    # A cursor value of 0 means that node has finished scanning
+                    # When all nodes show 0, the entire cluster scan is complete
+                    if all(v == 0 for v in cursor.values()):
+                        break
+                else:
+                    # if scan is complete
                     if cursor == 0:
                         break
-                except Exception as e:
-                    structlogger.warning(
-                        "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
-                        event_info=f"SCAN interrupted in cluster mode: {e}. "
-                        f"Returning {len(keys)} keys found so far.",
-                    )
-                    break
-        else:
-            # Standard and sentinel modes use KEYS
-            keys = self.red.keys(pattern)
+
+            except Exception as e:
+                structlogger.warning(
+                    "concurrent_redis_lock_store._get_keys_by_pattern.scan_interrupted",
+                    event_info=f"SCAN interrupted in cluster mode: {e}. "
+                    f"Returning {len(keys)} keys found so far.",
+                )
+                break
 
         return keys
 
+    def _get_keys_by_pattern(self, pattern: Text) -> list:
+        """Get keys by pattern, using SCAN for cluster mode and KEYS for others."""
+        if self.deployment_mode == DeploymentMode.CLUSTER.value:
+            return self._scan_cluster_keys(pattern)
+        else:
+            return self.red.keys(pattern)
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:

rasa/core/{available_endpoints.py → config/available_endpoints.py}

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 import dataclasses
+from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-from rasa.shared.constants import DEFAULT_ENDPOINTS_PATH
+from pydantic import BaseModel, ConfigDict, Field, model_validator
+
+from rasa.core.constants import MCP_SERVERS_KEY
 from rasa.shared.core.constants import (
     GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE,
     GLOBAL_SILENCE_TIMEOUT_KEY,
@@ -57,14 +60,46 @@ class InteractionHandlingConfig:
         )
 
 
+class MCPServerConfig(BaseModel):
+    model_config = ConfigDict(extra="allow")
+    name: str = Field(..., description="The name of the MCP server.")
+    url: str = Field(..., description="The URL of the MCP server.")
+    type: str = Field(..., description="The type of the MCP server.")
+    additional_params: Optional[Dict[str, Any]] = Field(
+        default_factory=dict, description="Additional parameters for the MCP server."
+    )
+
+    @model_validator(mode="after")
+    def validate_type(self) -> MCPServerConfig:
+        # validate that type is "http"
+        if self.type not in ["http", "https"]:
+            raise ValueError(f"Invalid MCP server type: {self.type}")
+        # validate that name and url are not empty
+        if not self.name or not self.url:
+            raise ValueError("Name and URL cannot be empty")
+        return self
+
+    @model_validator(mode="before")
+    def collect_additional_params(cls, values: Dict[str, Any]) -> Dict[str, Any]:
+        base_fields = {"name", "url", "type"}
+        extras = {k: v for k, v in values.items() if k not in base_fields}
+        if extras:
+            values["additional_params"] = extras
+            # remove them from top level so Pydantic doesn’t complain
+            for k in extras:
+                values.pop(k)
+        return values
+
+
 class AvailableEndpoints:
     """Collection of configured endpoints."""
 
     _instance = None
 
     @classmethod
-    def read_endpoints(cls, endpoint_file: str) -> AvailableEndpoints:
+    def read_endpoints(cls, endpoint_file: Path) -> AvailableEndpoints:
         """Read the different endpoints from a yaml file."""
+
         nlg = read_endpoint_config(endpoint_file, endpoint_type="nlg")
         nlu = read_endpoint_config(endpoint_file, endpoint_type="nlu")
         action = read_endpoint_config(endpoint_file, endpoint_type="action_endpoint")
@@ -75,6 +110,14 @@ class AvailableEndpoints:
         lock_store = read_endpoint_config(endpoint_file, endpoint_type="lock_store")
         event_broker = read_endpoint_config(endpoint_file, endpoint_type="event_broker")
         vector_store = read_endpoint_config(endpoint_file, endpoint_type="vector_store")
+        raw_mcp_servers = read_property_config_from_endpoints_file(
+            endpoint_file, property_name=MCP_SERVERS_KEY
+        )
+        mcp_servers = (
+            [MCPServerConfig(**server) for server in raw_mcp_servers]
+            if raw_mcp_servers
+            else None
+        )
         model_groups = read_property_config_from_endpoints_file(
             endpoint_file, property_name="model_groups"
         )
@@ -89,6 +132,7 @@ class AvailableEndpoints:
         )
 
         return cls(
+            endpoint_file,
             nlg,
             nlu,
             action,
@@ -97,6 +141,7 @@ class AvailableEndpoints:
             lock_store,
             event_broker,
             vector_store,
+            mcp_servers,
             model_groups,
             privacy,
             interaction_handling,
@@ -104,6 +149,7 @@ class AvailableEndpoints:
 
     def __init__(
         self,
+        config_file_path: Optional[Path] = None,
         nlg: Optional[EndpointConfig] = None,
         nlu: Optional[EndpointConfig] = None,
         action: Optional[EndpointConfig] = None,
@@ -112,6 +158,7 @@ class AvailableEndpoints:
         lock_store: Optional[EndpointConfig] = None,
         event_broker: Optional[EndpointConfig] = None,
         vector_store: Optional[EndpointConfig] = None,
+        mcp_servers: Optional[List[MCPServerConfig]] = None,
         model_groups: Optional[List[Dict[str, Any]]] = None,
         privacy: Optional[Dict[str, Any]] = None,
         interaction_handling: InteractionHandlingConfig = InteractionHandlingConfig(
@@ -119,6 +166,7 @@ class AvailableEndpoints:
         ),
     ) -> None:
         """Create an `AvailableEndpoints` object."""
+        self.config_file_path = config_file_path
         self.model = model
         self.action = action
         self.nlu = nlu
@@ -127,20 +175,7 @@ class AvailableEndpoints:
         self.lock_store = lock_store
         self.event_broker = event_broker
         self.vector_store = vector_store
+        self.mcp_servers = mcp_servers
         self.model_groups = model_groups
         self.privacy = privacy
         self.interaction_handling = interaction_handling
-
-    @classmethod
-    def get_instance(
-        cls, endpoint_file: Optional[str] = DEFAULT_ENDPOINTS_PATH
-    ) -> AvailableEndpoints:
-        """Get the singleton instance of AvailableEndpoints."""
-        # Ensure that the instance is initialized only once.
-        if cls._instance is None:
-            cls._instance = cls.read_endpoints(endpoint_file)
-        return cls._instance
-
-    @classmethod
-    def reset_instance(cls) -> None:
-        cls._instance = None