rasa-pro 3.13.0rc1__py3-none-any.whl → 3.13.0rc3__py3-none-any.whl

rasa/cli/studio/link.py

@@ -2,15 +2,8 @@ import argparse
 from typing import List, Text
 
 from rasa.cli import SubParsersAction
-from rasa.cli.arguments.default_arguments import (
-    add_config_param,
-    add_data_param,
-    add_domain_param,
-    add_endpoint_param,
-)
 from rasa.shared.constants import (
     DEFAULT_DOMAIN_PATH,
-    DEFAULT_ENDPOINTS_PATH,
 )
 from rasa.studio.link import handle_link
 
@@ -40,13 +33,4 @@ def add_subparser(
         type=str,
         help="Name of the assistant in Rasa Studio.",
     )
-
-    add_domain_param(link_parser, domain)
-    add_data_param(link_parser)
-    add_config_param(link_parser)
-    add_endpoint_param(
-        link_parser,
-        "Configuration file for the model endpoints.",
-        default=DEFAULT_ENDPOINTS_PATH,
-    )
     link_parser.set_defaults(func=handle_link)

rasa/cli/studio/train.py

@@ -20,10 +20,7 @@ def add_subparser(
         parents=parents,
         conflict_handler="resolve",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-        help=(
-            "Trains a Rasa model using Rasa Studio "
-            "data and your NLU data and stories."
-        ),
+        help="Trains a Rasa model using Rasa Studio data.",
     )
 
     train_parser.set_defaults(func=handle_train)

rasa/cli/studio/upload.py

@@ -25,7 +25,7 @@ def add_subparser(
         parents=parents,
         conflict_handler="resolve",
         formatter_class=argparse.ArgumentDefaultsHelpFormatter,
-        help="Upload primitives to Rasa Studio. Only works with NLU assistants.",
+        help="Upload primitives to Rasa Studio.",
     )
 
     upload_parser.set_defaults(func=handle_upload)

rasa/core/agent.py

@@ -238,9 +238,15 @@ async def load_agent(
         if endpoints.nlu:
             http_interpreter = RasaNLUHttpInterpreter(endpoints.nlu)
         if endpoints.privacy:
+            in_memory_tracker_store = (
+                tracker_store
+                if isinstance(tracker_store, InMemoryTrackerStore)
+                else None
+            )
             privacy_manager = await BackgroundPrivacyManager.create_instance(
                 endpoints=endpoints,
                 event_loop=loop,
+                in_memory_tracker_store=in_memory_tracker_store,
             )
             track_privacy_enabled(privacy_manager.config, broker)
 

rasa/core/channels/__init__.py

@@ -6,6 +6,7 @@ from rasa.core.channels.channel import (  # noqa: F401
     OutputChannel,
     UserMessage,
     CollectingOutputChannel,
+    requires_basic_auth,
 )
 
 # this prevents IDE's from optimizing the imports - we need to import the

rasa/core/channels/voice_ready/jambonz.py

@@ -17,7 +17,10 @@ from rasa.core.channels.voice_ready.jambonz_protocol import (
     send_ws_text_message,
     websocket_message_handler,
 )
-from rasa.core.channels.voice_ready.utils import validate_voice_license_scope
+from rasa.core.channels.voice_ready.utils import (
+    validate_username_password_credentials,
+    validate_voice_license_scope,
+)
 from rasa.shared.exceptions import RasaException
 from rasa.shared.utils.common import mark_as_beta_feature
 from rasa.utils.io import remove_emojis
@@ -41,11 +44,7 @@ class JambonzVoiceReadyInput(InputChannel):
 
         username = credentials.get("username")
         password = credentials.get("password")
-        if (username is None) != (password is None):
-            raise RasaException(
-                "In Jambonz channel, either both username and password "
-                "or neither should be provided. "
-            )
+        validate_username_password_credentials(username, password, "Jambonz")
 
         return cls(username, password)
 

rasa/core/channels/voice_ready/twilio_voice.py

@@ -16,9 +16,12 @@ from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
     requires_basic_auth,
 )
-from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_ready.utils import (
+    CallParameters,
+    validate_username_password_credentials,
+)
 from rasa.shared.core.events import BotUttered
-from rasa.shared.exceptions import InvalidConfigException, RasaException
+from rasa.shared.exceptions import InvalidConfigException
 
 logger = structlog.get_logger(__name__)
 
@@ -127,11 +130,7 @@ class TwilioVoiceInput(InputChannel):
 
         username = credentials.get("username")
         password = credentials.get("password")
-        if (username is None) != (password is None):
-            raise RasaException(
-                "In TwilioVoice channel, either both username and password "
-                "or neither should be provided. "
-            )
+        validate_username_password_credentials(username, password, "TwilioVoice")
 
         return cls(
             credentials.get(
@@ -180,8 +179,9 @@ class TwilioVoiceInput(InputChannel):
         if self.assistant_voice not in self.SUPPORTED_VOICES:
             self._raise_invalid_voice_exception()
 
-        if (self.username is None) != (self.password is None):
-            self._raise_invalid_credentials_exception()
+        validate_username_password_credentials(
+            self.username, self.password, "TwilioVoice"
+        )
 
         try:
             int(self.speech_timeout)
@@ -389,9 +389,10 @@ class TwilioVoiceInput(InputChannel):
         return voice_response
 
     def _raise_invalid_credentials_exception(self) -> None:
-        raise InvalidConfigException(
-            "In TwilioVoice channel, either both username and password "
-            "or neither should be provided. "
+        # This method is now redundant since we use the shared validation function
+        # but keeping it for backward compatibility if any external code calls it
+        validate_username_password_credentials(
+            self.username, self.password, "TwilioVoice"
         )
 
 

rasa/core/channels/voice_ready/utils.py

@@ -3,9 +3,31 @@ from typing import Optional
 
 import structlog
 
+from rasa.shared.exceptions import InvalidConfigException
+
 structlogger = structlog.get_logger()
 
 
+def validate_username_password_credentials(
+    username: Optional[str], password: Optional[str], channel_name: str
+) -> None:
+    """Validate that username and password are both provided or both None.
+
+    Args:
+        username: The username credential, or None
+        password: The password credential, or None
+        channel_name: The name of the channel for error message
+
+    Raises:
+        InvalidConfigException: If only one of username/password is provided
+    """
+    if (not username) != (not password):
+        raise InvalidConfigException(
+            f"In {channel_name} channel, either both username and password "
+            "or neither should be provided."
+        )
+
+
 def validate_voice_license_scope() -> None:
     from rasa.utils.licensing import (
         PRODUCT_AREA,

rasa/core/channels/voice_stream/audiocodes.py

@@ -104,10 +104,10 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
 
     def __init__(
         self,
-        token: Optional[Text],
         server_url: str,
         asr_config: Dict,
         tts_config: Dict,
+        token: Optional[Text] = None,
     ):
         mark_as_beta_feature("Audiocodes (audiocodes_stream) Channel")
         super().__init__(
@@ -121,16 +121,10 @@ class AudiocodesVoiceInputChannel(VoiceInputChannel):
     def from_credentials(
         cls,
         credentials: Optional[Dict[str, Any]],
-    ) -> VoiceInputChannel:
-        if not credentials:
-            raise ValueError("No credentials given for Audiocodes voice channel.")
-
-        return cls(
-            token=credentials.get("token"),
-            server_url=credentials["server_url"],
-            asr_config=credentials["asr"],
-            tts_config=credentials["tts"],
-        )
+    ) -> "AudiocodesVoiceInputChannel":
+        channel = super().from_credentials(credentials)
+        channel.token = credentials.get("token")  # type: ignore[attr-defined, union-attr]
+        return channel  # type: ignore[return-value]
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         return RasaAudioBytes(base64.b64decode(input_bytes))

rasa/core/channels/voice_stream/genesys.py

@@ -29,6 +29,7 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
+from rasa.shared.exceptions import InvalidConfigException
 
 """
 Genesys throws a rate limit error with too many audio messages.
@@ -91,9 +92,14 @@ class GenesysInputChannel(VoiceInputChannel):
         return "genesys"
 
     def __init__(
-        self, api_key: Text, client_secret: Optional[Text], *args: Any, **kwargs: Any
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        api_key: Optional[Text] = None,
+        client_secret: Optional[Text] = None,
     ) -> None:
-        super().__init__(*args, **kwargs)
+        super().__init__(server_url, asr_config, tts_config)
         self.api_key = api_key
         self.client_secret = client_secret
 
@@ -101,20 +107,33 @@ class GenesysInputChannel(VoiceInputChannel):
     def from_credentials(
         cls,
         credentials: Optional[Dict[str, Any]],
-    ) -> VoiceInputChannel:
-        if not credentials:
-            raise ValueError("No credentials given for Genesys voice channel.")
-
-        if not credentials.get("api_key"):
-            raise ValueError("No API key given for Genesys voice channel (api_key).")
-
-        return cls(
-            api_key=credentials["api_key"],
-            client_secret=credentials.get("client_secret"),
-            server_url=credentials["server_url"],
-            asr_config=credentials["asr"],
-            tts_config=credentials["tts"],
-        )
+    ) -> "GenesysInputChannel":
+        """Create a channel from credentials dictionary.
+
+        Args:
+            credentials: Dictionary containing the required credentials:
+                - server_url: URL where the server is hosted
+                - asr: ASR engine configuration
+                - tts: TTS engine configuration
+                - api_key: Required API key for Genesys authentication
+                - client_secret: Optional client secret for signature verification
+
+        Returns:
+            GenesysInputChannel instance
+        """
+        channel = super().from_credentials(credentials)
+
+        # Check required Genesys-specific 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:
         """Initialize Genesys-specific channel data if not already present.

rasa/core/channels/voice_stream/jambonz.py

@@ -12,8 +12,11 @@ from sanic import (  # type: ignore[attr-defined]
     response,
 )
 
-from rasa.core.channels import UserMessage
-from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels import UserMessage, requires_basic_auth
+from rasa.core.channels.voice_ready.utils import (
+    CallParameters,
+    validate_username_password_credentials,
+)
 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
@@ -28,6 +31,8 @@ from rasa.core.channels.voice_stream.voice_channel import (
 
 logger = structlog.get_logger()
 
+JAMBONZ_STREAMS_WEBSOCKET_PATH = "webhooks/jambonz_streams/websocket"
+
 
 def map_call_params(data: Dict[Text, str]) -> CallParameters:
     """Map the twilio stream parameters to the CallParameters dataclass."""
@@ -68,6 +73,65 @@ class JambonzStreamInputChannel(VoiceInputChannel):
     def name(cls) -> str:
         return "jambonz_stream"
 
+    def __init__(
+        self,
+        server_url: str,
+        asr_config: Dict,
+        tts_config: Dict,
+        username: Optional[Text] = None,
+        password: Optional[Text] = None,
+    ) -> None:
+        """Initialize the channel.
+
+        Args:
+            username: Optional username for basic auth
+            password: Optional password for basic auth
+        """
+        super().__init__(server_url, asr_config, tts_config)
+        self.username = username
+        self.password = password
+
+    @classmethod
+    def from_credentials(
+        cls, credentials: Optional[Dict[Text, Any]]
+    ) -> "JambonzStreamInputChannel":
+        """Create a channel from credentials dictionary.
+
+        Args:
+            credentials: Dictionary containing the required credentials:
+                - server_url: URL where the server is hosted
+                - asr: ASR engine configuration
+                - tts: TTS engine configuration
+                - username: Optional username for basic auth
+                - password: Optional password for basic auth
+
+        Returns:
+            JambonzStreamInputChannel instance
+        """
+        # Get common credentials from parent
+        channel = super().from_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
+        # protocol or not - we'll make sure both work
+        if self.server_url.startswith("http"):
+            base_url = self.server_url.replace("http", "ws")
+        else:
+            base_url = f"wss://{self.server_url}"
+        return f"{base_url}/{JAMBONZ_STREAMS_WEBSOCKET_PATH}"
+
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes:
         """Convert Jambonz audio bytes (L16 PCM) to Rasa audio bytes (μ-law)."""
         ulaw = audioop.lin2ulaw(input_bytes, 2)
@@ -129,6 +193,7 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             return response.json({"status": "ok"})
 
         @blueprint.route("/call_status", methods=["POST"])
+        @requires_basic_auth(self.username, self.password)
         async def call_status(request: Request) -> HTTPResponse:
             """Handle call status updates from Jambonz."""
             data = request.json
@@ -136,6 +201,7 @@ class JambonzStreamInputChannel(VoiceInputChannel):
             return response.json({"status": "ok"})
 
         @blueprint.route("/webhook", methods=["POST"])
+        @requires_basic_auth(self.username, self.password)
         async def webhook(request: Request) -> HTTPResponse:
             """Handle incoming webhook requests from Jambonz."""
             data = request.json
@@ -144,7 +210,7 @@ class JambonzStreamInputChannel(VoiceInputChannel):
                 [
                     {
                         "verb": "listen",
-                        "url": f"wss://{self.server_url}/webhooks/jambonz_stream/websocket",
+                        "url": self._websocket_stream_url(),
                         "sampleRate": 8000,
                         "passDtmf": True,
                         "bidirectionalAudio": {

rasa/core/channels/voice_stream/twilio_media_streams.py

@@ -19,7 +19,10 @@ from rasa.core.channels.channel import (
     create_auth_requested_response_provider,
     requires_basic_auth,
 )
-from rasa.core.channels.voice_ready.utils import CallParameters
+from rasa.core.channels.voice_ready.utils import (
+    CallParameters,
+    validate_username_password_credentials,
+)
 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
@@ -31,7 +34,6 @@ from rasa.core.channels.voice_stream.voice_channel import (
     VoiceInputChannel,
     VoiceOutputChannel,
 )
-from rasa.shared.exceptions import RasaException
 
 if TYPE_CHECKING:
     from twilio.twiml.voice_response import VoiceResponse
@@ -122,11 +124,7 @@ class TwilioMediaStreamsInputChannel(VoiceInputChannel):
 
         username = credentials.get("username")
         password = credentials.get("password")
-        if (username is None) != (password is None):
-            raise RasaException(
-                "In TwilioMediaStreams channel, either both username and password "
-                "or neither should be provided. "
-            )
+        validate_username_password_credentials(username, password, "TwilioMediaStreams")
 
         return cls(
             credentials["server_url"],

rasa/core/channels/voice_stream/voice_channel.py

@@ -35,7 +35,7 @@ from rasa.core.channels.voice_stream.util import (
     generate_silence,
 )
 from rasa.shared.core.constants import SILENCE_TIMEOUT_SLOT
-from rasa.shared.utils.cli import print_error_and_exit
+from rasa.shared.exceptions import InvalidConfigException
 from rasa.shared.utils.common import (
     class_from_module_path,
     mark_as_beta_feature,
@@ -71,6 +71,14 @@ class ContinueConversationAction(VoiceChannelAction):
 
 
 def asr_engine_from_config(asr_config: Dict) -> ASREngine:
+    if not asr_config:
+        raise ValueError("ASR configuration dictionary cannot be empty")
+
+    if "name" not in asr_config:
+        raise ValueError(
+            "ASR configuration must contain 'name' key specifying the engine type"
+        )
+
     name = str(asr_config["name"])
     asr_config = copy.copy(asr_config)
     asr_config.pop("name")
@@ -84,12 +92,12 @@ def asr_engine_from_config(asr_config: Dict) -> ASREngine:
             asr_engine_class = class_from_module_path(name)
             return asr_engine_class.from_config_dict(asr_config)
         except NameError:
-            print_error_and_exit(
+            raise InvalidConfigException(
                 f"Failed to initialize ASR Engine with type '{name}'. "
                 f"Please make sure the method `from_config_dict`is implemented."
             )
         except TypeError as e:
-            print_error_and_exit(
+            raise InvalidConfigException(
                 f"Failed to initialize ASR Engine with type '{name}'. "
                 f"Invalid configuration provided. "
                 f"Error: {e}"
@@ -97,6 +105,14 @@ def asr_engine_from_config(asr_config: Dict) -> ASREngine:
 
 
 def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
+    if not tts_config:
+        raise ValueError("TTS configuration dictionary cannot be empty")
+
+    if "name" not in tts_config:
+        raise ValueError(
+            "TTS configuration must contain 'name' key specifying the engine type"
+        )
+
     name = str(tts_config["name"])
     tts_config = copy.copy(tts_config)
     tts_config.pop("name")
@@ -110,13 +126,13 @@ def tts_engine_from_config(tts_config: Dict) -> TTSEngine:
             tts_engine_class = class_from_module_path(name)
             return tts_engine_class.from_config_dict(tts_config)
         except NameError:
-            print_error_and_exit(
+            raise InvalidConfigException(
                 f"Failed to initialize TTS Engine with type '{name}'. "
                 f"Please make sure the method `from_config_dict`is implemented."
             )
         except TypeError as e:
-            print_error_and_exit(
-                f"Failed to initialize ASR Engine with type '{name}'. "
+            raise InvalidConfigException(
+                f"Failed to initialize TTS Engine with type '{name}'. "
                 f"Invalid configuration provided. "
                 f"Error: {e}"
             )
@@ -336,11 +352,24 @@ class VoiceInputChannel(InputChannel):
         cls,
         credentials: Optional[Dict[str, Any]],
     ) -> InputChannel:
-        credentials = credentials or {}
+        if not credentials:
+            cls.raise_missing_credentials_exception()
+
+        if not credentials.get("server_url"):
+            raise InvalidConfigException("No server_url provided in credentials.")
+        if not credentials.get("asr"):
+            raise InvalidConfigException(
+                "No ASR configuration provided in credentials."
+            )
+        if not credentials.get("tts"):
+            raise InvalidConfigException(
+                "No TTS configuration provided in credentials."
+            )
+
         return cls(
-            credentials["server_url"],
-            credentials["asr"],
-            credentials["tts"],
+            server_url=credentials["server_url"],
+            asr_config=credentials["asr"],
+            tts_config=credentials["tts"],
         )
 
     def channel_bytes_to_rasa_audio_bytes(self, input_bytes: bytes) -> RasaAudioBytes: