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

rasa/dialogue_understanding/patterns/continue_interrupted.py

@@ -1,31 +1,47 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Text
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Text, Tuple
+
+import structlog
 
 from rasa.core.actions.action import Action
 from rasa.core.channels import OutputChannel
 from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.commands.utils import (
+    resume_flow,
+)
+from rasa.dialogue_understanding.patterns.cancel import CancelPatternFlowStackFrame
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
-from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
+    DialogueStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    get_active_continue_interrupted_pattern_frame,
+)
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
 from rasa.shared.core.constants import (
-    ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE,
-    ACTION_CANCEL_INTERRUPTED_FLOW,
+    ACTION_CANCEL_INTERRUPTED_FLOWS,
     ACTION_CONTINUE_INTERRUPTED_FLOW,
-    ACTION_SET_INTERRUPTED_FLOWS,
 )
 from rasa.shared.core.domain import Domain
-from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.events import AgentCancelled, Event, FlowCancelled, SlotSet
 from rasa.shared.core.trackers import DialogueStateTracker
 
 FLOW_PATTERN_CONTINUE_INTERRUPTED = (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX + "continue_interrupted"
 )
-INTERRUPTED_FLOWS_SLOT = "interrupted_flows"
 INTERRUPTED_FLOW_TO_CONTINUE_SLOT = "interrupted_flow_to_continue"
-MULTIPLE_FLOWS_INTERRUPTED_SLOT = "multiple_flows_interrupted"
-CONFIRMATION_CONTINUE_INTERRUPTED_FLOW_SLOT = "confirmation_continue_interrupted_flow"
+CONTINUE_INTERRUPTED_FLOW_CONFIRMATION_SLOT = "continue_interrupted_flow_confirmation"
+
+
+structlogger = structlog.get_logger()
 
 
 @dataclass
@@ -34,8 +50,14 @@ class ContinueInterruptedPatternFlowStackFrame(PatternFlowStackFrame):
 
     flow_id: str = FLOW_PATTERN_CONTINUE_INTERRUPTED
     """The ID of the flow."""
-    previous_flow_name: str = ""
-    """The name of the flow that was interrupted."""
+    interrupted_flow_names: List[str] = field(default_factory=list)
+    """The names of the previous flows that were interrupted."""
+    interrupted_flow_ids: List[str] = field(default_factory=list)
+    """The ids of the previous flows that were interrupted."""
+    interrupted_flow_options: str = ""
+    """The options that the user can choose from as a string."""
+    multiple_flows_interrupted: bool = False
+    """Whether the user has interrupted multiple flows."""
 
     @classmethod
     def type(cls) -> str:
@@ -55,7 +77,10 @@ class ContinueInterruptedPatternFlowStackFrame(PatternFlowStackFrame):
         return ContinueInterruptedPatternFlowStackFrame(
             frame_id=data["frame_id"],
             step_id=data["step_id"],
-            previous_flow_name=data["previous_flow_name"],
+            interrupted_flow_names=data["interrupted_flow_names"],
+            interrupted_flow_ids=data["interrupted_flow_ids"],
+            interrupted_flow_options=data["interrupted_flow_options"],
+            multiple_flows_interrupted=len(data["interrupted_flow_names"]) > 1,
         )
 
     def __eq__(self, other: Any) -> bool:
@@ -64,13 +89,15 @@ class ContinueInterruptedPatternFlowStackFrame(PatternFlowStackFrame):
         return (
             self.flow_id == other.flow_id
             and self.step_id == other.step_id
-            and self.previous_flow_name == other.previous_flow_name
+            and self.interrupted_flow_names == other.interrupted_flow_names
+            and self.interrupted_flow_ids == other.interrupted_flow_ids
+            and self.interrupted_flow_options == other.interrupted_flow_options
         )
 
 
-class ActionSetInterruptedFlows(Action):
+class ActionContinueInterruptedFlow(Action):
     def name(self) -> str:
-        return ACTION_SET_INTERRUPTED_FLOWS
+        return ACTION_CONTINUE_INTERRUPTED_FLOW
 
     async def run(
         self,
@@ -79,25 +106,62 @@ class ActionSetInterruptedFlows(Action):
         tracker: DialogueStateTracker,
         domain: Domain,
         metadata: Optional[Dict[Text, Any]] = None,
-    ) -> list[Event]:
-        interrupted_flows_set = set()
-        interrupted_user_flow_stack_frames = tracker.stack.get_all_user_flow_frames()
+    ) -> List[Event]:
+        # get the pattern frame from the stack
+        pattern_frame = get_active_continue_interrupted_pattern_frame(tracker.stack)
+
+        if pattern_frame is None:
+            structlogger.warning(
+                "action.continue_interrupted_flows.no_continue_interrupted_frame"
+            )
+            return []
 
-        for frame in interrupted_user_flow_stack_frames:
-            interrupted_flows_set.add(frame.flow_id)
+        interrupted_flow_ids = pattern_frame.interrupted_flow_ids
+        interrupted_flow_names = pattern_frame.interrupted_flow_names
+        multiple_flows_interrupted = pattern_frame.multiple_flows_interrupted
+
+        flow_to_continue = None
+        if not multiple_flows_interrupted:
+            # the user confirmed that they want to continue the flow
+            # as only one flow was interrupted, we can just continue the first one
+            flow_to_continue = interrupted_flow_ids[0]
+        else:
+            # the user mentioned the flow they want to continue
+            # check if the flow is in the list of interrupted flows
+            selected_flow = tracker.get_slot(INTERRUPTED_FLOW_TO_CONTINUE_SLOT)
+            if selected_flow in interrupted_flow_ids:
+                flow_to_continue = selected_flow
+            elif selected_flow in interrupted_flow_names:
+                # the user mentioned the flow by name
+                # find the flow id for the flow name
+                # the list of names and ids are in the same order
+                flow_to_continue = interrupted_flow_ids[
+                    interrupted_flow_names.index(selected_flow)
+                ]
+
+        # if the user did not select a valid flow,
+        # we need to ask them to select a valid flow
+        if flow_to_continue is None:
+            await output_channel.send_text_message(
+                tracker.sender_id,
+                "You haven't selected a valid task to resume. "
+                "Please specify the task you would like to continue. "
+                "The options are: {{context.interrupted_flow_options}}",
+            )
+            return []
 
-        interrupted_flows = list(interrupted_flows_set)
-        multiple_flows_interrupted = len(interrupted_flows) > 1
+        # resume the flow the user selected
+        events = resume_flow(flow_to_continue, tracker, tracker.stack)
 
-        return [
-            SlotSet(INTERRUPTED_FLOWS_SLOT, interrupted_flows),
-            SlotSet(MULTIPLE_FLOWS_INTERRUPTED_SLOT, multiple_flows_interrupted),
+        return events + [
+            SlotSet(INTERRUPTED_FLOW_TO_CONTINUE_SLOT, None),
+            SlotSet(CONTINUE_INTERRUPTED_FLOW_CONFIRMATION_SLOT, None),
         ]
 
 
-class ActionAskInterruptedFlowToContinue(Action):
+class ActionCancelInterruptedFlows(Action):
     def name(self) -> str:
-        return ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE
+        return ACTION_CANCEL_INTERRUPTED_FLOWS
 
     async def run(
         self,
@@ -107,107 +171,114 @@ class ActionAskInterruptedFlowToContinue(Action):
         domain: Domain,
         metadata: Optional[Dict[Text, Any]] = None,
     ) -> List[Event]:
-        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
-
-        buttons = [
-            {
-                "title": flow_id,
-                "payload": f'/SetSlots{{"{INTERRUPTED_FLOW_TO_CONTINUE_SLOT}": '
-                f'"{flow_id}"}}',
-            }
-            for flow_id in interrupted_flows or []
-        ]
-        buttons.append(
-            {
-                "title": "None of them",
-                "payload": f'/SetSlots{{"{INTERRUPTED_FLOW_TO_CONTINUE_SLOT}": '
-                f'"none"}}',
-            }
-        )
+        # get the pattern frame from the stack
+        pattern_frame = get_active_continue_interrupted_pattern_frame(tracker.stack)
 
-        await output_channel.send_text_with_buttons(
-            tracker.sender_id,
-            "You previously started several other tasks. "
-            "Would you like to resume any of them?",
-            buttons=buttons,
-        )
+        if pattern_frame is None:
+            structlogger.warning(
+                "action.continue_interrupted_flows.no_continue_interrupted_frame"
+            )
+            return []
 
-        return []
+        interrupted_flow_ids = pattern_frame.interrupted_flow_ids
 
+        event_list: List[Event] = []
 
-class ActionContinueInterruptedFlow(Action):
-    def name(self) -> str:
-        return ACTION_CONTINUE_INTERRUPTED_FLOW
+        # cancel all interrupted flows
+        for flow_id in interrupted_flow_ids:
+            event_list.extend(self.cancel_flow(tracker, tracker.stack, flow_id))
 
-    async def run(
+        return event_list + [
+            SlotSet(INTERRUPTED_FLOW_TO_CONTINUE_SLOT, None),
+            SlotSet(CONTINUE_INTERRUPTED_FLOW_CONFIRMATION_SLOT, None),
+        ]
+
+    def cancel_flow(
         self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
         tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[Text, Any]] = None,
+        stack: DialogueStack,
+        flow_id: str,
     ) -> List[Event]:
-        from rasa.dialogue_understanding.commands import StartFlowCommand
-
-        # get all necessary slot values
-        multiple = tracker.get_slot(MULTIPLE_FLOWS_INTERRUPTED_SLOT)
-        selected_flow = tracker.get_slot(INTERRUPTED_FLOW_TO_CONTINUE_SLOT)
-        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
+        """Cancels a flow by flow id."""
+        applied_events: List[Event] = []
 
-        original_user_frame = top_user_flow_frame(tracker.stack)
+        frames_to_cancel, user_frame_to_cancel = self._collect_frames_to_cancel(
+            stack, flow_id
+        )
 
-        # case of multiple interrupted flows, where the user selected a flow to continue
-        if multiple:
-            flow_id = selected_flow if selected_flow else None
-        # case of single interrupted flow, so there is only one flow to continue
-        else:
-            flow_id = interrupted_flows[0] if interrupted_flows else None
-
-        event_list = []
-        if flow_id:
-            # TODO: refactor to avoid creating a StartFlowCommand first
-            # resume the flow with the provided flow id
-            start_flow_command = StartFlowCommand(flow_id)
-            event_list = start_flow_command.resume_flow(
-                tracker, tracker.stack, original_user_frame
-            )
-        else:
-            await output_channel.send_text_message(
-                tracker.sender_id,
-                "You haven't selected a valid task to resume. "
-                "Please specify the task you would like to continue.",
+        # if the flow is not on the stack, do nothing
+        if user_frame_to_cancel is None:
+            structlogger.error(
+                "cancel_flow.no_user_frame_to_cancel",
+                flow_id=flow_id,
             )
+            return []
 
-        return event_list
+        frames_ids_to_cancel = [frame.frame_id for frame in frames_to_cancel]
 
+        stack.push(
+            CancelPatternFlowStackFrame(
+                canceled_name=flow_id,
+                canceled_frames=frames_ids_to_cancel,
+            )
+        )
 
-class ActionCancelInterruptedFlow(Action):
-    def name(self) -> str:
-        return ACTION_CANCEL_INTERRUPTED_FLOW
+        # create flow cancelled event
+        applied_events.extend(
+            [
+                FlowCancelled(
+                    user_frame_to_cancel.flow_id, user_frame_to_cancel.step_id
+                ),
+            ]
+        )
+        # create agent cancelled events for any agent frames that are on the stack
+        for frame in frames_to_cancel:
+            if isinstance(frame, AgentStackFrame):
+                applied_events.append(
+                    AgentCancelled(
+                        frame.agent_id, frame.flow_id, reason="Flow was cancelled"
+                    )
+                )
 
-    async def run(
-        self,
-        output_channel: OutputChannel,
-        nlg: NaturalLanguageGenerator,
-        tracker: DialogueStateTracker,
-        domain: Domain,
-        metadata: Optional[Dict[Text, Any]] = None,
-    ) -> List[Event]:
-        from rasa.dialogue_understanding.commands import CancelFlowCommand
+        update_stack_events = tracker.create_stack_updated_events(stack)
 
-        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
+        return applied_events + update_stack_events
 
-        event_list = []
-        for flow_id in interrupted_flows:
-            # TODO: refactor to avoid creating a CancelFlowCommand first
-            cancel_flow_command = CancelFlowCommand()
-            event_list.extend(
-                cancel_flow_command.cancel_flow(tracker, tracker.stack, flow_id)
-            )
+    def _collect_frames_to_cancel(
+        self, stack: DialogueStack, target_flow_id: str
+    ) -> Tuple[List[DialogueStackFrame], Optional[UserFlowStackFrame]]:
+        """Collect frames that need to be cancelled.
 
-        return event_list + [
-            SlotSet(INTERRUPTED_FLOWS_SLOT, None),
-            SlotSet(INTERRUPTED_FLOW_TO_CONTINUE_SLOT, None),
-            SlotSet(MULTIPLE_FLOWS_INTERRUPTED_SLOT, None),
-            SlotSet(CONFIRMATION_CONTINUE_INTERRUPTED_FLOW_SLOT, None),
-        ]
+        Args:
+            stack: The stack to collect frames from.
+            target_flow_id: The ID of the flow to cancel.
+
+        Returns:
+            A tuple containing (frames_to_cancel, frame_to_cancel).
+        """
+        frames_to_cancel: List[DialogueStackFrame] = []
+        frame_found = False
+        frame_to_cancel = None
+
+        # collect all frames that belong to the target flow
+        # i.e. we want to cancel all frames that are on the stack and between
+        # the user flow frame that belongs to the target flow and the next user
+        # flow frame that belongs to a different flow
+        # this includes any pattern frames or agent frames as well
+        for frame in stack.frames:
+            if isinstance(frame, UserFlowStackFrame) and (
+                frame.frame_type == FlowStackFrameType.REGULAR
+                or frame.frame_type == FlowStackFrameType.INTERRUPT
+            ):
+                if frame.flow_id == target_flow_id:
+                    frames_to_cancel.append(frame)
+                    frame_to_cancel = frame
+                    frame_found = True
+                    continue
+                elif frame_found:
+                    break
+
+            if frame_found:
+                frames_to_cancel.append(frame)
+
+        return list(frames_to_cancel), frame_to_cancel

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -1,16 +1,17 @@
 version: "3.1"
 responses:
 
-  utter_ask_continue_interrupted_flow:
-    - text: "Would you like to continue with {{ context.previous_flow_name }}?"
+  utter_ask_continue_interrupted_flow_confirmation:
+    - text: "Would you like to continue with {{context.interrupted_flow_options}}?"
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_ask_interrupted_flow_to_continue:
+    - text: "Would you like to resume {{context.interrupted_flow_options}}?"
       metadata:
         rephrase: True
         template: jinja
-      buttons:
-        - title: "Yes"
-          payload: "/SetSlots(confirmation_continue_interrupted_flow=true)"
-        - title: "No"
-          payload: "/SetSlots(confirmation_continue_interrupted_flow=false)"
 
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
@@ -129,19 +130,14 @@ slots:
     type: float
     initial_value: 0.0
     max_value: 1000000
-  interrupted_flows:
-    type: list
-  multiple_flows_interrupted:
-    type: bool
-    initial_value: false
-  confirmation_continue_interrupted_flow:
-    type: bool
-    mappings:
-      - type: from_llm
   interrupted_flow_to_continue:
     type: text
     mappings:
       - type: from_llm
+  continue_interrupted_flow_confirmation:
+    type: bool
+    mappings:
+      - type: from_llm
 
 flows:
   pattern_cancel_flow:
@@ -228,10 +224,9 @@ flows:
     description: Conversation repair flow for managing when users switch between different flows
     name: pattern continue interrupted
     steps:
-      - action: action_set_interrupted_flows
       - noop: true
         next:
-          - if: slots.multiple_flows_interrupted
+          - if: context.multiple_flows_interrupted
             then:
               - collect: interrupted_flow_to_continue
                 description: "Fill this slot with the name of the flow the user wants to continue. If the user does not want to continue any of the interrupted flows, fill this slot with 'none'."
@@ -241,19 +236,18 @@ flows:
                       - action: action_continue_interrupted_flow
                         next: END
                   - else:
-                      - action: action_cancel_interrupted_flow
+                      - action: action_cancel_interrupted_flows
                         next: END
           - else:
-            - collect: confirmation_continue_interrupted_flow
+            - collect: continue_interrupted_flow_confirmation
               description: "If the user wants to continue the interrupted flow, fill this slot with true. If the user does not want to continue the interrupted flow, fill this slot with false."
-              utter: utter_ask_continue_interrupted_flow
               next:
-                - if: slots.confirmation_continue_interrupted_flow
+                - if: slots.continue_interrupted_flow_confirmation
                   then:
                     - action: action_continue_interrupted_flow
                       next: END
                 - else:
-                    - action: action_cancel_interrupted_flow
+                    - action: action_cancel_interrupted_flows
                       next: END
 
   pattern_correction:

rasa/dialogue_understanding/stack/utils.py

@@ -17,6 +17,9 @@ from rasa.shared.core.flows.steps.constants import END_STEP
 from rasa.shared.core.flows.steps.continuation import ContinueFlowStep
 
 if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding.patterns.continue_interrupted import (
+        ContinueInterruptedPatternFlowStackFrame,
+    )
     from rasa.shared.core.trackers import DialogueStateTracker
 
 
@@ -171,10 +174,40 @@ def user_flows_on_the_stack(dialogue_stack: DialogueStack) -> Set[str]:
     All user flows that are currently on the stack.
     """
     return {
-        f.flow_id for f in dialogue_stack.frames if isinstance(f, UserFlowStackFrame)
+        frame.flow_id
+        for frame in user_frames_on_the_stack(
+            dialogue_stack, ignore_call_and_link_frames=False
+        )
     }
 
 
+def user_frames_on_the_stack(
+    dialogue_stack: DialogueStack, ignore_call_and_link_frames: bool = True
+) -> List[UserFlowStackFrame]:
+    """Get all user frames that are currently on the stack.
+
+    Args:
+        dialogue_stack: The dialogue stack.
+        ignore_call_and_link_frames: Whether to ignore user frames of type `call`
+            and `link`. By default, these frames are ignored.
+
+    Returns:
+    All user frames that are currently on the stack.
+    """
+    return [
+        frame
+        for frame in dialogue_stack.frames
+        if isinstance(frame, UserFlowStackFrame)
+        and (
+            not ignore_call_and_link_frames
+            or (
+                frame.frame_type != FlowStackFrameType.CALL
+                and frame.frame_type != FlowStackFrameType.LINK
+            )
+        )
+    ]
+
+
 def end_top_user_flow(stack: DialogueStack) -> DialogueStack:
     """Ends all frames on top of the stack including the topmost user frame.
 
@@ -235,13 +268,19 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
 
 def is_continue_interrupted_flow_active(stack: DialogueStack) -> bool:
     """Check if the continue interrupted flow is active."""
+    return get_active_continue_interrupted_pattern_frame(stack) is not None
+
+
+def get_active_continue_interrupted_pattern_frame(
+    stack: DialogueStack,
+) -> Optional["ContinueInterruptedPatternFlowStackFrame"]:
     from rasa.dialogue_understanding.patterns.continue_interrupted import (
         ContinueInterruptedPatternFlowStackFrame,
     )
 
     for frame in reversed(stack.frames):
         if isinstance(frame, ContinueInterruptedPatternFlowStackFrame):
-            return True
+            return frame
         if isinstance(frame, UserFlowStackFrame):
-            return False
-    return False
+            return None
+    return None

rasa/dialogue_understanding/utils.py

@@ -1,9 +1,9 @@
+import typing
 from contextlib import contextmanager
 from typing import Any, Dict, Generator, List, Optional, Text
 
 import structlog
 
-from rasa.dialogue_understanding.commands import Command, NoopCommand, SetSlotCommand
 from rasa.dialogue_understanding.constants import (
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME,
 )
@@ -23,6 +23,9 @@ from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.utils.common import get_bool_env_variable
 
+if typing.TYPE_CHECKING:
+    from rasa.dialogue_understanding.commands import Command
+
 record_commands_and_prompts = get_bool_env_variable(
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME, False
 )
@@ -41,7 +44,7 @@ def set_record_commands_and_prompts() -> Generator:
 
 
 def add_commands_to_message_parse_data(
-    message: Message, component_name: str, commands: List[Command]
+    message: Message, component_name: str, commands: List["Command"]
 ) -> None:
     """Add commands to the message parse data.
 
@@ -144,6 +147,11 @@ def _handle_via_nlu_in_coexistence(
     tracker: Optional[DialogueStateTracker], message: Message
 ) -> bool:
     """Check if the message should be handled by the NLU subsystem in coexistence mode."""  # noqa: E501
+    from rasa.dialogue_understanding.commands import (
+        NoopCommand,
+        SetSlotCommand,
+    )
+
     if not tracker:
         return False
 
@@ -156,8 +164,7 @@ def _handle_via_nlu_in_coexistence(
             "utils.handle_via_nlu_in_coexistence"
             ".tracker_missing_route_session_to_calm_slot",
             event_info=(
-                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot."
-                f"Routing to CALM."
+                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot.Routing to CALM."
             ),
             route_session_to_calm=commands,
         )
@@ -218,3 +225,16 @@ def _handle_via_nlu_in_coexistence(
         commands=commands,
     )
     return False
+
+
+def assemble_options_string(names: List[str], conjunction: str = "and") -> str:
+    """Concatenate options to a human-readable string."""
+    option_message = ""
+    for i, name in enumerate(names):
+        if i == 0:
+            option_message += name
+        elif i == len(names) - 1:
+            option_message += f" {conjunction} {name}"
+        else:
+            option_message += f", {name}"
+    return option_message

rasa/model_training.py

@@ -145,22 +145,23 @@ def _check_unresolved_slots(domain: Domain, stories: StoryGraph) -> None:
 
 
 async def train(
-    domain: Text,
-    config: Text,
-    training_files: Optional[Union[Text, List[Text]]],
-    output: Text = rasa.shared.constants.DEFAULT_MODELS_PATH,
+    domain: str,
+    config: str,
+    training_files: Optional[Union[str, List[str]]],
+    output: str = rasa.shared.constants.DEFAULT_MODELS_PATH,
     dry_run: bool = False,
     force_training: bool = False,
-    fixed_model_name: Optional[Text] = None,
+    fixed_model_name: Optional[str] = None,
     persist_nlu_training_data: bool = False,
     core_additional_arguments: Optional[Dict] = None,
     nlu_additional_arguments: Optional[Dict] = None,
-    model_to_finetune: Optional[Text] = None,
+    model_to_finetune: Optional[str] = None,
     finetuning_epoch_fraction: float = 1.0,
     remote_storage: Optional[StorageType] = None,
     file_importer: Optional[TrainingDataImporter] = None,
     keep_local_model_copy: bool = False,
     remote_root_only: bool = False,
+    sub_agents: Optional[str] = None,
 ) -> TrainingResult:
     """Trains a Rasa model (Core and NLU).
 
@@ -190,6 +191,7 @@ async def train(
             remote storage is configured.
         remote_root_only: If `True`, the model will be stored in the root of the
             remote model storage.
+        sub_agents: Path to sub-agents directory.
 
     Returns:
         An instance of `TrainingResult`.

rasa/shared/constants.py

@@ -249,6 +249,9 @@ _VALIDATE_ENVIRONMENT_MISSING_KEYS_KEY = "missing_keys"
 LLM_API_HEALTH_CHECK_ENV_VAR = "LLM_API_HEALTH_CHECK"
 LLM_API_HEALTH_CHECK_DEFAULT_VALUE = "false"
 
+MCP_API_HEALTH_CHECK_ENV_VAR = "MCP_API_HEALTH_CHECK"
+MCP_API_HEALTH_CHECK_DEFAULT_VALUE = "false"
+
 AWS_REGION_NAME_CONFIG_KEY = "aws_region_name"
 AWS_ACCESS_KEY_ID_CONFIG_KEY = "aws_access_key_id"
 AWS_SECRET_ACCESS_KEY_CONFIG_KEY = "aws_secret_access_key"