rasa-pro 3.14.0.dev20250818__py3-none-any.whl → 3.14.0.dev20250901__py3-none-any.whl

rasa/model_manager/utils.py

@@ -5,15 +5,11 @@ from typing import Optional
 import structlog
 
 from rasa.model_manager import config
-from rasa.shared.exceptions import RasaException
+from rasa.utils.io import subpath
 
 structlogger = structlog.get_logger()
 
 
-class InvalidPathException(RasaException):
-    """Raised if a path is invalid - e.g. path traversal is detected."""
-
-
 def write_encoded_data_to_file(encoded_data: bytes, file: str) -> None:
     """Write base64 encoded data to a file."""
     # create the directory if it does not exist of the parent directory
@@ -53,30 +49,6 @@ def logs_path(action_id: str) -> str:
     return subpath(logs_base_path(), f"{action_id}.txt")
 
 
-def subpath(parent: str, child: str) -> str:
-    """Return the path to the child directory of the parent directory.
-
-    Ensures, that child doesn't navigate to parent directories. Prevents
-    path traversal. Raises an InvalidPathException if the path is invalid.
-
-    Based on Snyk's directory traversal mitigation:
-    https://learn.snyk.io/lesson/directory-traversal/
-    """
-    safe_path = os.path.abspath(os.path.join(parent, child))
-    parent = os.path.abspath(parent)
-
-    common_base = os.path.commonpath([parent, safe_path])
-    if common_base != parent:
-        raise InvalidPathException(f"Invalid path: {safe_path}")
-
-    if os.path.basename(safe_path) != child:
-        raise InvalidPathException(
-            f"Invalid path - path traversal detected: {safe_path}"
-        )
-
-    return safe_path
-
-
 def get_logs_content(action_id: str) -> Optional[str]:
     """Return the content of the log file for a given action id."""
     try:

rasa/shared/core/domain.py

@@ -98,6 +98,8 @@ IS_RETRIEVAL_INTENT_KEY = "is_retrieval_intent"
 ENTITY_ROLES_KEY = "roles"
 ENTITY_GROUPS_KEY = "groups"
 ENTITY_FEATURIZATION_KEY = "influence_conversation"
+STORE_ENTITIES_AS_SLOTS_KEY = "store_entities_as_slots"
+DOMAIN_CONFIG_KEY = "config"
 
 KEY_SLOTS = "slots"
 KEY_INTENTS = "intents"
@@ -146,6 +148,8 @@ MERGE_FUNC_MAPPING: Dict[Text, Callable[..., Any]] = {
     KEY_FORMS: rasa.shared.utils.common.merge_dicts,
 }
 
+DEFAULT_STORE_ENTITIES_AS_SLOTS = True
+
 DICT_DATA_KEYS = [
     key
     for key, value in MERGE_FUNC_MAPPING.items()
@@ -318,7 +322,7 @@ class Domain:
         actions = cls._collect_action_names(domain_actions)
 
         additional_arguments = {
-            **data.get("config", {}),
+            **data.get(DOMAIN_CONFIG_KEY, {}),
             "actions_which_explicitly_need_domain": (
                 cls._collect_actions_which_explicitly_need_domain(domain_actions)
             ),
@@ -468,9 +472,9 @@ class Domain:
             return domain_dict
 
         if override:
-            config = domain_dict.get("config", {})
+            config = domain_dict.get(DOMAIN_CONFIG_KEY, {})
             for key, val in config.items():
-                combined["config"][key] = val
+                combined[DOMAIN_CONFIG_KEY][key] = val
 
         if (
             override
@@ -508,10 +512,10 @@ class Domain:
         return combined
 
     def partial_merge(self, other: Domain) -> Domain:
-        """
-        Returns a new Domain with intersection-based merging:
-          - For each domain section only overwrite items that already exist in self.
-          - Brand-new items in `other` are ignored.
+        """Returns a new Domain with intersection-based merging.
+
+        For each domain section only overwrite items that already exist in self.
+        Brand-new items in `other` are ignored.
 
         Args:
             other: The domain to merge with.
@@ -543,9 +547,9 @@ class Domain:
         return Domain.from_dict(updated_self)
 
     def difference(self, other: Domain) -> Domain:
-        """
-        Returns a new Domain containing items in `self` that are NOT in `other`,
-        using simple equality checks for dict/list items.
+        """Returns a new Domain containing items in `self` that are NOT in `other`.
+
+        Uses simple equality checks for dict/list items.
 
         Args:
             other: The domain to compare with.
@@ -598,9 +602,16 @@ class Domain:
     ) -> Dict:
         # add the config, session_config and training data version defaults
         # if not included in the original domain dict
-        if "config" not in data and not store_entities_as_slots:
+        if (
+            DOMAIN_CONFIG_KEY not in data
+            and store_entities_as_slots != DEFAULT_STORE_ENTITIES_AS_SLOTS
+        ):
             data.update(
-                {"config": {"store_entities_as_slots": store_entities_as_slots}}
+                {
+                    DOMAIN_CONFIG_KEY: {
+                        STORE_ENTITIES_AS_SLOTS_KEY: store_entities_as_slots
+                    }
+                }
             )
 
         if SESSION_CONFIG_KEY not in data:
@@ -937,7 +948,7 @@ class Domain:
         forms: Union[Dict[Text, Any], List[Text]],
         data: Dict,
         action_texts: Optional[List[Text]] = None,
-        store_entities_as_slots: bool = True,
+        store_entities_as_slots: bool = DEFAULT_STORE_ENTITIES_AS_SLOTS,
         session_config: SessionConfig = SessionConfig.default(),
         **kwargs: Any,
     ) -> None:
@@ -1711,9 +1722,45 @@ class Domain:
         else:
             return True
 
-    def as_dict(self) -> Dict[Text, Any]:
+    def _uses_custom_session_config(self) -> bool:
+        """Check if the domain uses a custom session config."""
+        return self._data.get(SESSION_CONFIG_KEY) != SessionConfig.default().as_dict()
+
+    def _uses_custom_domain_config(self) -> bool:
+        """Check if the domain uses a custom domain config."""
+        return self._data.get(DOMAIN_CONFIG_KEY) != {
+            STORE_ENTITIES_AS_SLOTS_KEY: DEFAULT_STORE_ENTITIES_AS_SLOTS
+        }
+
+    def _cleaned_json_data(self) -> Dict[Text, Any]:
+        """Remove default values from the domain data.
+
+        Only retains data that was customized by the user.
+
+        Returns:
+            A cleaned dictionary version of the domain.
+        """
+        cleaned_data = copy.deepcopy(self._data)
+
+        # Remove default config if it only contains store_entities_as_slots: False
+        if DOMAIN_CONFIG_KEY in cleaned_data and not self._uses_custom_domain_config():
+            del cleaned_data[DOMAIN_CONFIG_KEY]
+
+        # Remove default session config if it matches the default values
+        if (
+            SESSION_CONFIG_KEY in cleaned_data
+            and not self._uses_custom_session_config()
+        ):
+            del cleaned_data[SESSION_CONFIG_KEY]
+
+        return cleaned_data
+
+    def as_dict(self, should_clean_json: bool = False) -> Dict[Text, Any]:
         """Return serialized `Domain`."""
-        return self._data
+        if should_clean_json:
+            return self._cleaned_json_data()
+        else:
+            return self._data
 
     @staticmethod
     def get_responses_with_multilines(

rasa/shared/core/flows/flow_step.py

@@ -52,7 +52,13 @@ def step_from_json(flow_id: Text, data: Dict[Text, Any]) -> FlowStep:
         return SetSlotsFlowStep.from_json(flow_id, data)
     if "noop" in data:
         return NoOperationFlowStep.from_json(flow_id, data)
-    raise RasaException(f"Failed to parse step from json. Unknown type for {data}.")
+
+    required_properties = ["action", "collect", "link", "call", "set_slots", "noop"]
+    raise RasaException(
+        f"Failed to parse step from json. Unknown type for {data}. "
+        f"At least one of the following properties is required: "
+        f"{', '.join(required_properties)}"
+    )
 
 
 @dataclass

rasa/shared/core/flows/steps/call.py

@@ -50,7 +50,14 @@ class CallFlowStep(FlowStep):
 
         if should_resolve_calls:
             if not self.called_flow_reference:
-                raise ValueError("Call flow reference not set.")
+                raise ValueError(
+                    f"Flow step '{self.id}' in flow '{self.flow_id}' is trying "
+                    f"to call flow '{self.call}', but the flow reference could "
+                    f"not be resolved. Please ensure that:\n"
+                    f"1. A flow named '{self.call}' is defined in your domain\n"
+                    f"2. The flow name is spelled correctly (case-sensitive)\n"
+                    f"3. The called flow is properly formatted with valid YAML syntax"
+                )
 
             yield from self.called_flow_reference.steps_with_calls_resolved
 

rasa/shared/core/flows/yaml_flows_io.py

@@ -262,12 +262,9 @@ class YamlFlowsWriter:
         Returns:
             The dumped YAML.
         """
-        dump = {}
-        for flow in flows:
-            dumped_flow = get_flow_as_json(flow, should_clean_json)
-            del dumped_flow["id"]
-            dump[flow.id] = dumped_flow
-        return dump_obj_as_yaml_to_string({KEY_FLOWS: dump})
+        return dump_obj_as_yaml_to_string(
+            {KEY_FLOWS: get_flows_as_json(flows, should_clean_json)}
+        )
 
     @staticmethod
     def dump(
@@ -424,9 +421,20 @@ def process_yaml_content(yaml_content: Dict[str, Any]) -> Dict[str, Any]:
     return yaml_content
 
 
+def get_flows_as_json(
+    flows: FlowsList, should_clean_json: bool = False
+) -> Dict[str, Any]:
+    """Get the flows as a JSON dictionary."""
+    dump = {}
+    for flow in flows:
+        dumped_flow = get_flow_as_json(flow, should_clean_json)
+        del dumped_flow["id"]
+        dump[flow.id] = dumped_flow
+    return dump
+
+
 def get_flow_as_json(flow: Flow, should_clean_json: bool = False) -> Dict[str, Any]:
-    """
-    Clean the Flow JSON by removing default values and empty fields.
+    """Clean the Flow JSON by removing default values and empty fields.
 
     Args:
         flow: The Flow object to clean.

rasa/shared/core/slots.py

@@ -273,10 +273,14 @@ class Slot(ABC):
         try:
             return rasa.shared.utils.common.class_from_module_path(type_name)
         except (ImportError, AttributeError):
+            known_types = [
+                cls.type_name for cls in rasa.shared.utils.common.all_subclasses(Slot)
+            ]
             raise InvalidSlotTypeException(
                 f"Failed to find slot type, '{type_name}' is neither a known type nor "
                 f"user-defined. If you are creating your own slot type, make "
                 f"sure its module path is correct. "
+                f"Known types: {', '.join(known_types)} "
                 f"You can find all build in types at {DOCS_URL_SLOTS}"
             )
 

rasa/shared/importers/importer.py

@@ -207,6 +207,12 @@ class TrainingDataImporter(ABC):
                 )
             ]
 
+        return TrainingDataImporter.wrap_in_builtins(importers)
+
+    @staticmethod
+    def wrap_in_builtins(
+        importers: List["TrainingDataImporter"],
+    ) -> "TrainingDataImporter":
         return LanguageImporter(
             E2EImporter(
                 FlowSyncImporter(ResponsesSyncImporter(CombinedDataImporter(importers)))

rasa/shared/importers/utils.py

@@ -1,9 +1,37 @@
-from typing import Iterable, List, Optional, Text
+from typing import Any, Dict, Iterable, List, Optional, Text
+
+from pydantic import BaseModel, Field
 
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.yaml_flows_io import KEY_FLOWS, get_flows_as_json
 from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.nlu.training_data.formats.rasa_yaml import RasaYAMLWriter
 from rasa.shared.nlu.training_data.training_data import TrainingData
+from rasa.utils.json_utils import extract_values
+
+
+class CALMUserData(BaseModel):
+    """All pieces that will be uploaded to Rasa Studio."""
+
+    flows: Dict[str, Any] = Field(default_factory=dict)
+    domain: Dict[str, Any] = Field(default_factory=dict)
+    config: Dict[str, Any] = Field(default_factory=dict)
+    endpoints: Dict[str, Any] = Field(default_factory=dict)
+    nlu: Dict[str, Any] = Field(default_factory=dict)
+
+
+DOMAIN_KEYS = [
+    "version",
+    "actions",
+    "responses",
+    "slots",
+    "intents",
+    "entities",
+    "forms",
+    "session_config",
+]
 
 
 def training_data_from_paths(paths: Iterable[Text], language: Text) -> TrainingData:
@@ -34,3 +62,51 @@ def flows_from_paths(files: List[Text]) -> FlowsList:
         )
     flows.validate()
     return flows
+
+
+def extract_calm_import_parts_from_importer(
+    importer: TrainingDataImporter,
+    config: Optional[Dict[str, Any]] = None,
+    endpoints: Optional[Dict[str, Any]] = None,
+) -> CALMUserData:
+    """Extracts CALMUserData from a TrainingDataImporter.
+
+    Args:
+        importer: The training data importer
+        data_paths: The path(s) to the training data for flows
+        config: Optional config dict, if not provided will use importer.get_config()
+        endpoints: Optional endpoints dict, defaults to empty dict
+
+    Returns:
+        CALMUserData containing flows, domain, config, endpoints, and nlu data
+    """
+    # Extract config
+    if config is None:
+        config = importer.get_config()
+
+    # Extract domain
+    domain_from_files = importer.get_user_domain().as_dict()
+    domain = extract_values(domain_from_files, DOMAIN_KEYS)
+
+    # Extract flows
+    flows = importer.get_user_flows()
+    flows_dict = {KEY_FLOWS: get_flows_as_json(flows)}
+
+    # Extract NLU data
+    nlu_data = importer.get_nlu_data()
+    nlu_examples = nlu_data.filter_training_examples(
+        lambda ex: ex.get("intent") in nlu_data.intents
+    )
+    nlu_dict = RasaYAMLWriter().training_data_to_dict(nlu_examples)
+
+    # Use provided endpoints or default to empty dict
+    if endpoints is None:
+        endpoints = {}
+
+    return CALMUserData(
+        flows=flows_dict or {},
+        domain=domain or {},
+        config=config or {},
+        endpoints=endpoints or {},
+        nlu=nlu_dict or {},
+    )

rasa/shared/providers/_utils.py

@@ -1,87 +1,103 @@
 from typing import Any, Dict, Optional
 
+import boto3
 import structlog
-from litellm import validate_environment
+from botocore.exceptions import BotoCoreError, ClientError
 
 from rasa.shared.constants import (
     API_BASE_CONFIG_KEY,
     API_VERSION_CONFIG_KEY,
     AWS_ACCESS_KEY_ID_CONFIG_KEY,
-    AWS_ACCESS_KEY_ID_ENV_VAR,
+    AWS_BEDROCK_PROVIDER,
     AWS_REGION_NAME_CONFIG_KEY,
-    AWS_REGION_NAME_ENV_VAR,
+    AWS_SAGEMAKER_CHAT_PROVIDER,
+    AWS_SAGEMAKER_PROVIDER,
     AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
-    AWS_SECRET_ACCESS_KEY_ENV_VAR,
     AWS_SESSION_TOKEN_CONFIG_KEY,
-    AWS_SESSION_TOKEN_ENV_VAR,
     AZURE_API_BASE_ENV_VAR,
     AZURE_API_VERSION_ENV_VAR,
     DEPLOYMENT_CONFIG_KEY,
 )
 from rasa.shared.exceptions import ProviderClientValidationError
-from rasa.shared.providers.embedding._base_litellm_embedding_client import (
-    _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY,
-)
+from rasa.shared.utils.io import resolve_environment_variables
 
 structlogger = structlog.get_logger()
 
 
 def validate_aws_setup_for_litellm_clients(
-    litellm_model_name: str, litellm_call_kwargs: dict, source_log: str
+    litellm_model_name: str, litellm_call_kwargs: Dict, source_log: str, provider: str
 ) -> None:
-    """Validates the AWS setup for LiteLLM clients to ensure all required
-    environment variables or corresponding call kwargs are set.
+    """Validates the AWS setup for LiteLLM clients to ensure credentials are set.
 
     Args:
         litellm_model_name (str): The name of the LiteLLM model being validated.
         litellm_call_kwargs (dict): Additional keyword arguments passed to the client,
             which may include configuration values for AWS credentials.
         source_log (str): The source log identifier for structured logging.
+        provider (str): The provider for which the validation is being performed.
 
     Raises:
         ProviderClientValidationError: If any required AWS environment variable
             or corresponding configuration key is missing.
     """
-
-    # Mapping of environment variable names to their corresponding config keys
-    envs_to_args = {
-        AWS_ACCESS_KEY_ID_ENV_VAR: AWS_ACCESS_KEY_ID_CONFIG_KEY,
-        AWS_SECRET_ACCESS_KEY_ENV_VAR: AWS_SECRET_ACCESS_KEY_CONFIG_KEY,
-        AWS_REGION_NAME_ENV_VAR: AWS_REGION_NAME_CONFIG_KEY,
-        AWS_SESSION_TOKEN_ENV_VAR: AWS_SESSION_TOKEN_CONFIG_KEY,
-    }
-
-    # Validate the environment setup for the model
-    validation_info = validate_environment(litellm_model_name)
-    missing_environment_variables = validation_info.get(
-        _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY, []
+    # expand environment variables if referenced in the config
+    resolved_litellm_call_kwargs: Dict = resolve_environment_variables(
+        litellm_call_kwargs
+    )  # type: ignore[assignment]
+
+    # boto3 only accepts bedrock and sagemaker as valid clients
+    # therefore we need to convert the provider name if it is defined
+    # as sagemaker_chat
+    provider = (
+        AWS_SAGEMAKER_PROVIDER if provider == AWS_SAGEMAKER_CHAT_PROVIDER else provider
     )
-    # Filter out missing environment variables that have been set trough arguments
-    # in extra parameters
-    missing_environment_variables = [
-        missing_env_var
-        for missing_env_var in missing_environment_variables
-        if litellm_call_kwargs.get(envs_to_args.get(missing_env_var)) is None
-    ]
 
-    if missing_environment_variables:
-        missing_environment_details = [
-            (
-                f"'{missing_env_var}' environment variable or "
-                f"'{envs_to_args.get(missing_env_var)}' config key"
-            )
-            for missing_env_var in missing_environment_variables
+    # if the AWS credentials are defined in the endpoints yaml model config,
+    # either as referenced secret env vars or direct values, we need to pass them
+    # to the boto3 client to ensure that the client can connect to the AWS service.
+    additional_kwargs: Dict[str, Any] = {}
+    if AWS_ACCESS_KEY_ID_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs[AWS_ACCESS_KEY_ID_CONFIG_KEY] = resolved_litellm_call_kwargs[
+            AWS_ACCESS_KEY_ID_CONFIG_KEY
         ]
+    if AWS_SECRET_ACCESS_KEY_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs[AWS_SECRET_ACCESS_KEY_CONFIG_KEY] = (
+            resolved_litellm_call_kwargs[AWS_SECRET_ACCESS_KEY_CONFIG_KEY]
+        )
+    if AWS_SESSION_TOKEN_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs[AWS_SESSION_TOKEN_CONFIG_KEY] = resolved_litellm_call_kwargs[
+            AWS_SESSION_TOKEN_CONFIG_KEY
+        ]
+    if AWS_REGION_NAME_CONFIG_KEY in resolved_litellm_call_kwargs:
+        additional_kwargs["region_name"] = resolved_litellm_call_kwargs[
+            AWS_REGION_NAME_CONFIG_KEY
+        ]
+
+    try:
+        # We are using the boto3 client because it can discover the AWS credentials
+        # from the environment variables, credentials file, or IAM roles.
+        # This is necessary to ensure that the client can connect to the AWS service.
+        aws_client = boto3.client(provider, **additional_kwargs)
+
+        # Using different method calls available to different AWS clients
+        # to test the connection
+        if provider == AWS_SAGEMAKER_PROVIDER:
+            aws_client.list_models()
+        elif provider == AWS_BEDROCK_PROVIDER:
+            aws_client.get_model_invocation_logging_configuration()
+
+    except (ClientError, BotoCoreError) as exc:
         event_info = (
-            f"The following environment variables or configuration keys are "
-            f"missing: "
-            f"{', '.join(missing_environment_details)}. "
-            f"These settings are required for API calls."
+            f"Failed to validate AWS setup for LiteLLM clients: {exc}. "
+            f"Ensure that you are using one of the available authentication methods:"
+            f"credentials file, environment variables, or IAM roles. "
+            f"Also, ensure that the AWS region is set correctly. "
         )
         structlogger.error(
-            f"{source_log}.validate_aws_environment_variables",
+            f"{source_log}.validate_aws_credentials_for_litellm_clients",
             event_info=event_info,
-            missing_environment_variables=missing_environment_variables,
+            exception=str(exc),
+            model_name=litellm_model_name,
         )
         raise ProviderClientValidationError(event_info)
 

rasa/shared/providers/embedding/default_litellm_embedding_client.py

@@ -37,6 +37,7 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> "DefaultLiteLLMEmbeddingClient":
+        """Creates a DefaultLiteLLMEmbeddingClient instance from a config dict."""
         default_config = DefaultLiteLLMClientConfig.from_dict(config)
         return cls(
             model=default_config.model,
@@ -121,6 +122,7 @@ class DefaultLiteLLMEmbeddingClient(_BaseLiteLLMEmbeddingClient):
                 self._litellm_model_name,
                 self._litellm_extra_parameters,
                 "default_litellm_embedding_client",
+                provider=self.provider,
             )
         else:
             super().validate_client_setup()

rasa/shared/providers/llm/default_litellm_llm_client.py

@@ -39,6 +39,7 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
 
     @classmethod
     def from_config(cls, config: Dict[str, Any]) -> DefaultLiteLLMClient:
+        """Creates a DefaultLiteLLMClient instance from a configuration dictionary."""
         default_config = DefaultLiteLLMClientConfig.from_dict(config)
         return cls(
             model=default_config.model,
@@ -110,6 +111,7 @@ class DefaultLiteLLMClient(_BaseLiteLLMClient):
                 self._litellm_model_name,
                 self._litellm_extra_parameters,
                 "default_litellm_llm_client",
+                provider=self.provider,
             )
         else:
             super().validate_client_setup()