rasa-pro 3.14.0.dev10__py3-none-any.whl → 3.14.0.dev11__py3-none-any.whl

rasa/core/actions/direct_custom_actions_executor.py

@@ -35,8 +35,6 @@ class DirectCustomActionExecutor(CustomActionExecutor):
         self.action_name = action_name
         self.action_endpoint = action_endpoint
         self.action_executor = self._create_action_executor()
-        self.register_actions_from_a_module()
-        self.action_executor.reload()
 
     @staticmethod
     @lru_cache(maxsize=1)
@@ -88,12 +86,21 @@ class DirectCustomActionExecutor(CustomActionExecutor):
 
         Returns:
             The response from the execution of the custom action.
+
+        Raises:
+            RasaException: If the actions module specified does not exist.
         """
         structlogger.debug(
             "action.direct_custom_action_executor.run",
             action_name=self.action_name,
         )
 
+        # Register actions module if not already registered.
+        # This is done here instead of __init__ to allow proper
+        # exception handling and avoid hanging conversations.
+        self.register_actions_from_a_module()
+        self.action_executor.reload()
+
         tracker_state = tracker.current_state(EventVerbosity.ALL)
         action_call = {
             "next_action": self.action_name,

rasa/core/agent.py

@@ -286,14 +286,13 @@ async def load_agent(
                 "Agent loaded with no model!"
             )
 
-        if agent.processor:
+        if agent.processor and sub_agents:
             flows = await agent.processor.get_flows()
-            domain = agent.processor.domain
             # CLI commands that accept --sub-agents
             # all route through this entry point.
             # With all required data available,
             # this is the best spot to initialize the subagents.
-            await initialize_agents(flows, domain, sub_agents)
+            await initialize_agents(flows, sub_agents)
 
         return agent
 

rasa/core/available_agents.py

@@ -117,7 +117,7 @@ class AvailableAgents(metaclass=Singleton):
             else:
                 # We are using the default folder, it may not be created yet
                 # Init with an empty agents in this case
-                structlogger.warning(
+                structlogger.info(
                     f"Default agents config folder '{agent_folder}' does not exist. "
                     f"Agent configurations won't be loaded."
                 )

rasa/core/brokers/broker.py

@@ -66,7 +66,7 @@ class EventBroker:
         raise NotImplementedError("Event broker must implement the `publish` method.")
 
     def is_ready(self) -> bool:
-        """Determine whether or not the event broker is ready.
+        """Determine whether the event broker is ready.
 
         Returns:
             `True` by default, but this may be overridden by subclasses.

rasa/core/brokers/kafka.py

@@ -6,13 +6,18 @@ import threading
 import time
 from asyncio import AbstractEventLoop
 from functools import cached_property
-from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union
+from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Tuple, Union
 
 import structlog
 
 import rasa.shared.utils.common
 from rasa.core.brokers.broker import EventBroker
 from rasa.core.exceptions import KafkaProducerInitializationError
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    IAMCredentialsProviderInput,
+    SupportedServiceType,
+    create_iam_credentials_provider,
+)
 from rasa.shared.core.events import ErrorHandled
 from rasa.shared.utils.io import DEFAULT_ENCODING
 from rasa.utils.endpoints import EndpointConfig
@@ -93,6 +98,9 @@ class KafkaEventBroker(EventBroker):
         self.ssl_keyfile = ssl_keyfile
         self.queue_size = kwargs.get("queue_size")
         self.ssl_check_hostname = "https" if ssl_check_hostname else None
+        self.iam_credentials_provider = create_iam_credentials_provider(
+            IAMCredentialsProviderInput(service_name=SupportedServiceType.EVENT_BROKER)
+        )
 
         # PII management attributes
         self.stream_pii = kwargs.get("stream_pii", True)
@@ -134,8 +142,8 @@ class KafkaEventBroker(EventBroker):
             try:
                 self._check_kafka_connection()
                 logger.debug("Connection to kafka successful.")
-            except KafkaException:
-                logger.debug("Failed to connect kafka.")
+            except KafkaException as exc:
+                logger.debug(f"Failed to connect to kafka: {exc}")
                 return
         while retries:
             try:
@@ -215,7 +223,31 @@ class KafkaEventBroker(EventBroker):
             KafkaException: if Kafka is disconnected.
         """
         if self.producer is not None:
-            self.producer.list_topics(timeout=5)
+            structlogger.debug(
+                "rasa.core.brokers.kafka.KafkaEventBroker.check_kafka_connection",
+            )
+            # we have to poll to trigger the oauth_cb if using IAM authentication
+            self.producer.poll(0)
+            self.producer.list_topics(self.topic, timeout=5)
+
+    def get_aws_iam_token(
+        self, oauth_config: Any
+    ) -> Tuple[Optional[str], Optional[float]]:
+        """Callback function to fetch AWS IAM token for MSK authentication.
+
+        The callback function requires this specific signature to work correctly.
+
+        Args:
+            oauth_config: OAuth configuration.
+
+        Returns:
+            A tuple of auth token and expiry time in seconds.
+        """
+        if self.iam_credentials_provider is None:
+            return None, None
+
+        temp_credentials = self.iam_credentials_provider.get_credentials()
+        return temp_credentials.auth_token, temp_credentials.expiration
 
     def _get_kafka_config(self) -> Dict[Text, Any]:
         config = {
@@ -246,15 +278,27 @@ class KafkaEventBroker(EventBroker):
             }
         elif self.security_protocol == "SASL_SSL":
             authentication_params = {
-                "sasl.username": self.sasl_username,
-                "sasl.password": self.sasl_password,
                 "ssl.ca.location": self.ssl_cafile,
-                "ssl.certificate.location": self.ssl_certfile,
-                "ssl.key.location": self.ssl_keyfile,
                 "ssl.endpoint.identification.algorithm": self.ssl_check_hostname,
                 "security.protocol": self.security_protocol,
                 "sasl.mechanism": self.sasl_mechanism,
             }
+
+            if self.iam_credentials_provider is not None:
+                authentication_params.update(
+                    {
+                        "oauth_cb": self.get_aws_iam_token,
+                    }
+                )
+            else:
+                authentication_params.update(
+                    {
+                        "sasl.username": self.sasl_username,
+                        "sasl.password": self.sasl_password,
+                        "ssl.certificate.location": self.ssl_certfile,
+                        "ssl.key.location": self.ssl_keyfile,
+                    }
+                )
         else:
             raise ValueError(
                 f"Cannot initialise `KafkaEventBroker`: "

rasa/core/channels/__init__.py

@@ -1,5 +1,5 @@
 # ruff: noqa: I001
-from typing import Text, Dict, List, Type
+from typing import Text, Dict, List, Type, Optional
 
 from rasa.core.channels.channel import (  # noqa: F401
     InputChannel,
@@ -15,54 +15,101 @@ from rasa.core.channels.socketio import SocketIOInput
 from rasa.core.channels.botframework import BotFrameworkInput
 from rasa.core.channels.callback import CallbackInput
 from rasa.core.channels.console import CmdlineInput
-from rasa.core.channels.facebook import FacebookInput
 from rasa.core.channels.mattermost import MattermostInput
 from rasa.core.channels.rasa_chat import RasaChatInput
 from rasa.core.channels.rest import RestInput
 from rasa.core.channels.rocketchat import RocketChatInput
-from rasa.core.channels.slack import SlackInput
-from rasa.core.channels.telegram import TelegramInput
-from rasa.core.channels.twilio import TwilioInput
-from rasa.core.channels.voice_ready.twilio_voice import TwilioVoiceInput
 from rasa.core.channels.voice_ready.jambonz import JambonzVoiceReadyInput
 from rasa.core.channels.voice_ready.audiocodes import AudiocodesInput
 from rasa.core.channels.voice_stream.browser_audio import BrowserAudioInputChannel
-from rasa.core.channels.webexteams import WebexTeamsInput
 from rasa.core.channels.hangouts import HangoutsInput
-from rasa.core.channels.vier_cvg import CVGInput
-from rasa.core.channels.voice_stream.twilio_media_streams import (
-    TwilioMediaStreamsInputChannel,
-)
 from rasa.core.channels.voice_stream.genesys import GenesysInputChannel
 from rasa.core.channels.studio_chat import StudioChatInput
 from rasa.core.channels.voice_stream.audiocodes import AudiocodesVoiceInputChannel
 from rasa.core.channels.voice_stream.jambonz import JambonzStreamInputChannel
 
+# Type annotations for channels with optional dependencies
+FacebookInput: Optional[Type[InputChannel]]
+SlackInput: Optional[Type[InputChannel]]
+TelegramInput: Optional[Type[InputChannel]]
+TwilioInput: Optional[Type[InputChannel]]
+TwilioVoiceInput: Optional[Type[InputChannel]]
+TwilioMediaStreamsInputChannel: Optional[Type[InputChannel]]
+WebexTeamsInput: Optional[Type[InputChannel]]
+CVGInput: Optional[Type[InputChannel]]
+
+# Channels with optional dependencies - import with try-except
+try:
+    from rasa.core.channels.facebook import FacebookInput
+except ImportError:
+    FacebookInput = None
+
+try:
+    from rasa.core.channels.slack import SlackInput
+except ImportError:
+    SlackInput = None
+
+try:
+    from rasa.core.channels.telegram import TelegramInput
+except ImportError:
+    TelegramInput = None
+
+try:
+    from rasa.core.channels.twilio import TwilioInput
+except ImportError:
+    TwilioInput = None
+
+try:
+    from rasa.core.channels.voice_ready.twilio_voice import TwilioVoiceInput
+except ImportError:
+    TwilioVoiceInput = None
+
+try:
+    from rasa.core.channels.voice_stream.twilio_media_streams import (
+        TwilioMediaStreamsInputChannel,
+    )
+except ImportError:
+    TwilioMediaStreamsInputChannel = None
+
+try:
+    from rasa.core.channels.webexteams import WebexTeamsInput
+except ImportError:
+    WebexTeamsInput = None
+
+try:
+    from rasa.core.channels.vier_cvg import CVGInput
+except ImportError:
+    CVGInput = None
+
 input_channel_classes: List[Type[InputChannel]] = [
-    CmdlineInput,
-    FacebookInput,
-    SlackInput,
-    TelegramInput,
-    MattermostInput,
-    TwilioInput,
-    TwilioVoiceInput,
-    RasaChatInput,
-    BotFrameworkInput,
-    RocketChatInput,
-    CallbackInput,
-    RestInput,
-    SocketIOInput,
-    WebexTeamsInput,
-    HangoutsInput,
-    AudiocodesInput,
-    CVGInput,
-    JambonzVoiceReadyInput,
-    TwilioMediaStreamsInputChannel,
-    BrowserAudioInputChannel,
-    GenesysInputChannel,
-    StudioChatInput,
-    AudiocodesVoiceInputChannel,
-    JambonzStreamInputChannel,
+    c
+    for c in [
+        CmdlineInput,
+        FacebookInput,
+        SlackInput,
+        TelegramInput,
+        MattermostInput,
+        TwilioInput,
+        TwilioVoiceInput,
+        RasaChatInput,
+        BotFrameworkInput,
+        RocketChatInput,
+        CallbackInput,
+        RestInput,
+        SocketIOInput,
+        WebexTeamsInput,
+        HangoutsInput,
+        AudiocodesInput,
+        CVGInput,
+        JambonzVoiceReadyInput,
+        TwilioMediaStreamsInputChannel,
+        BrowserAudioInputChannel,
+        GenesysInputChannel,
+        StudioChatInput,
+        AudiocodesVoiceInputChannel,
+        JambonzStreamInputChannel,
+    ]
+    if c is not None
 ]
 
 # Mapping from an input channel name to its class to allow name based lookup.

rasa/core/channels/inspector/README.md

@@ -1,4 +1,4 @@
-nu# Rasa Inspector
+# Rasa Inspector
 
 A rapid prototyping tool for enterprise developer personas working in Rasa Pro built with React + Typescript + Vite.
 

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/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/concurrent_lock_store.py

@@ -4,6 +4,7 @@ from collections import deque
 from typing import Deque, Optional, Text
 
 import structlog
+from pydantic import ValidationError
 
 from rasa.core.lock import Ticket, TicketLock
 from rasa.core.lock_store import (
@@ -12,6 +13,12 @@ from rasa.core.lock_store import (
     LockError,
     LockStore,
 )
+from rasa.core.redis_connection_factory import (
+    DeploymentMode,
+    RedisConfig,
+    RedisConnectionFactory,
+)
+from rasa.shared.exceptions import RasaException
 from rasa.utils.endpoints import EndpointConfig
 
 DEFAULT_REDIS_DB = 1
@@ -74,9 +81,10 @@ class ConcurrentRedisLockStore(LockStore):
                 alphanumeric.
             socket_timeout - Timeout in seconds after which an exception will be raised
                 in case Redis doesn't respond within `socket_timeout` seconds.
+            deployment_mode - Redis deployment mode: standard, cluster, or sentinel.
+            endpoints - List of endpoints for cluster/sentinel mode in host:port format.
+            sentinel_service - Sentinel service name.
         """
-        import redis
-
         host = endpoint_config.kwargs.get("host", DEFAULT_HOSTNAME)
         port = endpoint_config.kwargs.get("port", DEFAULT_PORT)
         db = endpoint_config.kwargs.get("db", DEFAULT_REDIS_DB)
@@ -90,20 +98,33 @@ class ConcurrentRedisLockStore(LockStore):
         socket_timeout = endpoint_config.kwargs.get(
             "socket_timeout", DEFAULT_SOCKET_TIMEOUT_IN_SECONDS
         )
-
-        self.red = redis.StrictRedis(
-            host=host,
-            port=int(port),
-            db=int(db),
-            username=username,
-            password=password,
-            ssl=use_ssl,
-            ssl_certfile=ssl_certfile,
-            ssl_keyfile=ssl_keyfile,
-            ssl_ca_certs=ssl_ca_certs,
-            socket_timeout=socket_timeout,
+        deployment_mode = endpoint_config.kwargs.get(
+            "deployment_mode", DeploymentMode.STANDARD.value
         )
+        endpoints = endpoint_config.kwargs.get("endpoints", [])
+        sentinel_service = endpoint_config.kwargs.get("sentinel_service")
 
+        try:
+            redis_config = RedisConfig(
+                host=host,
+                port=port,
+                db=db,
+                username=username,
+                password=password,
+                use_ssl=use_ssl,
+                ssl_certfile=ssl_certfile,
+                ssl_keyfile=ssl_keyfile,
+                ssl_ca_certs=ssl_ca_certs,
+                socket_timeout=socket_timeout,
+                deployment_mode=deployment_mode,
+                endpoints=endpoints,
+                sentinel_service=sentinel_service,
+            )
+            self.red = RedisConnectionFactory.create_connection(redis_config)
+        except ValidationError as e:
+            raise RasaException(f"Invalid Redis configuration: {e}")
+
+        self.deployment_mode = deployment_mode
         self.key_prefix = DEFAULT_CONCURRENT_REDIS_LOCK_STORE_KEY_PREFIX
         if key_prefix:
             structlogger.debug(
@@ -129,6 +150,32 @@ 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)
+                    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)
+
+        return keys
+
     def issue_ticket(
         self, conversation_id: Text, lock_lifetime: float = LOCK_LIFETIME
     ) -> int:
@@ -157,11 +204,14 @@ class ConcurrentRedisLockStore(LockStore):
         tickets: Deque[Ticket] = deque()
 
         pattern = self.key_prefix + conversation_id + ":" + "[0-9]*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         for key in redis_keys:
             serialised_ticket = self.red.get(key)
             if serialised_ticket:
+                # Handle bytes to string conversion for JSON parsing
+                if isinstance(serialised_ticket, bytes):
+                    serialised_ticket = serialised_ticket.decode("utf-8")
                 ticket = Ticket.from_dict(json.loads(serialised_ticket))
                 tickets.appendleft(ticket)
 
@@ -172,7 +222,7 @@ class ConcurrentRedisLockStore(LockStore):
     def delete_lock(self, conversation_id: Text) -> None:
         """Deletes lock for conversation ID."""
         pattern = self.key_prefix + conversation_id + ":*"
-        redis_keys = self.red.keys(pattern)
+        redis_keys = self._get_keys_by_pattern(pattern)
 
         if not redis_keys:
             structlogger.debug(

rasa/core/iam_credentials_providers/aws_iam_credentials_providers.py

@@ -1,7 +1,11 @@
+import os
+import threading
+import time
 from typing import Optional
 
 import boto3
 import structlog
+from aws_msk_iam_sasl_signer import MSKAuthTokenProvider
 from botocore.exceptions import BotoCoreError
 
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
@@ -10,6 +14,7 @@ from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     SupportedServiceType,
     TemporaryCredentials,
 )
+from rasa.shared.exceptions import ConnectionException
 
 structlogger = structlog.get_logger(__name__)
 
@@ -17,7 +22,7 @@ structlogger = structlog.get_logger(__name__)
 class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
     """Generates temporary credentials for AWS RDS using IAM roles."""
 
-    def __init__(self, username: str, host: str, port: int):
+    def __init__(self, username: str, host: str, port: int) -> None:
         """Initializes the provider."""
         self.username = username
         self.host = host
@@ -52,6 +57,73 @@ class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
             return TemporaryCredentials(auth_token=None)
 
 
+class AWSMSKafkaIAMCredentialsProvider(IAMCredentialsProvider):
+    """Generates temporary credentials for AWS MSK using IAM roles."""
+
+    def __init__(self) -> None:
+        self.region = os.getenv("AWS_DEFAULT_REGION", os.getenv("AWS_REGION"))
+        self._token: Optional[str] = None
+        self._expires_at: float = 0
+        self.refresh_margin_seconds = 60  # Refresh 60 seconds before expiry
+        # ensure thread safety when refreshing token because the
+        # kafka client library we use (confluent-kafka) is multithreaded
+        self.lock = threading.Lock()
+
+    @property
+    def token(self) -> Optional[str]:
+        return self._token
+
+    @token.setter
+    def token(self, value: str) -> None:
+        self._token = value
+
+    @property
+    def expires_at(self) -> float:
+        return self._expires_at
+
+    @expires_at.setter
+    def expires_at(self, value: float) -> None:
+        self._expires_at = value
+
+    def get_credentials(self) -> TemporaryCredentials:
+        """Generates temporary credentials for AWS MSK."""
+        with self.lock:
+            current_time = time.time()  # Current time in seconds
+            if (
+                not self.token
+                or current_time >= self.expires_at - self.refresh_margin_seconds
+            ):
+                try:
+                    auth_token, expiry_ms = MSKAuthTokenProvider.generate_auth_token(
+                        self.region
+                    )
+                    structlogger.debug(
+                        "rasa.core.aws_msk_iam_credentials_provider.get_credentials",
+                        event_info="Successfully generated AWS IAM token for "
+                        "Kafka authentication.",
+                    )
+                    self.token = auth_token
+                    self.expires_at = int(expiry_ms) / 1000  # Convert ms to seconds
+                    return TemporaryCredentials(
+                        auth_token=auth_token,
+                        expiration=self.expires_at,
+                    )
+                except Exception as exc:
+                    raise ConnectionException(
+                        f"Failed to generate AWS IAM token "
+                        f"for MSK authentication. Original exception: {exc}"
+                    ) from exc
+            else:
+                structlogger.debug(
+                    "rasa.core.aws_msk_iam_credentials_provider.get_credentials",
+                    event_info="Using cached AWS IAM token for Kafka authentication.",
+                )
+                return TemporaryCredentials(
+                    auth_token=self.token,
+                    expiration=self.expires_at,
+                )
+
+
 def create_aws_iam_credentials_provider(
     provider_input: "IAMCredentialsProviderInput",
 ) -> Optional["IAMCredentialsProvider"]:
@@ -63,4 +135,7 @@ def create_aws_iam_credentials_provider(
             port=provider_input.port,
         )
 
+    if provider_input.service_name == SupportedServiceType.EVENT_BROKER:
+        return AWSMSKafkaIAMCredentialsProvider()
+
     return None

rasa/core/iam_credentials_providers/credentials_provider_protocol.py

@@ -16,7 +16,7 @@ class TemporaryCredentials(BaseModel):
     """Dataclass storing temporary credentials."""
 
     auth_token: Optional[str] = None
-    expiration: Optional[int] = None
+    expiration: Optional[float] = None
     username: Optional[str] = None
     presigned_url: Optional[str] = None