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

rasa/core/config/configuration.py

@@ -0,0 +1,260 @@
+from __future__ import annotations
+
+import dataclasses
+from pathlib import Path
+from typing import Literal, Optional
+
+import structlog
+
+from rasa.cli.validation.config_path_validation import get_validated_path
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.credentials import CredentialsConfig
+from rasa.core.config.message_procesing_config import MessageProcessingConfig
+from rasa.shared.constants import (
+    DEFAULT_CONFIG_PATH,
+    DEFAULT_CREDENTIALS_PATH,
+    DEFAULT_ENDPOINTS_PATH,
+)
+
+logger = structlog.get_logger(__name__)
+
+
+@dataclasses.dataclass
+class ValidatedConfigPaths:
+    credentials_path: Optional[Path] = None
+    endpoints_path: Optional[Path] = None
+    message_processing_config_path: Optional[Path] = None
+
+
+@dataclasses.dataclass
+class ConfigPath:
+    target: Optional[Path] = None
+    type: Literal["credentials", "endpoints", "config"] = "endpoints"
+    alternative_targets: list[Path] = dataclasses.field(default_factory=list)
+    default_path: str = ""
+
+    @staticmethod
+    def _validate(
+        config_path: ConfigPath, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        validated_path = get_validated_path(
+            config_path.target,
+            config_path.type,
+            config_path.alternative_targets,
+            can_be_missing,
+        )
+
+        if validated_path is None and can_be_missing:
+            logger.debug(
+                f"No {config_path.type} configuration file found. "
+                f"Proceeding without {config_path.type} configuration."
+            )
+
+        if isinstance(validated_path, str):
+            validated_path = Path(validated_path)
+
+        return validated_path
+
+
+@dataclasses.dataclass
+class CredentialsConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="credentials",
+            alternative_targets=[Path(DEFAULT_CREDENTIALS_PATH)],
+            default_path=DEFAULT_CREDENTIALS_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = CredentialsConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_CREDENTIALS_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / CredentialsConfigPath.default_file_path()
+
+
+@dataclasses.dataclass
+class EndpointsConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="endpoints",
+            alternative_targets=[Path(DEFAULT_ENDPOINTS_PATH)],
+            default_path=DEFAULT_ENDPOINTS_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = EndpointsConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_ENDPOINTS_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / EndpointsConfigPath.default_file_path()
+
+
+@dataclasses.dataclass
+class MessageProcessingConfigPath(ConfigPath):
+    def __init__(self, target: Optional[Path] = None):
+        super().__init__(
+            target=target,
+            type="config",
+            alternative_targets=[Path(DEFAULT_CONFIG_PATH)],
+            default_path=DEFAULT_CONFIG_PATH,
+        )
+
+    @staticmethod
+    def validate(
+        target_config_path: Optional[Path] = None, can_be_missing: bool = True
+    ) -> Optional[Path]:
+        config_path = MessageProcessingConfigPath(target=target_config_path)
+        return ConfigPath._validate(config_path, can_be_missing)
+
+    @staticmethod
+    def default_file_path() -> Path:
+        return Path(DEFAULT_CONFIG_PATH)
+
+    @staticmethod
+    def at_path(
+        root_path: Path,
+    ) -> Path:
+        return root_path / MessageProcessingConfigPath.default_file_path()
+
+
+class Configuration:
+    _instance: Optional[Configuration] = None
+
+    def __init__(
+        self,
+        endpoints: AvailableEndpoints,
+        credentials: Optional[CredentialsConfig] = None,
+        message_processing_config: Optional[MessageProcessingConfig] = None,
+    ):
+        self.credentials = credentials
+        self.endpoints = endpoints
+        self.message_processing_config = message_processing_config
+
+    @classmethod
+    def initialise_empty(cls) -> Configuration:
+        if cls._instance is None:
+            cls._instance = Configuration(
+                credentials=None,
+                endpoints=AvailableEndpoints(),
+                message_processing_config=None,
+            )
+        return cls._instance
+
+    @classmethod
+    def initialise_endpoints(cls, endpoints_path: Path) -> Configuration:
+        logger.debug(
+            "configuration.initialise_endpoints.start", endpoints_path=endpoints_path
+        )
+
+        validated_endpoints_path = EndpointsConfigPath.validate(endpoints_path)
+        endpoints = (
+            AvailableEndpoints.read_endpoints(validated_endpoints_path)
+            if validated_endpoints_path
+            else AvailableEndpoints()
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                endpoints=endpoints, credentials=None, message_processing_config=None
+            )
+        else:
+            cls._instance.endpoints = endpoints
+        return cls._instance
+
+    @classmethod
+    def initialise_empty_endpoints(cls) -> Configuration:
+        logger.debug("configuration.initialise_empty_endpoints.start")
+        if cls._instance is None:
+            cls._instance = Configuration(
+                endpoints=AvailableEndpoints(),
+                credentials=None,
+                message_processing_config=None,
+            )
+        else:
+            cls._instance.endpoints = AvailableEndpoints()
+        return cls._instance
+
+    @classmethod
+    def initialise_message_processing(
+        cls, message_processing_config_path: Path
+    ) -> Configuration:
+        logger.debug(
+            "configuration.initialise_message_processing.start",
+            message_processing_config_path=message_processing_config_path,
+        )
+        validated_message_processing_path = MessageProcessingConfigPath.validate(
+            message_processing_config_path
+        )
+        message_processing_config = (
+            MessageProcessingConfig.load_from_file(validated_message_processing_path)
+            if validated_message_processing_path
+            else None
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                message_processing_config=message_processing_config,
+                credentials=None,
+                endpoints=AvailableEndpoints(),
+            )
+        else:
+            cls._instance.message_processing_config = message_processing_config
+        return cls._instance
+
+    @classmethod
+    def initialise_credentials(cls, credentials_path: Path) -> Configuration:
+        logger.debug(
+            "configuration.initialise_credentials.start",
+            credentials_path=credentials_path,
+        )
+
+        validated_credentials_path = CredentialsConfigPath.validate(credentials_path)
+
+        credentials = (
+            CredentialsConfig.load_from_file(validated_credentials_path)
+            if validated_credentials_path
+            else None
+        )
+        if cls._instance is None:
+            cls._instance = Configuration(
+                credentials=credentials,
+                endpoints=AvailableEndpoints(),
+                message_processing_config=None,
+            )
+        else:
+            cls._instance.credentials = credentials
+        return cls._instance
+
+    @classmethod
+    def get_instance(cls) -> Configuration:
+        if cls._instance is None:
+            raise Exception(
+                "Configuration not initialized. "
+                "Call appropriate 'initialise' methods to "
+                "load the config when Rasa Pro starts: "
+                "initialise_endpoints(), "
+                "initialise_credentials(), "
+                "initialise_message_processing()"
+            )
+        return cls._instance

rasa/core/config/credentials.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict
+
+from rasa.shared.utils.yaml import read_config_file
+
+
+class CredentialsConfig:
+    def __init__(
+        self, channels: Dict[str, Dict[str, Any]], config_file_path: Path
+    ) -> None:
+        self.channels = channels
+        self.config_file_path = config_file_path
+
+    @classmethod
+    def load_from_file(cls, file_path: Path) -> CredentialsConfig:
+        credentials_dict = read_config_file(file_path)
+        return cls(credentials_dict, file_path)

rasa/core/config/message_procesing_config.py

@@ -0,0 +1,34 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any, Dict, List
+
+from rasa.shared.utils.yaml import read_config_file
+
+
+class MessageProcessingConfig:
+    def __init__(
+        self,
+        recipe: str,
+        language: str,
+        assistant_id: str,
+        pipeline: List[Dict[str, Any]],
+        policies: List[Dict[str, Any]],
+    ):
+        self.recipe = recipe
+        self.language = language
+        self.assistant_id = assistant_id
+        self.pipeline = pipeline
+        self.policies = policies
+
+    @classmethod
+    def load_from_file(cls, filepath: Path) -> MessageProcessingConfig:
+        credentials_dict = read_config_file(filepath)
+
+        recipe = credentials_dict.get("recipe", "")
+        language = credentials_dict.get("language", "")
+        assistant_id = credentials_dict.get("assistant_id", "")
+        pipeline = credentials_dict.get("pipeline", [])
+        policies = credentials_dict.get("policies", [])
+
+        return cls(recipe, language, assistant_id, pipeline, policies)

rasa/core/constants.py

@@ -31,6 +31,10 @@ BEARER_TOKEN_PREFIX = "Bearer "
 # The lowest priority is intended to be used by machine learning policies.
 DEFAULT_POLICY_PRIORITY = 1
 
+DEFAULT_SUB_AGENTS = "sub_agents"
+
+MCP_SERVERS_KEY = "mcp_servers"
+
 # The priority of intent-prediction policies.
 # This should be below all rule based policies but higher than ML
 # based policies. This enables a loop inside ensemble where if none
@@ -119,3 +123,9 @@ SQL_TRACKER_STORE_SSL_ROOT_CERTIFICATE_ENV_VAR_NAME = (
     "SQL_TRACKER_STORE_SSL_ROOT_CERTIFICATE"
 )
 AWS_ELASTICACHE_CLUSTER_NAME_ENV_VAR_NAME = "AWS_ELASTICACHE_CLUSTER_NAME"
+RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME = "RDS_SQL_DB_AWS_IAM_ENABLED"
+ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME = "ELASTICACHE_REDIS_AWS_IAM_ENABLED"
+KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME = "KAFKA_MSK_AWS_IAM_ENABLED"
+SQL_SERVICE_NAME = "sql"
+REDIS_SERVICE_NAME = "redis"
+KAFKA_SERVICE_NAME = "kafka"

rasa/core/iam_credentials_providers/aws_iam_credentials_providers.py

@@ -1,7 +1,7 @@
 import os
 import threading
 import time
-from typing import Optional, Tuple
+from typing import Dict, Optional, Tuple
 from urllib.parse import ParseResult, urlencode, urlunparse
 
 import boto3
@@ -14,6 +14,14 @@ from botocore.session import get_session
 from botocore.signers import RequestSigner
 from cachetools import TTLCache, cached
 
+from rasa.core.constants import (
+    ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    KAFKA_SERVICE_NAME,
+    RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    REDIS_SERVICE_NAME,
+    SQL_SERVICE_NAME,
+)
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     IAMCredentialsProvider,
     IAMCredentialsProviderInput,
@@ -24,6 +32,25 @@ from rasa.shared.exceptions import ConnectionException
 
 structlogger = structlog.get_logger(__name__)
 
+SERVICE_CONFIG: Dict[Tuple[SupportedServiceType, str], str] = {
+    (
+        SupportedServiceType.TRACKER_STORE,
+        SQL_SERVICE_NAME,
+    ): RDS_SQL_DB_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.TRACKER_STORE,
+        REDIS_SERVICE_NAME,
+    ): ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.EVENT_BROKER,
+        KAFKA_SERVICE_NAME,
+    ): KAFKA_MSK_AWS_IAM_ENABLED_ENV_VAR_NAME,
+    (
+        SupportedServiceType.LOCK_STORE,
+        REDIS_SERVICE_NAME,
+    ): ELASTICACHE_REDIS_AWS_IAM_ENABLED_ENV_VAR_NAME,
+}
+
 
 class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
     """Generates temporary credentials for AWS RDS using IAM roles."""
@@ -203,21 +230,59 @@ class AWSElasticacheRedisIAMCredentialsProvider(redis.CredentialProvider):
             return TemporaryCredentials()
 
 
+def is_iam_enabled(provider_input: "IAMCredentialsProviderInput") -> bool:
+    """Checks if IAM authentication is enabled for the given service."""
+    service_type = provider_input.service_type
+    service_name = provider_input.service_name
+    iam_enabled_env_var_name = SERVICE_CONFIG.get((service_type, service_name))
+
+    if not iam_enabled_env_var_name:
+        structlogger.warning(
+            "rasa.core.aws_iam_credentials_providers.is_iam_enabled.unsupported_service",
+            event_info=f"IAM authentication check requested for unsupported service: "
+            f"{service_name}",
+        )
+        return False
+
+    return os.getenv(iam_enabled_env_var_name, "false").lower() == "true"
+
+
 def create_aws_iam_credentials_provider(
     provider_input: "IAMCredentialsProviderInput",
 ) -> Optional["IAMCredentialsProvider"]:
     """Factory function to create an AWS IAM credentials provider."""
-    if provider_input.service_name == SupportedServiceType.TRACKER_STORE:
+    iam_enabled = is_iam_enabled(provider_input)
+    if not iam_enabled:
+        structlogger.debug(
+            "rasa.core.aws_iam_credentials_providers.create_provider.iam_not_enabled",
+            event_info=f"IAM authentication not enabled for service: "
+            f"{provider_input.service_type}",
+        )
+        return None
+
+    if (
+        provider_input.service_type == SupportedServiceType.TRACKER_STORE
+        and provider_input.service_name == SQL_SERVICE_NAME
+    ):
         return AWSRDSIAMCredentialsProvider(
             username=provider_input.username,
             host=provider_input.host,
             port=provider_input.port,
         )
 
-    if provider_input.service_name == SupportedServiceType.EVENT_BROKER:
+    if (
+        provider_input.service_type == SupportedServiceType.TRACKER_STORE
+        and provider_input.service_name == REDIS_SERVICE_NAME
+    ):
+        return AWSElasticacheRedisIAMCredentialsProvider(
+            username=provider_input.username,
+            cluster_name=provider_input.cluster_name,
+        )
+
+    if provider_input.service_type == SupportedServiceType.EVENT_BROKER:
         return AWSMSKafkaIAMCredentialsProvider()
 
-    if provider_input.service_name == SupportedServiceType.LOCK_STORE:
+    if provider_input.service_type == SupportedServiceType.LOCK_STORE:
         return AWSElasticacheRedisIAMCredentialsProvider(
             username=provider_input.username,
             cluster_name=provider_input.cluster_name,

rasa/core/iam_credentials_providers/credentials_provider_protocol.py

@@ -47,7 +47,8 @@ class SupportedServiceType(Enum):
 class IAMCredentialsProviderInput(BaseModel):
     """Input data for creating an IAM credentials provider."""
 
-    service_name: SupportedServiceType
+    service_type: SupportedServiceType
+    service_name: str
     username: Optional[str] = None
     host: Optional[str] = None
     port: Optional[int] = None

rasa/core/lock_store.py

@@ -18,6 +18,9 @@ from pydantic import (
 
 import rasa.shared.utils.common
 from rasa.core.constants import DEFAULT_LOCK_LIFETIME, IAM_CLOUD_PROVIDER_ENV_VAR_NAME
+from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
+    SupportedServiceType,
+)
 from rasa.core.lock import TicketLock
 from rasa.core.redis_connection_factory import (
     DeploymentMode,
@@ -336,6 +339,7 @@ class RedisLockStore(LockStore):
             redis_config = RedisConfig(
                 host=str(self.config.host),
                 port=self.config.port,
+                service_type=SupportedServiceType.LOCK_STORE,
                 db=self.config.db,
                 username=self.config.username,
                 password=self.config.password,

rasa/core/policies/enterprise_search_policy.py

@@ -12,7 +12,7 @@ from jinja2 import Template
 from pydantic import ValidationError
 
 import rasa.shared.utils.io
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.constants import (
     UTTER_SOURCE_METADATA_KEY,
 )
@@ -63,6 +63,8 @@ from rasa.shared.constants import (
 )
 from rasa.shared.core.constants import (
     ACTION_CANCEL_FLOW,
+    ACTION_METADATA_MESSAGE_KEY,
+    ACTION_METADATA_TEXT_KEY,
     ACTION_SEND_TEXT_NAME,
     DEFAULT_SLOT_NAMES,
 )
@@ -585,8 +587,8 @@ class EnterpriseSearchPolicy(LLMHealthCheckMixin, EmbeddingsHealthCheckMixin, Po
             return self._create_prediction_internal_error(domain, tracker)
 
         action_metadata = {
-            "message": {
-                "text": response,
+            ACTION_METADATA_MESSAGE_KEY: {
+                ACTION_METADATA_TEXT_KEY: response,
                 SEARCH_RESULTS_METADATA_KEY: [
                     result.text for result in documents.results
                 ],

rasa/core/policies/flow_policy.py

@@ -137,8 +137,8 @@ class FlowPolicy(Policy):
 
         # create executor and predict next action
         try:
-            prediction = flow_executor.advance_flows(
-                tracker, domain.action_names_or_texts, flows
+            prediction = await flow_executor.advance_flows(
+                tracker, domain.action_names_or_texts, flows, domain.slots
             )
             return self._create_prediction_result(
                 prediction.action_name,
@@ -164,8 +164,8 @@ class FlowPolicy(Policy):
             # we retry, with the internal error frame on the stack
             events = tracker.create_stack_updated_events(updated_stack)
             tracker.update_with_events(events)
-            prediction = flow_executor.advance_flows(
-                tracker, domain.action_names_or_texts, flows
+            prediction = await flow_executor.advance_flows(
+                tracker, domain.action_names_or_texts, flows, domain.slots
             )
             collected_events = events + (prediction.events or [])
             return self._create_prediction_result(