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

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

@@ -152,7 +152,7 @@ class GRPCCustomActionExecutor(CustomActionExecutor):
                 structlogger.error(
                     "rasa.core.actions.grpc_custom_action_executor.domain_not_found",
                     event_info=(
-                        f"Failed to execute custom action '{self.action_endpoint}'. "
+                        f"Failed to execute custom action '{self.action_name}'. "
                         f"Could not find domain. {resource_not_found_error.message}"
                     ),
                 )

rasa/core/agent.py

@@ -12,9 +12,11 @@ import aiohttp
 from aiohttp import ClientError
 
 import rasa.shared.utils.io
+from rasa.agents.utils import initialize_agents
 from rasa.core import jobs
-from rasa.core.available_endpoints import AvailableEndpoints
+from rasa.core.available_agents import AvailableAgents
 from rasa.core.channels.channel import OutputChannel, UserMessage
+from rasa.core.config.available_endpoints import AvailableEndpoints
 from rasa.core.constants import DEFAULT_REQUEST_TIMEOUT
 from rasa.core.exceptions import AgentNotReady
 from rasa.core.http_interpreter import RasaNLUHttpInterpreter
@@ -34,7 +36,7 @@ from rasa.privacy.privacy_manager import BackgroundPrivacyManager
 from rasa.shared.constants import DEFAULT_SENDER_ID
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.trackers import DialogueStateTracker, EventVerbosity
-from rasa.shared.exceptions import RasaException
+from rasa.shared.exceptions import AgentInitializationException, RasaException
 from rasa.telemetry import track_privacy_enabled
 from rasa.utils.common import TempDirectoryPath, get_temp_dir_name
 from rasa.utils.endpoints import EndpointConfig
@@ -202,6 +204,7 @@ async def load_agent(
     model_server: Optional[EndpointConfig] = None,
     remote_storage: Optional[StorageType] = None,
     endpoints: Optional[AvailableEndpoints] = None,
+    sub_agents: Optional[AvailableAgents] = None,
     loop: Optional[AbstractEventLoop] = None,
 ) -> Agent:
     """Loads agent from server, remote storage or disk.
@@ -211,6 +214,7 @@ async def load_agent(
         model_server: Configuration for a potential server which serves the model.
         remote_storage: Remote storage to use for loading the model.
         endpoints: Endpoint configuration.
+        sub_agents: Sub-agents configuration.
         loop: Optional async loop to pass to broker creation.
 
     Returns:
@@ -281,8 +285,19 @@ async def load_agent(
                 "No valid configuration given to load agent. "
                 "Agent loaded with no model!"
             )
+
+        if agent.processor and sub_agents:
+            flows = await agent.processor.get_flows()
+            # 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, sub_agents)
+
         return agent
 
+    except AgentInitializationException as e:
+        raise e
     except Exception as e:
         logger.error(f"Could not load model due to {e}.", exc_info=True)
         return agent
@@ -322,6 +337,7 @@ class Agent:
         remote_storage: Optional[StorageType] = None,
         http_interpreter: Optional[RasaNLUHttpInterpreter] = None,
         endpoints: Optional[AvailableEndpoints] = None,
+        sub_agents: Optional[AvailableAgents] = None,
         privacy_manager: Optional[BackgroundPrivacyManager] = None,
     ):
         """Initializes an `Agent`."""
@@ -334,6 +350,7 @@ class Agent:
         self.action_endpoint = action_endpoint
         self.http_interpreter = http_interpreter
         self.endpoints = endpoints
+        self.sub_agents = sub_agents
 
         self._set_fingerprint(fingerprint)
         self.model_server = model_server