rasa-pro 3.14.0a20__py3-none-any.whl → 3.14.0a23__py3-none-any.whl

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
@@ -118,3 +122,4 @@ SQL_TRACKER_STORE_SSL_MODE_ENV_VAR_NAME = "SQL_TRACKER_STORE_SSL_MODE"
 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"

rasa/core/iam_credentials_providers/aws_iam_credentials_providers.py

@@ -1,12 +1,18 @@
 import os
 import threading
 import time
-from typing import Optional
+from typing import Optional, Tuple
+from urllib.parse import ParseResult, urlencode, urlunparse
 
 import boto3
+import redis
 import structlog
 from aws_msk_iam_sasl_signer import MSKAuthTokenProvider
 from botocore.exceptions import BotoCoreError
+from botocore.model import ServiceId
+from botocore.session import get_session
+from botocore.signers import RequestSigner
+from cachetools import TTLCache, cached
 
 from rasa.core.iam_credentials_providers.credentials_provider_protocol import (
     IAMCredentialsProvider,
@@ -28,7 +34,7 @@ class AWSRDSIAMCredentialsProvider(IAMCredentialsProvider):
         self.host = host
         self.port = port
 
-    def get_credentials(self) -> TemporaryCredentials:
+    def get_temporary_credentials(self) -> TemporaryCredentials:
         """Generates temporary credentials for AWS RDS."""
         structlogger.debug(
             "rasa.core.aws_rds_iam_credentials_provider.get_credentials",
@@ -85,7 +91,7 @@ class AWSMSKafkaIAMCredentialsProvider(IAMCredentialsProvider):
     def expires_at(self, value: float) -> None:
         self._expires_at = value
 
-    def get_credentials(self) -> TemporaryCredentials:
+    def get_temporary_credentials(self) -> TemporaryCredentials:
         """Generates temporary credentials for AWS MSK."""
         with self.lock:
             current_time = time.time()  # Current time in seconds
@@ -124,6 +130,79 @@ class AWSMSKafkaIAMCredentialsProvider(IAMCredentialsProvider):
                 )
 
 
+class AWSElasticacheRedisIAMCredentialsProvider(redis.CredentialProvider):
+    """Generates temporary credentials for AWS ElastiCache Redis using IAM roles."""
+
+    def __init__(self, username: str, cluster_name: Optional[str] = None) -> None:
+        """Initializes the provider."""
+        self.username = username
+        self.cluster_name = cluster_name
+        self.region = os.getenv("AWS_DEFAULT_REGION", os.getenv("AWS_REGION"))
+        self.session = get_session()
+        self.request_signer = RequestSigner(
+            ServiceId("elasticache"),
+            self.region,
+            "elasticache",
+            "v4",
+            self.session.get_credentials(),
+            self.session.get_component("event_emitter"),
+        )
+
+    # Generated IAM tokens are valid for 15 minutes
+    @cached(cache=TTLCache(maxsize=128, ttl=900))
+    def get_credentials(self) -> Tuple[str, str]:
+        """Generates temporary credentials for AWS ElastiCache Redis.
+
+        Required method implementation by redis-py CredentialProvider parent class.
+        Used internally by redis-py when connecting to Redis.
+        """
+        query_params = {"Action": "connect", "User": self.username}
+        url = urlunparse(
+            ParseResult(
+                scheme="https",
+                netloc=self.cluster_name,
+                path="/",
+                query=urlencode(query_params),
+                params="",
+                fragment="",
+            )
+        )
+        signed_url = self.request_signer.generate_presigned_url(
+            {"method": "GET", "url": url, "body": {}, "headers": {}, "context": {}},
+            operation_name="connect",
+            expires_in=900,
+            region_name=self.region,
+        )
+
+        # RequestSigner only seems to work if the URL has a protocol, but
+        # Elasticache only accepts the URL without a protocol
+        # So strip it off the signed URL before returning
+        return self.username, signed_url.removeprefix("https://")
+
+    def get_temporary_credentials(self) -> TemporaryCredentials:
+        """Generates temporary credentials for AWS ElastiCache Redis.
+
+        Implemented to comply with the IAMCredentialsProvider rasa-pro interface.
+        Calls the get_credentials method which is used internally by redis-py.
+        """
+        try:
+            username, signed_url = self.get_credentials()
+            structlogger.info(
+                "rasa.core.aws_elasticache_redis_iam_credentials_provider.generated_credentials",
+                event_info="Successfully generated temporary credentials for "
+                "AWS ElastiCache Redis.",
+            )
+            return TemporaryCredentials(username=username, presigned_url=signed_url)
+        except Exception as exc:
+            structlogger.error(
+                "rasa.core.aws_elasticache_redis_iam_credentials_provider.error_generating_credentials",
+                event_info="Failed to generate temporary credentials for "
+                "AWS ElastiCache Redis.",
+                error=str(exc),
+            )
+            return TemporaryCredentials()
+
+
 def create_aws_iam_credentials_provider(
     provider_input: "IAMCredentialsProviderInput",
 ) -> Optional["IAMCredentialsProvider"]:
@@ -138,4 +217,10 @@ def create_aws_iam_credentials_provider(
     if provider_input.service_name == SupportedServiceType.EVENT_BROKER:
         return AWSMSKafkaIAMCredentialsProvider()
 
+    if provider_input.service_name == SupportedServiceType.LOCK_STORE:
+        return AWSElasticacheRedisIAMCredentialsProvider(
+            username=provider_input.username,
+            cluster_name=provider_input.cluster_name,
+        )
+
     return None

rasa/core/iam_credentials_providers/credentials_provider_protocol.py

@@ -25,7 +25,7 @@ class TemporaryCredentials(BaseModel):
 class IAMCredentialsProvider(Protocol):
     """Interface for generating temporary credentials using IAM roles."""
 
-    def get_credentials(self) -> TemporaryCredentials:
+    def get_temporary_credentials(self) -> TemporaryCredentials:
         """Generates temporary credentials using IAM roles."""
         ...
 
@@ -51,6 +51,7 @@ class IAMCredentialsProviderInput(BaseModel):
     username: Optional[str] = None
     host: Optional[str] = None
     port: Optional[int] = None
+    cluster_name: Optional[str] = None
 
 
 def create_iam_credentials_provider(

rasa/core/lock_store.py

@@ -17,7 +17,7 @@ from pydantic import (
 )
 
 import rasa.shared.utils.common
-from rasa.core.constants import DEFAULT_LOCK_LIFETIME
+from rasa.core.constants import DEFAULT_LOCK_LIFETIME, IAM_CLOUD_PROVIDER_ENV_VAR_NAME
 from rasa.core.lock import TicketLock
 from rasa.core.redis_connection_factory import (
     DeploymentMode,
@@ -227,7 +227,7 @@ class LockStore:
 
 
 class RedisLockStoreConfig(BaseModel):
-    host: Union[AnyUrl, Literal["localhost"]] = Field(
+    host: Union[AnyUrl, Literal["localhost"], str] = Field(
         default="localhost", description="The host of the redis server."
     )
     port: NonNegativeInt = Field(
@@ -308,7 +308,9 @@ class RedisLockStoreConfig(BaseModel):
 
     @model_validator(mode="after")
     def verify_username_password(self) -> RedisLockStoreConfig:
-        if bool(self.username) ^ bool(self.password):
+        if os.getenv(IAM_CLOUD_PROVIDER_ENV_VAR_NAME) is None and (
+            bool(self.username) ^ bool(self.password)
+        ):
             raise ValueError(
                 f"Expected username and password. "
                 f"Found: username: {'<has value>' if self.username else '<N/A>'}, "
@@ -341,7 +343,7 @@ class RedisLockStore(LockStore):
                 ssl_keyfile=self.config.ssl_keyfile,
                 ssl_certfile=self.config.ssl_certfile,
                 ssl_ca_certs=self.config.ssl_ca_certs,
-                deployment_mode=self.config.deployment_mode,
+                deployment_mode=self.config.deployment_mode.value,
                 endpoints=self.config.endpoints,
                 sentinel_service=self.config.sentinel_service,
                 socket_timeout=self.config.socket_timeout,

rasa/core/nlg/generator.py

@@ -2,7 +2,6 @@ from typing import Any, Dict, List, Optional, Text, Union
 
 import structlog
 from jinja2 import Template
-from pypred import Predicate
 
 import rasa.shared.utils.common
 import rasa.shared.utils.io
@@ -12,6 +11,7 @@ from rasa.shared.constants import CHANNEL, RESPONSE_CONDITION
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.utils.endpoints import EndpointConfig
+from rasa.utils.pypred import Predicate
 
 structlogger = structlog.get_logger()
 

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(