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

rasa/cli/validation/bot_config.py

@@ -0,0 +1,223 @@
+import argparse
+import os
+from typing import TYPE_CHECKING, Optional
+
+import structlog
+
+from rasa import telemetry
+from rasa.exceptions import ValidationError
+from rasa.shared.importers.importer import TrainingDataImporter
+from rasa.shared.utils.common import display_research_study_prompt
+
+if TYPE_CHECKING:
+    from rasa.validator import Validator
+
+structlogger = structlog.get_logger()
+
+FREE_TEXT_INPUT_PROMPT = "Type out your own message..."
+
+
+def _validate_domain(validator: "Validator") -> bool:
+    valid_domain_validity = validator.verify_domain_validity()
+    valid_actions_in_stories_rules = validator.verify_actions_in_stories_rules()
+    valid_forms_in_stories_rules = validator.verify_forms_in_stories_rules()
+    valid_form_slots = validator.verify_form_slots()
+    valid_slot_mappings = validator.verify_slot_mappings()
+    valid_responses = validator.check_for_no_empty_parenthesis_in_responses()
+    valid_buttons = validator.validate_button_payloads()
+    valid_slot_validation = validator.verify_slot_validation()
+    valid_conditional_responses = (
+        validator.validate_conditional_response_variation_predicates()
+    )
+    return (
+        valid_domain_validity
+        and valid_actions_in_stories_rules
+        and valid_forms_in_stories_rules
+        and valid_form_slots
+        and valid_slot_mappings
+        and valid_responses
+        and valid_buttons
+        and valid_slot_validation
+        and valid_conditional_responses
+    )
+
+
+def _validate_nlu(validator: "Validator", fail_on_warnings: bool) -> bool:
+    return validator.verify_nlu(not fail_on_warnings)
+
+
+def _validate_story_structure(
+    validator: "Validator", max_history: Optional[int], fail_on_warnings: bool
+) -> bool:
+    # Check if a valid setting for `max_history` was given
+    if isinstance(max_history, int) and max_history < 1:
+        raise argparse.ArgumentTypeError(
+            f"The value of `--max-history {max_history}` is not a positive integer."
+        )
+
+    return validator.verify_story_structure(
+        not fail_on_warnings, max_history=max_history
+    )
+
+
+def _validate_sub_agents(sub_agents_path: str) -> bool:
+    """Validates sub-agents configuration.
+
+    Args:
+        sub_agents_path: Path to the sub-agents directory.
+
+    Returns:
+        True if validation passes, False otherwise.
+    """
+    from rasa.agents.validation import validate_agent_folder
+    from rasa.core.constants import DEFAULT_SUB_AGENTS
+
+    try:
+        # Check if the sub-agents directory exists
+        if not os.path.isdir(sub_agents_path):
+            # If the sub-agents-path points to the default folder and it doesn't exist,
+            # no agents are available.
+            # AvailableAgents will handle the non-existing folder gracefully.
+
+            if sub_agents_path == DEFAULT_SUB_AGENTS:
+                structlogger.info(
+                    "cli.validate_files.sub_agents_validation",
+                    sub_agents_path=sub_agents_path,
+                    event_info="Default sub-agents directory does not exist, "
+                    "no sub-agents will be available.",
+                )
+                return True
+            else:
+                # For user-specified paths, the directory must exist
+                structlogger.error(
+                    "cli.validate_files.sub_agents_validation_error",
+                    sub_agents_path=sub_agents_path,
+                    event_info=f"Sub-agents directory '{sub_agents_path}' "
+                    "does not exist.",
+                )
+                return False
+
+        # Validate the actual config content using AvailableAgents
+        # This will validate file existence, structure, mandatory keys, etc.
+        try:
+            validate_agent_folder(sub_agents_path)
+
+        except ValidationError as e:
+            # This is a validation error - log it and return False
+            structlogger.error(
+                "cli.validate_files.sub_agents_validation_error",
+                sub_agents_path=sub_agents_path,
+                validation_error=str(e),
+                event_info=f"Sub-agents configuration validation failed: {e}",
+            )
+            return False
+
+        except Exception as e:
+            # This is an unexpected error
+            structlogger.error(
+                "cli.validate_files.sub_agents_validation_error",
+                sub_agents_path=sub_agents_path,
+                error=str(e),
+                event_info=f"Unexpected error during sub-agents validation: {e}",
+            )
+            return False
+
+        structlogger.info(
+            "cli.validate_files.sub_agents_validation_success",
+            sub_agents_path=sub_agents_path,
+            event_info="Sub-agents validation passed successfully.",
+        )
+        return True
+
+    except Exception as e:
+        # This is an unexpected error
+        structlogger.error(
+            "cli.validate_files.sub_agents_validation_error",
+            sub_agents_path=sub_agents_path,
+            error=str(e),
+            event_info="Sub-agents validation failed.",
+        )
+        return False
+
+
+def validate_files(
+    fail_on_warnings: bool,
+    max_history: Optional[int],
+    importer: TrainingDataImporter,
+    stories_only: bool = False,
+    flows_only: bool = False,
+    translations_only: bool = False,
+    sub_agents: Optional[str] = None,
+) -> None:
+    """Validates either the story structure or the entire project.
+
+    Args:
+        fail_on_warnings: `True` if the process should exit with a non-zero status
+        max_history: The max history to use when validating the story structure.
+        importer: The `TrainingDataImporter` to use to load the training data.
+        stories_only: If `True`, only the story structure is validated.
+        flows_only: If `True`, only the flows are validated.
+        translations_only: If `True`, only the translations data is validated.
+        sub_agents: Path to sub-agents directory for validation.
+    """
+    from rasa.validator import Validator
+
+    validator = Validator.from_importer(importer)
+
+    if stories_only:
+        all_good = _validate_story_structure(validator, max_history, fail_on_warnings)
+    elif flows_only:
+        all_good = validator.verify_flows()
+    elif translations_only:
+        all_good = validator.verify_translations()
+    else:
+        if importer.get_domain().is_empty():
+            structlogger.error(
+                "cli.validate_files.empty_domain",
+                event_info="Encountered empty domain during validation.",
+            )
+            display_research_study_prompt()
+            raise ValidationError(
+                code="cli.validate_files.empty_domain",
+                event_info="Encountered empty domain during validation.",
+            )
+
+        valid_domain = _validate_domain(validator)
+        valid_nlu = _validate_nlu(validator, fail_on_warnings)
+        valid_stories = _validate_story_structure(
+            validator, max_history, fail_on_warnings
+        )
+        valid_flows = validator.verify_flows()
+        if validator.config:
+            valid_translations = validator.verify_translations(summary_mode=True)
+        else:
+            valid_translations = True
+        valid_CALM_slot_mappings = validator.validate_CALM_slot_mappings()
+
+        # Validate sub-agents if specified
+        valid_sub_agents = _validate_sub_agents(sub_agents) if sub_agents else True
+
+        all_good = (
+            valid_domain
+            and valid_nlu
+            and valid_stories
+            and valid_flows
+            and valid_translations
+            and valid_CALM_slot_mappings
+            and valid_sub_agents
+        )
+
+    if validator.config:
+        validator.warn_if_config_mandatory_keys_are_not_set()
+
+    telemetry.track_validate_files(all_good)
+    if not all_good:
+        structlogger.error(
+            "cli.validate_files.project_validation_error",
+            event_info="Project validation completed with errors.",
+        )
+        display_research_study_prompt()
+        raise ValidationError(
+            code="cli.validate_files.project_validation_error",
+            event_info="Project validation completed with errors.",
+        )

rasa/cli/validation/config_path_validation.py

@@ -0,0 +1,257 @@
+import os
+import time
+from pathlib import Path
+from typing import List, Optional, Text, Union
+
+import randomname
+import structlog
+
+from rasa.exceptions import ModelNotFound, ValidationError
+from rasa.shared.constants import (
+    ASSISTANT_ID_DEFAULT_VALUE,
+    ASSISTANT_ID_KEY,
+    DEFAULT_CONFIG_PATH,
+)
+from rasa.shared.utils.common import display_research_study_prompt
+from rasa.shared.utils.yaml import read_config_file
+from rasa.utils.io import write_yaml
+
+structlogger = structlog.get_logger()
+
+
+FREE_TEXT_INPUT_PROMPT = "Type out your own message..."
+
+
+def get_validated_path(
+    current: Optional[Union[Path, Text]],
+    parameter: Text,
+    default: Optional[Union[Path, Text, List[Text], List[Path]]] = None,
+    none_is_valid: bool = False,
+) -> Optional[Union[Path, Text]]:
+    """Checks whether a file path or its default value is valid and returns it.
+
+    Args:
+        current: The parsed value.
+        parameter: The name of the parameter.
+        default: one or multiple default values of the parameter.
+        none_is_valid: `True` if `None` is valid value for the path,
+                        else `False``
+
+    Returns:
+        The current value if valid,
+        otherwise one of the default values of the argument if valid,
+        otherwise `None` if allowed,
+        otherwise raises an error and exits.
+    """
+    if current and os.path.exists(current):
+        return current
+
+    if parameter == "model":
+        raise ModelNotFound(
+            f"The provided model path '{current}' could not be found. "
+            "Provide an existing model path."
+        )
+
+    default_options: Union[List[str], List[Path]] = []
+    # try to find a valid option among the defaults
+    if isinstance(default, str) or isinstance(default, Path):
+        default_options = [str(default)]
+    elif isinstance(default, list):
+        default_options = default
+
+    valid_options = (option for option in default_options if os.path.exists(option))
+    chosen_option = next(valid_options, None)
+
+    # warn and log if user-chosen parameter wasn't found and thus overwritten
+    if chosen_option:
+        shared_info = f"Using default location '{chosen_option}' instead."
+        if current is None:
+            structlogger.debug(
+                "cli.get_validated_path.parameter_not_set",
+                parameter=parameter,
+                event_info=(f"Parameter '{parameter}' was not set. {shared_info}"),
+            )
+        elif current not in default_options:
+            structlogger.warn(
+                "cli.get_validated_path.path_does_not_exists",
+                path=current,
+                event_info=(
+                    f"The path '{current}' does not seem to exist. {shared_info}"
+                ),
+            )
+
+    if chosen_option is None and not none_is_valid:
+        _cancel_cause_not_found(current, parameter, default)
+
+    return chosen_option
+
+
+def validate_assistant_id_in_config(config_file: Union["Path", Text]) -> None:
+    """Verifies that the assistant_id key exists and has a unique value in config.
+
+    Issues a warning if the key does not exist or has the default value and replaces it
+    with a pseudo-random string value.
+    """
+    config_data = read_config_file(config_file, reader_type=["safe", "rt"])
+    assistant_id = config_data.get(ASSISTANT_ID_KEY)
+
+    if assistant_id is None or assistant_id == ASSISTANT_ID_DEFAULT_VALUE:
+        structlogger.warn(
+            "cli.validate_assistant_id_in_config.missing_unique_assistant_id_key",
+            config=config_file,
+            missing_key=ASSISTANT_ID_KEY,
+            event_info=(
+                f"The config file '{config_file!s}' is "
+                f"missing a unique value for the "
+                f"'{ASSISTANT_ID_KEY}' mandatory key. "
+                f"Proceeding with generating a random "
+                f"value and overwriting the '{ASSISTANT_ID_KEY}'"
+                f" in the config file."
+            ),
+        )
+
+        # add random value for assistant id, overwrite config file
+        time_format = "%Y%m%d-%H%M%S"
+        config_data[ASSISTANT_ID_KEY] = (
+            f"{time.strftime(time_format)}-{randomname.get_name()}"
+        )
+
+        write_yaml(data=config_data, target=config_file, should_preserve_key_order=True)
+
+    return
+
+
+def validate_config_path(
+    config: Optional[Union[Text, "Path"]],
+    default_config: Text = DEFAULT_CONFIG_PATH,
+) -> Text:
+    """Verifies that the config path exists.
+
+    Exit if the config file does not exist.
+
+    Args:
+        config: Path to the config file.
+        default_config: default config to use if the file at `config` doesn't exist.
+
+    Returns: The path to the config file.
+    """
+    config = get_validated_path(config, "config", default_config)
+
+    if not config or not os.path.exists(config):
+        display_research_study_prompt()
+        raise ValidationError(
+            code="cli.validate_config_path.does_not_exists",
+            config=config,
+            event_info=(
+                f"The config file '{config}' does not exist. "
+                f"Use '--config' to specify a valid config file."
+            ),
+        )
+
+    return str(config)
+
+
+def validate_mandatory_config_keys(
+    config: Union[Text, "Path"],
+    mandatory_keys: List[Text],
+) -> Text:
+    """Get a config from a config file and check if it is valid.
+
+    Exit if the config isn't valid.
+
+    Args:
+        config: Path to the config file.
+        mandatory_keys: The keys that have to be specified in the config file.
+
+    Returns: The path to the config file if the config is valid.
+    """
+    missing_keys = set(_missing_config_keys(config, mandatory_keys))
+    if missing_keys:
+        display_research_study_prompt()
+        raise ValidationError(
+            code="cli.validate_mandatory_config_keys.missing_keys",
+            config=config,
+            missing_keys=missing_keys,
+            event_info=(
+                "The config file '{}' is missing mandatory parameters: "
+                "'{}'. Add missing parameters to config file and try again.".format(
+                    config, "', '".join(missing_keys)
+                )
+            ),
+        )
+
+    return str(config)
+
+
+def get_validated_config(
+    config: Optional[Union[Text, "Path"]],
+    mandatory_keys: List[Text],
+    default_config: Text = DEFAULT_CONFIG_PATH,
+) -> Text:
+    """Validates config and returns path to validated config file."""
+    config = validate_config_path(config, default_config)
+    validate_assistant_id_in_config(config)
+
+    config = validate_mandatory_config_keys(config, mandatory_keys)
+
+    return config
+
+
+def _missing_config_keys(
+    path: Union["Path", Text], mandatory_keys: List[Text]
+) -> List[Text]:
+    """Checks whether the config file at `path` contains the `mandatory_keys`.
+
+    Args:
+        path: The path to the config file.
+        mandatory_keys: A list of mandatory config keys.
+
+    Returns:
+        The list of missing config keys.
+    """
+    if not os.path.exists(path):
+        return mandatory_keys
+
+    config_data = read_config_file(path)
+
+    return [k for k in mandatory_keys if k not in config_data or config_data[k] is None]
+
+
+def _cancel_cause_not_found(
+    current: Optional[Union["Path", Text]],
+    parameter: Text,
+    default: Optional[Union["Path", Text, List[Text]]],
+) -> None:
+    """Exits with an error because the given path was not valid.
+
+    Args:
+        current: The path given by the user.
+        parameter: The name of the parameter.
+        default: The default value of the parameter.
+
+    """
+    default_clause = ""
+    if default and isinstance(default, str):
+        default_clause = f"use the default location ('{default}') or"
+    elif default and isinstance(default, list):
+        default_clause = f"use one of the default locations ({', '.join(default)}) or"
+
+    structlogger.error(
+        "cli.path_does_not_exist",
+        path=current,
+        event_info=(
+            f"The path '{current}' does not exist. "
+            f"Please make sure to {default_clause} specify it "
+            f"with '--{parameter}'."
+        ),
+    )
+    display_research_study_prompt()
+    raise ValidationError(
+        code="cli.path_does_not_exist",
+        path=current,
+        event_info=(
+            f"The path '{current}' does not exist. "
+            f"Please make sure to {default_clause} specify it "
+            f"with '--{parameter}'."
+        ),
+    )

rasa/cli/x.py

@@ -15,7 +15,9 @@ import rasa.utils.common
 import rasa.utils.io
 from rasa.cli import SubParsersAction
 from rasa.cli.arguments import x as arguments
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.cli.validation.config_path_validation import get_validated_path
+from rasa.core.config.available_endpoints import AvailableEndpoints
+from rasa.core.config.configuration import Configuration
 from rasa.shared.constants import (
     DEFAULT_CREDENTIALS_PATH,
     DEFAULT_ENDPOINTS_PATH,
@@ -90,7 +92,7 @@ def _prepare_credentials_for_rasa_x(
 ) -> Text:
     if credentials_path:
         credentials_path = str(
-            rasa.cli.utils.get_validated_path(
+            get_validated_path(
                 credentials_path, "credentials", DEFAULT_CREDENTIALS_PATH, True
             )
         )
@@ -179,7 +181,9 @@ def run_in_enterprise_connection_mode(args: argparse.Namespace) -> None:
     print_success("Starting a Rasa server in Rasa Enterprise connection mode... 🚀")
 
     credentials_path, endpoints_path = _get_credentials_and_endpoints_paths(args)
-    endpoints = AvailableEndpoints.get_instance(endpoints_path)
+    endpoints = Configuration.initialise_endpoints(
+        endpoints_path=Path(endpoints_path)
+    ).endpoints
 
     _rasa_service(args, endpoints, None, credentials_path)
 
@@ -195,7 +199,7 @@ def _get_credentials_and_endpoints_paths(
             _pull_runtime_config_from_server(config_endpoint)
         )
     else:
-        endpoints_config_path = rasa.cli.utils.get_validated_path(
+        endpoints_config_path = get_validated_path(
             args.endpoints, "endpoints", DEFAULT_ENDPOINTS_PATH, True
         )
         credentials_path = None

rasa/constants.py

@@ -18,12 +18,18 @@ CONFIG_TELEMETRY_ID = "rasa_user_id"
 CONFIG_TELEMETRY_ENABLED = "enabled"
 CONFIG_TELEMETRY_DATE = "date"
 
-MINIMUM_COMPATIBLE_VERSION = "3.11.0rc1"
+MINIMUM_COMPATIBLE_VERSION = "3.14.0.dev10"
 
 GLOBAL_USER_CONFIG_PATH = os.path.expanduser("~/.config/rasa/global.yml")
 
+# Logging level for external libraries (default: ERROR to reduce noise)
 DEFAULT_LOG_LEVEL_LIBRARIES = "ERROR"
 ENV_LOG_LEVEL_LIBRARIES = "LOG_LEVEL_LIBRARIES"
+
+# MCP (Model Context Protocol) logging configuration
+ENV_LOG_LEVEL_MCP = "LOG_LEVEL_MCP"
+ENV_MCP_LOGGING_ENABLED = "MCP_LOGGING_ENABLED"
+
 ENV_LOG_LEVEL_MATPLOTLIB = "LOG_LEVEL_MATPLOTLIB"
 ENV_LOG_LEVEL_RABBITMQ = "LOG_LEVEL_RABBITMQ"
 ENV_LOG_LEVEL_KAFKA = "LOG_LEVEL_KAFKA"

rasa/core/actions/action.py

@@ -47,6 +47,7 @@ from rasa.shared.constants import (
     UTTER_PREFIX,
 )
 from rasa.shared.core.constants import (
+    ACTION_AGENT_REQUEST_USER_INPUT_NAME,
     ACTION_BACK_NAME,
     ACTION_DEACTIVATE_LOOP_NAME,
     ACTION_DEFAULT_ASK_AFFIRMATION_NAME,
@@ -56,6 +57,8 @@ from rasa.shared.core.constants import (
     ACTION_LISTEN_NAME,
     ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
     ACTION_METADATA_EXECUTION_SUCCESS,
+    ACTION_METADATA_MESSAGE_KEY,
+    ACTION_METADATA_TEXT_KEY,
     ACTION_RESET_ROUTING,
     ACTION_RESTART_NAME,
     ACTION_REVERT_FALLBACK_EVENTS_NAME,
@@ -88,7 +91,12 @@ from rasa.shared.core.slot_mappings import (
 )
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import RasaException
-from rasa.shared.nlu.constants import INTENT_NAME_KEY, INTENT_RANKING_KEY
+from rasa.shared.nlu.constants import (
+    INTENT,
+    INTENT_NAME_KEY,
+    INTENT_RANKING_KEY,
+    PREDICTED_CONFIDENCE_KEY,
+)
 from rasa.shared.utils.io import raise_warning
 from rasa.shared.utils.schemas.events import EVENTS_SCHEMA
 from rasa.utils.endpoints import EndpointConfig
@@ -113,6 +121,10 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
     from rasa.core.actions.two_stage_fallback import TwoStageFallbackAction
     from rasa.dialogue_understanding.patterns.cancel import ActionCancelFlow
     from rasa.dialogue_understanding.patterns.clarify import ActionClarifyFlows
+    from rasa.dialogue_understanding.patterns.continue_interrupted import (
+        ActionCancelInterruptedFlows,
+        ActionContinueInterruptedFlow,
+    )
     from rasa.dialogue_understanding.patterns.correction import ActionCorrectFlowSlot
 
     return [
@@ -127,6 +139,7 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         TwoStageFallbackAction(action_endpoint),
         ActionUnlikelyIntent(),
         ActionSendText(),
+        ActionAgentRequestUserInfo(),
         ActionBack(),
         ActionExtractSlots(action_endpoint),
         ActionCancelFlow(),
@@ -139,6 +152,8 @@ def default_actions(action_endpoint: Optional[EndpointConfig] = None) -> List["A
         ActionResetRouting(),
         ActionHangup(),
         ActionRepeatBotMessages(),
+        ActionContinueInterruptedFlow(),
+        ActionCancelInterruptedFlows(),
     ]
 
 
@@ -873,8 +888,8 @@ class RemoteAction(Action):
     ) -> List[BotUttered]:
         """Use the responses generated by the action endpoint and utter them."""
         bot_messages = []
-        domain: Domain = kwargs.get("domain", None)
-        action_name: str = kwargs.get("action_name", None)
+        domain: Optional[Domain] = kwargs.get("domain", None)
+        action_name: Optional[str] = kwargs.get("action_name", None)
         for response in responses:
             generated_response = response.pop("response", None)
             if generated_response is not None:
@@ -1014,13 +1029,13 @@ def _revert_affirmation_events(tracker: "DialogueStateTracker") -> List[Event]:
         revert_events += _revert_rephrasing_events()
 
     last_user_event = tracker.get_last_event_for(UserUttered)
-    if not last_user_event:
-        raise TypeError("Cannot find last event to revert to.")
+    if not last_user_event or not isinstance(last_user_event, UserUttered):
+        raise TypeError("Cannot find last user uttered event to revert to.")
 
     last_user_event = copy.deepcopy(last_user_event)
     # FIXME: better type annotation for `parse_data` would require
     # a larger refactoring (e.g. switch to dataclass)
-    last_user_event.parse_data["intent"]["confidence"] = 1.0  # type: ignore[typeddict-item]
+    last_user_event.parse_data[INTENT][PREDICTED_CONFIDENCE_KEY] = 1.0  # type: ignore[literal-required]
 
     return revert_events + [last_user_event]
 
@@ -1037,8 +1052,8 @@ def _revert_single_affirmation_events() -> List[Event]:
 
 def _revert_successful_rephrasing(tracker: "DialogueStateTracker") -> List[Event]:
     last_user_event = tracker.get_last_event_for(UserUttered)
-    if not last_user_event:
-        raise TypeError("Cannot find last event to revert to.")
+    if not last_user_event or not isinstance(last_user_event, UserUttered):
+        raise TypeError("Cannot find last user uttered event to revert to.")
 
     last_user_event = copy.deepcopy(last_user_event)
     return _revert_rephrasing_events() + [last_user_event]
@@ -1138,9 +1153,9 @@ class ActionSendText(Action):
         metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
         """Runs action. Please see parent class for the full docstring."""
-        fallback = {"text": ""}
+        fallback = {ACTION_METADATA_TEXT_KEY: ""}
         metadata_copy = copy.deepcopy(metadata) if metadata else {}
-        message = metadata_copy.get("message", fallback)
+        message = metadata_copy.get(ACTION_METADATA_MESSAGE_KEY, fallback)
 
         should_send_text = metadata_copy.get("should_send_text", True)
         if should_send_text:
@@ -1148,6 +1163,32 @@ class ActionSendText(Action):
         return []
 
 
+class ActionAgentRequestUserInfo(Action):
+    """Sends a text message to the output channel that requests some user information.
+
+    The difference to `ActionSendText` is that this action will pause the main advancing
+    flow loop until the user responds to the request
+    (`should_predict_another_action` will return False for this action).
+    """
+
+    def name(self) -> Text:
+        return ACTION_AGENT_REQUEST_USER_INPUT_NAME
+
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        """Runs action. Please see parent class for the full docstring."""
+        fallback = {ACTION_METADATA_TEXT_KEY: ""}
+        metadata_copy = copy.deepcopy(metadata) if metadata else {}
+        message = metadata_copy.get(ACTION_METADATA_MESSAGE_KEY, fallback)
+        return [create_bot_utterance(message)]
+
+
 class ActionExtractSlots(Action):
     """Default action that runs after each user turn.
 

rasa/core/actions/action_run_slot_rejections.py

@@ -2,7 +2,6 @@ from typing import TYPE_CHECKING, Any, Dict, List, Optional, Text, Union
 
 import structlog
 from jinja2 import Template
-from pypred import Predicate
 
 from rasa.core.actions.action import Action, create_bot_utterance
 from rasa.core.utils import add_bot_utterance_metadata
@@ -21,6 +20,7 @@ from rasa.shared.core.slots import (
     Slot,
     SlotRejection,
 )
+from rasa.utils.pypred import Predicate
 
 if TYPE_CHECKING:
     from rasa.core.channels.channel import OutputChannel