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

rasa/dialogue_understanding/generator/prompt_templates/agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2

@@ -13,13 +13,13 @@ Use the following structured data:
 
 ## Available Actions:
 * `start flow flow_name`: Start a flow. For example, `start flow transfer_money` or `start flow list_contacts`.
-* `set slot slot_name slot_value`: Set a slot for the active flow. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values.
+* `set slot slot_name slot_value`: Set a slot for the active flow. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values. ONLY use slots that are explicitly defined in the flow's slot list.
 * `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: When a message could refer to multiple flows, list the possible flows as options to clarify. Example: `disambiguate flows list_contacts add_contact remove_contact`.
 * `search and reply`: Provide a response from the knowledge base to address the user’s inquiry when no flows fit, including domain knowledge, FAQs, and all off-topic or social messages.
 * `cancel flow`: Cancel the current flow if the user requests it.
 * `repeat message`: Repeat the last bot message.
-{% if active_agent %} * `continue agent`: Continue the currently active agent {{ active_agent.name }}.{% endif %}
-{% if completed_agents %}* `restart agent agent_name`: Restart the agent with the given name, in case the user wants to change some answer to a previous question asked by the agent. For example, `restart agent car_research_agent` if the user chnaged his mind about the car he wants to buy.{% endif %}
+{% if active_agent %} * `continue agent`: Continue the currently active agent {{ active_agent.name }}. This has HIGHEST PRIORITY when an agent is active and the user is responding to agent questions.{% endif %}
+{% if completed_agents %}* `restart agent agent_name`: Restart the agent with the given name, in case the user wants to change some answer to a previous question asked by the agent. For example, `restart agent car_research_agent` if the user changed his mind about the car he wants to buy. ONLY use agents that are listed in the `completed_agents` section.{% endif %}
 
 ---
 
@@ -32,6 +32,7 @@ Use the following structured data:
 * For categorical slots try to match the user message with allowed slot values. Use "other" if you cannot match it.
 * Set the boolean slots based on the user response. Map positive responses to `True`, and negative to `False`.
 * Extract text slot values exactly as provided by the user. Avoid assumptions, format changes, or partial extractions.
+* ONLY use `set slot` with slots that are explicitly defined in the current flow's slot list. Do NOT create or assume slots that don't exist.
 ### Disambiguate Flows
 * Use `disambiguate flows` when the user's message matches multiple flows and you cannot decide which flow is most appropriate.
 * If the user message is short and not precise enough to start a flow or `search and reply`, disambiguate.
@@ -42,29 +43,35 @@ Use the following structured data:
 * Flow Priority: If you are unsure between starting a flow or `search and reply`, always prioritize starting a flow.
 ### Cancel Flow
 * Do not cancel any flow unless the user explicitly requests it.
-* Multiple flows can be started without cancelling the previous, if the user wants to pursue multiple processes.
-### General Tips
+* Multiple flows can be started without cancelling the previous, if the user wants to pursue multiple processes.{% if active_agent or completed_agents %}
+### Agents{% if active_agent %}
+* When an agent is active, ALWAYS prioritize `continue agent` over `search and reply` unless the user is clearly asking something unrelated to the agent's task.{% endif %}{% if completed_agents %}
+* ONLY use `restart agent` with agents that are listed in the `completed_agents` section. Do NOT restart non-existent agents.{% endif %}
+* If you're unsure about agent names, refer to the structured data provided in the `Current State` section.
+{% endif %}### General Tips
 * Only use information provided by the user.
 * Strictly adhere to the provided action format.
+* ONLY use the exact actions listed above. Do NOT invent new actions like "respond <message>" or any other variations.
 * Focus on the last message and take it one step at a time.
 * Use the previous conversation steps only to aid understanding.
 
 ---
 
 ## Decision Rule Table
-| Condition                                             | Action             |
-|-------------------------------------------------------|--------------------|
-| Flow perfectly matches user's message                 | start flow         |
-| Multiple flows are equally strong, relevant matches   | disambiguate flows |
-| User's message is unclear or imprecise                | disambiguate flows |
-| No flow fits at all, but knowledge base may help      | search and reply   |
+| Condition                                                     | Action             |
+|---------------------------------------------------------------|--------------------|{% if active_agent %}
+| Agent is active and the user is responding to agent questions | continue agent     |{% endif %}
+| Flow perfectly matches user's message                         | start flow         |
+| Multiple flows are equally strong, relevant matches           | disambiguate flows |
+| User's message is unclear or imprecise                        | disambiguate flows |
+| No flow fits at all, but knowledge base may help              | search and reply   |
 
 ---
 
 ## Current State
 {% if current_flow != None %}Use the following structured data:
 ```json
-{"active_flow": "{{ current_flow }}","current_step": {"requested_slot": "{{ current_slot }}","requested_slot_description": {{ current_slot_description | to_json_escaped_string }}},"slots": [{% for slot in flow_slots %}{"name": "{{ slot.name }}","value": "{{ slot.value }}","type": "{{ slot.type }}"{{ "," if slot.description or slot.allowed_values else "" }}{% if slot.description %}"description": {{ slot.description | to_json_escaped_string }}{{ "," if slot.allowed_values else "" }}{% endif %}{% if slot.allowed_values %}"allowed_values": "{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% if active_agent or completed_agents %},{% endif %}{% if active_agent %}"active_agent": {"name": "{{ active_agent.name }}","description": "{{ active_agent.description }}"}{% if completed_agents %},{% endif %}{% endif %}{% if completed_agents %}"completed_agents": [{% for agent in completed_agents %}{"name": "{{ agent.name }}","description": "{{ agent.description }}"}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}
+{"active_flow":{"name":"{{ current_flow }}","current_step":{"requested_slot":"{{ current_slot }}","requested_slot_description":{{ current_slot_description | to_json_escaped_string }}},"slots":[{% for slot in flow_slots %}{"name":"{{ slot.name }}","value":"{{ slot.value }}","type":"{{ slot.type }}"{% if slot.description %},"description":{{ slot.description | to_json_escaped_string }}{% endif %}{% if slot.allowed_values %},"allowed_values":"{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}{% if active_agent %},"active_agent":{"name":"{{ active_agent.name }}","description":{{ active_agent.description | to_json_escaped_string }}}{% endif %}{% if completed_agents %},"completed_agents":[{% for agent in completed_agents %}{"name":"{{ agent.name }}","description":{{ agent.description | to_json_escaped_string }}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}
 ```{% else %}
 You are currently not inside any flow.{% endif %}
 

rasa/dialogue_understanding/generator/single_step/single_step_based_llm_command_generator.py

@@ -5,7 +5,10 @@ from typing import Any, Dict, List, Literal, Optional, Text
 import structlog
 
 import rasa.shared.utils.io
-from rasa.core.available_agents import AvailableAgents
+from rasa.agents.utils import (
+    get_active_agent_info,
+    get_completed_agents_info,
+)
 from rasa.dialogue_understanding.commands import (
     CannotHandleCommand,
     Command,
@@ -45,7 +48,6 @@ from rasa.shared.constants import (
     PROMPT_TEMPLATE_CONFIG_KEY,
     ROUTE_TO_CALM_SLOT,
 )
-from rasa.shared.core.events import AgentCompleted
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import ProviderClientAPIException
@@ -416,10 +418,10 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
             "current_slot_type": current_slot_type,
             "current_slot_allowed_values": current_slot_allowed_values,
             "user_message": latest_user_message,
-            "active_agent": self._get_active_agent(tracker, top_flow.id)
+            "active_agent": get_active_agent_info(tracker, top_flow.id)
             if top_flow
             else None,
-            "completed_agents": self._get_completed_agents(tracker),
+            "completed_agents": get_completed_agents_info(tracker),
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)
@@ -467,34 +469,3 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
     ) -> Optional[str]:
         """Get the prompt template from the config or the default prompt template."""
         pass
-
-    def _get_active_agent(
-        self, tracker: DialogueStateTracker, active_flow_id: str
-    ) -> Optional[Dict[str, Any]]:
-        agent_frame = tracker.stack.find_active_agent_stack_frame_for_flow(
-            active_flow_id
-        )
-        if agent_frame:
-            return self._get_agent_info(agent_frame.agent_id)
-        return None
-
-    def _get_completed_agents(
-        self, tracker: DialogueStateTracker
-    ) -> List[Dict[str, Any]]:
-        completed_agents: List[Dict[str, Any]] = []
-        for event in reversed(tracker.events):
-            if isinstance(event, AgentCompleted):
-                agent_info = self._get_agent_info(event.agent_id)
-                if agent_info:
-                    completed_agents.append(agent_info)
-        return completed_agents
-
-    def _get_agent_info(self, agent_id: str) -> Optional[Dict[str, Any]]:
-        agent_config = AvailableAgents.get_agent_config(agent_id)
-        if agent_config is None:
-            return None
-
-        return {
-            "name": agent_config.agent.name,
-            "description": agent_config.agent.description,
-        }

rasa/dialogue_understanding/patterns/cancel.py

@@ -8,10 +8,12 @@ import structlog
 from rasa.core.actions import action
 from rasa.core.channels.channel import OutputChannel
 from rasa.core.nlg.generator import NaturalLanguageGenerator
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
     PatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import AgentStackFrame
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
 from rasa.shared.core.constants import ACTION_CANCEL_FLOW
 from rasa.shared.core.domain import Domain
@@ -30,7 +32,8 @@ class CancelPatternFlowStackFrame(PatternFlowStackFrame):
     """A pattern flow stack frame which cancels a flow.
 
     The frame contains the information about the stack frames that should
-    be canceled."""
+    be canceled.
+    """
 
     flow_id: str = FLOW_PATTERN_CANCEL
     """The ID of the flow."""
@@ -93,19 +96,37 @@ class ActionCancelFlow(action.Action):
             structlogger.warning("action.cancel_flow.no_cancel_frame")
             return []
 
+        agent_frame_ids_to_cancel = []
         for canceled_frame_id in top.canceled_frames:
             for frame in stack.frames:
                 if frame.frame_id == canceled_frame_id and isinstance(
                     frame, BaseFlowStackFrame
                 ):
-                    # Setting the stack frame to the end step so it is properly
-                    # wrapped up by the flow policy
-                    frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
-                    break
+                    if isinstance(frame, AgentStackFrame):
+                        # When an AgentStackFrame needs to be canceled, we can
+                        # remove it directly from the stack. No extra logic is
+                        # required in the flow executor, since
+                        # the AgentCanceled event has already been created by
+                        # ActionCancelInterruptedFlows or CancelFlowCommand, and the
+                        # steps following the agentic call step should not be executed.
+                        agent_frame_ids_to_cancel.append(frame.frame_id)
+                        break
+                    else:
+                        # Setting the stack frame to the end step so it is
+                        # properly wrapped up by the flow policy
+                        frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
+                        break
             else:
                 structlogger.warning(
                     "action.cancel_flow.frame_not_found",
                     frame_id=canceled_frame_id,
                 )
 
-        return tracker.create_stack_updated_events(stack)
+        # Create a copy of the stack without the agentic frames that should
+        # be canceled
+        new_stack = DialogueStack.empty()
+        for frame in stack.frames:
+            if frame.frame_id not in agent_frame_ids_to_cancel:
+                new_stack.push(frame)
+
+        return tracker.create_stack_updated_events(new_stack)

rasa/dialogue_understanding/patterns/clarify.py

@@ -61,19 +61,6 @@ class ActionClarifyFlows(action.Action):
         """Return the flow name."""
         return ACTION_CLARIFY_FLOWS
 
-    @staticmethod
-    def assemble_options_string(names: List[str]) -> str:
-        """Concatenate options to a human-readable string."""
-        clarification_message = ""
-        for i, name in enumerate(names):
-            if i == 0:
-                clarification_message += name
-            elif i == len(names) - 1:
-                clarification_message += f" or {name}"
-            else:
-                clarification_message += f", {name}"
-        return clarification_message
-
     async def run(
         self,
         output_channel: "OutputChannel",
@@ -83,6 +70,8 @@ class ActionClarifyFlows(action.Action):
         metadata: Optional[Dict[str, Any]] = None,
     ) -> List[Event]:
         """Correct the slots."""
+        from rasa.dialogue_understanding.utils import assemble_options_string
+
         stack = tracker.stack
         if not (top := stack.top()):
             structlogger.warning("action.clarify_flows.no_active_flow")
@@ -92,7 +81,7 @@ class ActionClarifyFlows(action.Action):
             structlogger.warning("action.clarify_flows.no_clarification_frame")
             return []
 
-        options_string = self.assemble_options_string(top.names)
+        options_string = assemble_options_string(top.names, conjunction="or")
         top.clarification_options = options_string
         # since we modified the stack frame, we need to update the stack
         return tracker.create_stack_updated_events(stack)

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