rasa-pro 3.14.0.dev6__py3-none-any.whl → 3.14.0.dev8__py3-none-any.whl

rasa/shared/core/constants.py

@@ -53,13 +53,15 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
+
+# pattern continue interrupted flows
 ACTION_CONTINUE_INTERRUPTED_FLOW = "action_continue_interrupted_flow"
-ACTION_SET_INTERRUPTED_FLOWS = "action_set_interrupted_flows"
-ACTION_CANCEL_INTERRUPTED_FLOW = "action_cancel_interrupted_flow"
-ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE = "action_ask_interrupted_flow_to_continue"
+ACTION_CANCEL_INTERRUPTED_FLOWS = "action_cancel_interrupted_flows"
+
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
+ACTION_METADATA_EXECUTION_TIME = "execution_times"
 
 ACTION_METADATA_MESSAGE_KEY = "message"
 ACTION_METADATA_TEXT_KEY = "text"
@@ -91,9 +93,7 @@ DEFAULT_ACTION_NAMES = [
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
     ACTION_CONTINUE_INTERRUPTED_FLOW,
-    ACTION_SET_INTERRUPTED_FLOWS,
-    ACTION_CANCEL_INTERRUPTED_FLOW,
-    ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE,
+    ACTION_CANCEL_INTERRUPTED_FLOWS,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"

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
@@ -510,8 +514,8 @@ class Domain:
     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.
+        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.
@@ -545,7 +549,7 @@ class Domain:
     def difference(self, other: Domain) -> Domain:
         """Returns a new Domain containing items in `self` that are NOT in `other`.
 
-        Simple using equality checks for dict/list items.
+        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/events.py

@@ -35,6 +35,7 @@ from rasa.shared.core.constants import (
     ACTION_LISTEN_NAME,
     ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
     ACTION_METADATA_EXECUTION_SUCCESS,
+    ACTION_METADATA_EXECUTION_TIME,
     ACTION_NAME_SENDER_ID_CONNECTOR_STR,
     ACTION_SESSION_START_NAME,
     ENTITY_LABEL_SEPARATOR,
@@ -1815,6 +1816,7 @@ class ActionExecuted(Event):
         items_to_ignore = [
             ACTION_METADATA_EXECUTION_SUCCESS,
             ACTION_METADATA_EXECUTION_ERROR_MESSAGE,
+            ACTION_METADATA_EXECUTION_TIME,
         ]
         meta_no_nones = {
             k: v

rasa/shared/core/flows/constants.py

@@ -11,3 +11,8 @@ KEY_RUN_PATTERN_COMPLETED = "run_pattern_completed"
 KEY_TRANSLATION = "translation"
 KEY_CALLED_FLOW = "called_flow"
 KEY_LINKED_FLOW = "linked_flow"
+
+# MCP mapping field names
+KEY_MAPPING_INPUT = "input"
+KEY_MAPPING_OUTPUT = "output"
+KEY_MAPPING_SLOT = "slot"

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

@@ -11,9 +11,12 @@ from rasa.shared.core.flows.validation import (
     DuplicatedFlowIdException,
     validate_call_steps,
     validate_exit_if_conditions,
+    validate_exit_if_exclusivity,
     validate_flow,
     validate_link_in_call_restriction,
     validate_linked_flows_exists,
+    validate_mcp_mapping_slots,
+    validate_mcp_server_references,
     validate_nlu_trigger,
     validate_patterns_are_not_called_or_linked,
     validate_patterns_are_not_calling_or_linking_other_flows,
@@ -176,11 +179,14 @@ class FlowsList:
         validate_nlu_trigger(self.underlying_flows)
         validate_link_in_call_restriction(self)
         validate_call_steps(self)
+        validate_mcp_server_references(self)
+        validate_mcp_mapping_slots(self, domain)
         validate_linked_flows_exists(self)
         validate_patterns_are_not_called_or_linked(self)
         validate_patterns_are_not_calling_or_linking_other_flows(self)
         validate_step_ids_are_unique(self)
         validate_exit_if_conditions(self, domain)
+        validate_exit_if_exclusivity(self)
 
     @property
     def user_flow_ids(self) -> Set[str]:

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

@@ -4,7 +4,6 @@ from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, Generator, List, Optional, Text
 
 from rasa.core.available_agents import AvailableAgents
-from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.core.flows.flow_step import FlowStep
 
 if TYPE_CHECKING:
@@ -74,7 +73,14 @@ class CallFlowStep(FlowStep):
 
         if should_resolve_calls and self.is_calling_flow():
             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
 
@@ -86,16 +92,13 @@ class CallFlowStep(FlowStep):
 
     def is_calling_mcp_tool(self) -> bool:
         """Returns True if the call references an MCP tool of an existing MCP server."""
-        mcp_server_list = AvailableEndpoints.get_instance().mcp_servers
-        if mcp_server_list is None:
-            return False
-
-        mcp_server_names = [server.name for server in mcp_server_list]
-        return (
-            self.mcp_server is not None
-            and self.mapping is not None
-            and self.mcp_server in mcp_server_names
-        )
+        from rasa.shared.utils.mcp.utils import mcp_server_exists
+
+        return self.has_mcp_tool_properties() and mcp_server_exists(self.mcp_server)
+
+    def has_mcp_tool_properties(self) -> bool:
+        """Returns True if the call step has MCP tool properties."""
+        return self.mcp_server is not None and self.mapping is not None
 
     def is_calling_agent(self) -> bool:
         """Returns True if the call references an agent."""

rasa/shared/core/flows/validation.py

@@ -4,7 +4,7 @@ import re
 import typing
 from collections import defaultdict
 from dataclasses import dataclass
-from typing import List, Optional, Set, Text
+from typing import Iterator, List, Optional, Set, Text, Tuple
 
 from jinja2 import Template
 
@@ -14,6 +14,11 @@ from rasa.shared.constants import (
     RASA_PATTERN_HUMAN_HANDOFF,
     RASA_PATTERN_INTERNAL_ERROR,
 )
+from rasa.shared.core.flows.constants import (
+    KEY_MAPPING_INPUT,
+    KEY_MAPPING_OUTPUT,
+    KEY_MAPPING_SLOT,
+)
 from rasa.shared.core.flows.flow import Flow
 from rasa.shared.core.flows.flow_step import (
     FlowStep,
@@ -130,6 +135,27 @@ class InvalidExitIfConditionException(RasaException):
         )
 
 
+class ExitIfExclusivityException(RasaException):
+    """Raised when a call step with exit_if has other properties."""
+
+    def __init__(
+        self, step_id: str, flow_id: str, conflicting_properties: List[str]
+    ) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.conflicting_properties = conflicting_properties
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        conflicting_properties_str = ", ".join(self.conflicting_properties)
+        return (
+            f"Call step '{self.step_id}' in flow '{self.flow_id}' has an 'exit_if' "
+            f"property but also has other properties: {conflicting_properties_str}. "
+            f"A call step with 'exit_if' cannot have any other properties."
+        )
+
+
 class DuplicatedFlowIdException(RasaException):
     """Raised when a flow is using the same id as another flow."""
 
@@ -304,9 +330,7 @@ class UnresolvedLinkFlowException(RasaException):
 
 
 class UnresolvedCallStepException(RasaException):
-    """Valid call step should have a reference to an existing flow or agent.
-    Raised when it does not.
-    """
+    """Raised when a call step doesn't have a reference to an existing flow or agent."""
 
     def __init__(
         self, call_step_argument: str, calling_flow_id: str, step_id: str
@@ -327,6 +351,62 @@ class UnresolvedCallStepException(RasaException):
         )
 
 
+class InvalidMCPServerReferenceException(RasaException):
+    """Raised when a call step references a non-existent MCP server."""
+
+    def __init__(
+        self, mcp_server_name: str, calling_flow_id: str, step_id: str
+    ) -> None:
+        """Initializes the exception."""
+        self.mcp_server_name = mcp_server_name
+        self.calling_flow_id = calling_flow_id
+        self.step_id = step_id
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        return (
+            f"Call step '{self.step_id}' in flow '{self.calling_flow_id}' "
+            f"references MCP server '{self.mcp_server_name}' which does not exist "
+            f"in endpoints.yml. Please make sure that the MCP server is properly "
+            f"configured in endpoints.yml."
+        )
+
+
+class InvalidMCPMappingSlotException(RasaException):
+    """Raised when MCP tool mapping references non-existent slots."""
+
+    def __init__(
+        self,
+        step_id: str,
+        flow_id: str,
+        invalid_input_slots: Set[str],
+        invalid_output_slots: Set[str],
+    ) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.invalid_input_slots = invalid_input_slots
+        self.invalid_output_slots = invalid_output_slots
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        error_parts = []
+
+        if self.invalid_input_slots:
+            input_slots_str = ", ".join(sorted(self.invalid_input_slots))
+            error_parts.append(f"input slots: {input_slots_str}")
+
+        if self.invalid_output_slots:
+            output_slots_str = ", ".join(sorted(self.invalid_output_slots))
+            error_parts.append(f"output slots: {output_slots_str}")
+
+        slots_info = " ".join(error_parts)
+        return (
+            f"Call step '{self.step_id}' in flow '{self.flow_id}' has slots not "
+            f"defined in the domain: {slots_info}"
+        )
+
+
 class UnresolvedFlowStepIdException(RasaException):
     """Raised when a flow step is referenced, but its id can not be resolved."""
 
@@ -610,19 +690,19 @@ def validate_link_in_call_restriction(flows: "FlowsList") -> None:
 
 
 def validate_call_steps(flows: "FlowsList") -> None:
-    """Validates that all called flows/agents exist and additional properties
-    are valid.
-    """
+    """Validates that all called flows/agents exist and properties are valid."""
     for flow in flows.underlying_flows:
         for step in flow.steps:
             if not isinstance(step, CallFlowStep):
                 continue
 
             _is_step_calling_agent = step.is_calling_agent()
+            _is_step_calling_mcp_tool = step.has_mcp_tool_properties()
+
             if (
                 not _is_step_calling_agent
                 and flows.flow_by_id(step.call) is None
-                and not step.is_calling_mcp_tool()
+                and not _is_step_calling_mcp_tool
             ):
                 raise UnresolvedCallStepException(step.call, flow.id, step.id)
 
@@ -635,6 +715,97 @@ def validate_call_steps(flows: "FlowsList") -> None:
                 )
 
 
+def validate_mcp_server_references(flows: "FlowsList") -> None:
+    """Validates that MCP server references in call steps are valid."""
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if not isinstance(step, CallFlowStep):
+                continue
+
+            # Only validate call steps that are trying to call MCP tools
+            if step.has_mcp_tool_properties():
+                # Check if the referenced MCP server exists
+                from rasa.shared.utils.mcp.utils import mcp_server_exists
+
+                if not mcp_server_exists(step.mcp_server):
+                    raise InvalidMCPServerReferenceException(
+                        step.mcp_server, flow.id, step.id
+                    )
+
+
+def validate_mcp_mapping_slots(
+    flows: "FlowsList", domain: Optional["Domain"] = None
+) -> None:
+    """Validates that slots referenced in MCP tool mapping are defined in the domain.
+
+    This function validates that all slots referenced in the input and output
+    mapping of MCP tool calls are defined in the domain.
+
+    Args:
+        flows: The flows to validate.
+        domain: The domain with slot definitions. If None, slot validation is skipped.
+
+    Raises:
+        InvalidMCPMappingSlotException: If any MCP mapping references undefined slots.
+    """
+    if domain is None:
+        return
+
+    domain_slots = {slot.name for slot in domain.slots}
+
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if not isinstance(step, CallFlowStep):
+                continue
+
+            # Only validate call steps that are calling MCP tools
+            if not step.has_mcp_tool_properties() or step.mapping is None:
+                continue
+
+            # Extract slot names from input mapping
+            input_slots = set()
+            if KEY_MAPPING_INPUT in step.mapping and isinstance(
+                step.mapping[KEY_MAPPING_INPUT], list
+            ):
+                for input_item in step.mapping[KEY_MAPPING_INPUT]:
+                    input_slots.add(input_item[KEY_MAPPING_SLOT])
+
+            # Extract slot names from output mapping
+            output_slots = set()
+            if KEY_MAPPING_OUTPUT in step.mapping and isinstance(
+                step.mapping[KEY_MAPPING_OUTPUT], list
+            ):
+                for output_item in step.mapping[KEY_MAPPING_OUTPUT]:
+                    output_slots.add(output_item[KEY_MAPPING_SLOT])
+
+            # Check for invalid slots in both input and output
+            invalid_input_slots = input_slots - domain_slots
+            invalid_output_slots = output_slots - domain_slots
+
+            # Raise exception if any invalid slots are found
+            if invalid_input_slots or invalid_output_slots:
+                raise InvalidMCPMappingSlotException(
+                    step.id, flow.id, invalid_input_slots, invalid_output_slots
+                )
+
+
+def _get_call_steps_with_exit_if(
+    flows: "FlowsList",
+) -> Iterator[Tuple["CallFlowStep", "Flow"]]:
+    """Helper function to get all call steps with exit_if properties.
+
+    Args:
+        flows: The flows to search through.
+
+    Yields:
+        Tuples of (call_step, flow) for steps that have exit_if properties.
+    """
+    for flow in flows.underlying_flows:
+        for step in flow.steps:
+            if isinstance(step, CallFlowStep) and step.exit_if:
+                yield step, flow
+
+
 def validate_exit_if_conditions(
     flows: "FlowsList", domain: Optional["Domain"] = None
 ) -> None:
@@ -652,47 +823,69 @@ def validate_exit_if_conditions(
     Raises:
         InvalidExitIfConditionException: If any exit_if condition is invalid.
     """
-    for flow in flows.underlying_flows:
-        for step in flow.steps:
-            if not isinstance(step, CallFlowStep) or not step.exit_if:
-                continue
-
-            for condition in step.exit_if:
-                if not isinstance(condition, str):
-                    raise InvalidExitIfConditionException(
-                        step.id, flow.id, str(condition), "Condition must be a string"
-                    )
+    for step, flow in _get_call_steps_with_exit_if(flows):
+        for condition in step.exit_if:  # type: ignore[union-attr]
+            if not isinstance(condition, str):
+                raise InvalidExitIfConditionException(
+                    step.id, flow.id, str(condition), "Condition must be a string"
+                )
 
-                # Check if condition contains at least one slot reference
-                slot_references = re.findall(r"\bslots\.\w+", condition)
-                if not slot_references:
-                    raise InvalidExitIfConditionException(
-                        step.id,
-                        flow.id,
-                        condition,
-                        "Condition must contain at least one slot reference "
-                        "(e.g., 'slots.slot_name')",
-                    )
+            # Check if condition contains at least one slot reference
+            slot_references_regex = re.compile(r"\bslots\.\w+")
+            slot_references = slot_references_regex.findall(condition)
+            if not slot_references:
+                raise InvalidExitIfConditionException(
+                    step.id,
+                    flow.id,
+                    condition,
+                    "Condition must contain at least one slot reference "
+                    "(e.g., 'slots.slot_name')",
+                )
 
-                # Validate slot names if domain is provided
-                if domain:
-                    domain_slots = {slot.name: slot for slot in domain.slots}
-                    for slot_ref in slot_references:
-                        slot_name = slot_ref.split(".")[1]
-                        if slot_name not in domain_slots:
-                            raise InvalidExitIfConditionException(
-                                step.id,
-                                flow.id,
-                                condition,
-                                f"Slot '{slot_name}' is not defined in the domain",
-                            )
-
-                        # Validate predicate syntax using pypred
-                        _validate_predicate_syntax_with_pypred(
-                            step.id, flow.id, condition
+            # Validate predicate syntax using pypred (always, regardless of domain)
+            _validate_predicate_syntax_with_pypred(step.id, flow.id, condition)
+
+            # Validate slot names if domain is provided
+            if domain:
+                domain_slots = {slot.name: slot for slot in domain.slots}
+                for slot_ref in slot_references:
+                    slot_name = slot_ref.split(".")[1]
+                    if slot_name not in domain_slots:
+                        raise InvalidExitIfConditionException(
+                            step.id,
+                            flow.id,
+                            condition,
+                            f"Slot '{slot_name}' is not defined in the domain",
                         )
 
 
+def validate_exit_if_exclusivity(flows: "FlowsList") -> None:
+    """Validates that call steps with exit_if don't have other properties.
+
+    This function validates that call steps with an exit_if property cannot have
+    any other properties besides the required 'call' property and standard flow
+    step properties (id, next, metadata, description).
+
+    Args:
+        flows: The flows to validate.
+
+    Raises:
+        ExitIfExclusivityException: If a call step with exit_if has other properties.
+    """
+    for step, flow in _get_call_steps_with_exit_if(flows):
+        # Check for conflicting properties
+        conflicting_properties = []
+
+        # Check for MCP-related properties
+        if step.mcp_server is not None:
+            conflicting_properties.append("mcp_server")
+        if step.mapping is not None:
+            conflicting_properties.append("mapping")
+
+        if conflicting_properties:
+            raise ExitIfExclusivityException(step.id, flow.id, conflicting_properties)
+
+
 def validate_linked_flows_exists(flows: "FlowsList") -> None:
     """Validates that all linked flows exist."""
     for flow in flows.underlying_flows:
@@ -814,6 +1007,7 @@ def validate_slot_names_to_be_collected(flow: Flow) -> None:
 
 def validate_flow_id(flow: Flow) -> None:
     """Validates if the flow id comply with a specified regex.
+
     Flow IDs can start with an alphanumeric character or an underscore.
     Followed by zero or more alphanumeric characters, hyphens, or underscores.
 

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(
@@ -425,6 +422,18 @@ 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.