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

rasa/dialogue_understanding/commands/__init__.py

@@ -8,6 +8,9 @@ from rasa.dialogue_understanding.commands.chit_chat_answer_command import (
 )
 from rasa.dialogue_understanding.commands.clarify_command import ClarifyCommand
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.continue_agent_command import (
+    ContinueAgentCommand,
+)
 from rasa.dialogue_understanding.commands.correct_slots_command import (
     CorrectedSlot,
     CorrectSlotsCommand,
@@ -29,6 +32,9 @@ from rasa.dialogue_understanding.commands.noop_command import NoopCommand
 from rasa.dialogue_understanding.commands.repeat_bot_messages_command import (
     RepeatBotMessagesCommand,
 )
+from rasa.dialogue_understanding.commands.restart_agent_command import (
+    RestartAgentCommand,
+)
 from rasa.dialogue_understanding.commands.restart_command import RestartCommand
 from rasa.dialogue_understanding.commands.session_end_command import SessionEndCommand
 from rasa.dialogue_understanding.commands.session_start_command import (
@@ -62,4 +68,6 @@ __all__ = [
     "SessionEndCommand",
     "RepeatBotMessagesCommand",
     "RestartCommand",
+    "ContinueAgentCommand",
+    "RestartAgentCommand",
 ]

rasa/dialogue_understanding/commands/cancel_flow_command.py

@@ -6,6 +6,9 @@ from typing import Any, Dict, List
 
 import structlog
 
+from rasa.core.policies.flows.flow_executor import (
+    remove_agent_stack_frame,
+)
 from rasa.dialogue_understanding.commands.command import Command
 from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxManager,
@@ -18,7 +21,7 @@ from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     UserFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
-from rasa.shared.core.events import Event, FlowCancelled
+from rasa.shared.core.events import AgentCancelled, Event, FlowCancelled
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -48,8 +51,7 @@ class CancelFlowCommand(Command):
         """Selects the frames that were canceled.
 
         Args:
-            dialogue_stack: The dialogue stack.
-            current_flow: The current flow.
+            stack: The dialogue stack.
 
         Returns:
         The frames that were canceled.
@@ -71,8 +73,7 @@ class CancelFlowCommand(Command):
             # we should never get here as we should always find the user flow
             # that was canceled.
             raise ValueError(
-                f"Could not find a user flow frame to cancel. "
-                f"Current stack: {stack}."
+                f"Could not find a user flow frame to cancel. Current stack: {stack}."
             )
 
     def run_command_on_tracker(
@@ -106,6 +107,19 @@ class CancelFlowCommand(Command):
             )
             return []
 
+        if agent_frame := original_tracker.stack.find_active_agent_stack_frame_for_flow(
+            current_flow.id
+        ):
+            structlogger.debug(
+                "cancel_command.remove_agent_stack_frame",
+                command=self,
+                frame=agent_frame,
+            )
+            remove_agent_stack_frame(stack, agent_frame.agent_id)
+            applied_events.append(
+                AgentCancelled(agent_id=agent_frame.agent_id, flow_id=current_flow.id)
+            )
+
         # we pass in the original dialogue stack (before any of the currently
         # predicted commands were applied) to make sure we don't cancel any
         # frames that were added by the currently predicted commands.

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -12,6 +12,10 @@ from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
 from rasa.dialogue_understanding.patterns.chitchat import ChitchatPatternFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -52,6 +56,13 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
             The events to apply to the tracker.
         """
         stack = tracker.stack
+
+        # if the top stack frame is an agent stack frame, we need to
+        # update the state to INTERRUPTED
+        if top_stack_frame := stack.top():
+            if isinstance(top_stack_frame, AgentStackFrame):
+                top_stack_frame.state = AgentState.INTERRUPTED
+
         stack.push(ChitchatPatternFlowStackFrame())
         return tracker.create_stack_updated_events(stack)
 

rasa/dialogue_understanding/commands/clarify_command.py

@@ -13,6 +13,10 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
 )
 from rasa.dialogue_understanding.commands.utils import extract_cleaned_options
 from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -85,6 +89,12 @@ class ClarifyCommand(Command):
             if flow is not None
         ]
 
+        # if the top stack frame is an agent stack frame, we need to
+        # update the state to INTERRUPTED
+        if top_stack_frame := stack.top():
+            if isinstance(top_stack_frame, AgentStackFrame):
+                top_stack_frame.state = AgentState.INTERRUPTED
+
         stack.push(ClarifyPatternFlowStackFrame(names=names))
         return tracker.create_stack_updated_events(stack)
 

rasa/dialogue_understanding/commands/continue_agent_command.py

@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+
+from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class ContinueAgentCommand(Command):
+    """A command to continue the currently active agent's execution."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "continue agent"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> ContinueAgentCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        return ContinueAgentCommand()
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        # do nothing
+        return []
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, ContinueAgentCommand)
+
+    def to_dsl(self) -> str:
+        """Converts the command to a DSL string."""
+        mapper = {
+            CommandSyntaxVersion.v1: "ContinueAgent()",
+            CommandSyntaxVersion.v2: "continue agent",
+            CommandSyntaxVersion.v3: "continue agent",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
+
+    @classmethod
+    def from_dsl(cls, match: re.Match, **kwargs: Any) -> ContinueAgentCommand:
+        """Converts a DSL string to a command."""
+        return ContinueAgentCommand()
+
+    @staticmethod
+    def regex_pattern() -> str:
+        mapper = {
+            CommandSyntaxVersion.v1: r"ContinueAgent\(\)",
+            CommandSyntaxVersion.v2: r"""^[\s\W\d]*continue agent['"`]*$""",
+            CommandSyntaxVersion.v3: r"""^[\s\W\d]*continue agent['"`]*$""",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -12,6 +12,10 @@ from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
 from rasa.dialogue_understanding.patterns.search import SearchPatternFlowStackFrame
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -52,6 +56,13 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
             The events to apply to the tracker.
         """
         stack = tracker.stack
+
+        # if the top stack frame is an agent stack frame, we need to
+        # update the state to INTERRUPTED
+        if top_stack_frame := stack.top():
+            if isinstance(top_stack_frame, AgentStackFrame):
+                top_stack_frame.state = AgentState.INTERRUPTED
+
         stack.push(SearchPatternFlowStackFrame())
         return tracker.create_stack_updated_events(stack)
 

rasa/dialogue_understanding/commands/restart_agent_command.py

@@ -0,0 +1,162 @@
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from typing import Any, Dict, List, Optional
+
+from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+)
+from rasa.shared.core.events import AgentStarted, Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.steps import CallFlowStep
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@dataclass
+class RestartAgentCommand(Command):
+    """A command to restart an agentic loop within a flow."""
+
+    agent_id: str
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return "restart agent"
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> RestartAgentCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        try:
+            return RestartAgentCommand(agent_id=data["agent_id"])
+        except KeyError as e:
+            raise ValueError(
+                f"Missing parameter '{e}' while parsing RestartAgentCommand."
+            ) from e
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+
+        # get the agent flow
+        agent_flow_id = self._get_agent_flow(original_tracker)
+
+        # create a new agent stack frame to restart the agent
+        restart_agent_frame = self.create_restart_agent_stack_frame(
+            all_flows, agent_flow_id
+        )
+
+        # if the stack contains an agent stack frame with status
+        # "waiting for input" update the status to "interrupted"
+        self.update_agent_stack_frames_on_stack(stack)
+
+        # push the stack frame on the top of the stack
+        stack.push(restart_agent_frame)
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.command())
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(other, RestartAgentCommand)
+
+    def to_dsl(self) -> str:
+        """Converts the command to a DSL string."""
+        mapper = {
+            CommandSyntaxVersion.v1: f"RestartAgent({self.agent_id})",
+            CommandSyntaxVersion.v2: f"restart agent {self.agent_id}",
+            CommandSyntaxVersion.v3: f"restart agent {self.agent_id}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
+
+    @classmethod
+    def from_dsl(cls, match: re.Match, **kwargs: Any) -> RestartAgentCommand:
+        """Converts a DSL string to a command."""
+        return RestartAgentCommand(agent_id=str(match.group(1).strip()))
+
+    @staticmethod
+    def regex_pattern() -> str:
+        mapper = {
+            CommandSyntaxVersion.v1: r"RestartAgent\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)",
+            CommandSyntaxVersion.v2: (
+                r"""^[\s\W\d]*restart agent ['"`]?([a-zA-Z0-9_-]+)['"`]*"""
+            ),
+            CommandSyntaxVersion.v3: (
+                r"""^[\s\W\d]*restart agent ['"`]?([a-zA-Z0-9_-]+)['"`]*"""
+            ),
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
+
+    def create_restart_agent_stack_frame(
+        self, all_flows: FlowsList, agent_flow_id: str
+    ) -> AgentStackFrame:
+        # get the agent flow
+        agent_flow = all_flows.flow_by_id(agent_flow_id)
+        if not agent_flow:
+            raise ValueError(f"Agent flow {agent_flow_id} not found")
+
+        # find the call flow step for the agent
+        # set the state to "waiting for input" so that the agent can process
+        # the latest user message
+        for step in agent_flow.steps:
+            if isinstance(step, CallFlowStep) and step.call == self.agent_id:
+                return AgentStackFrame(
+                    frame_id=f"restart_agent_{self.agent_id}",
+                    flow_id=agent_flow_id,
+                    step_id=step.id,
+                    agent_id=self.agent_id,
+                    state=AgentState.WAITING_FOR_INPUT,
+                )
+
+        raise ValueError(f"Call step in agent flow {agent_flow_id} not found")
+
+    def update_agent_stack_frames_on_stack(self, stack: DialogueStack) -> None:
+        for frame in stack.frames:
+            if (
+                isinstance(frame, AgentStackFrame)
+                and frame.state == AgentState.WAITING_FOR_INPUT
+            ):
+                frame.state = AgentState.INTERRUPTED
+
+    def _get_agent_flow(self, tracker: DialogueStateTracker) -> Optional[str]:
+        # find events associated with the agent
+        agent_started_events = [
+            event
+            for event in tracker.events
+            if type(event) == AgentStarted and event.agent_id == self.agent_id
+        ]
+        # take the last one if the agent was started multiple times
+        if agent_started_events:
+            return agent_started_events[-1].flow_id
+        return None

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -11,15 +11,25 @@ from rasa.dialogue_understanding.commands.command_syntax_manager import (
     CommandSyntaxManager,
     CommandSyntaxVersion,
 )
+from rasa.dialogue_understanding.commands.utils import (
+    remove_pattern_continue_interrupted_frames,
+    resume_flow,
+)
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentState,
     FlowStackFrameType,
     UserFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.utils import (
+    is_continue_interrupted_flow_active,
     top_user_flow_frame,
     user_flows_on_the_stack,
 )
-from rasa.shared.core.events import Event, FlowInterrupted
+from rasa.shared.core.events import (
+    AgentInterrupted,
+    Event,
+    FlowInterrupted,
+)
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 
@@ -71,12 +81,7 @@ class StartFlowCommand(Command):
         original_stack = original_tracker.stack
         applied_events: List[Event] = []
 
-        if self.flow in user_flows_on_the_stack(stack):
-            structlogger.debug(
-                "start_flow_command.skip_command.already_started_flow", command=self
-            )
-            return []
-        elif self.flow not in all_flows.flow_ids:
+        if self.flow not in all_flows.flow_ids:
             structlogger.debug(
                 "start_flow_command.skip_command.start_invalid_flow_id", command=self
             )
@@ -87,9 +92,47 @@ class StartFlowCommand(Command):
             original_user_frame.flow(all_flows) if original_user_frame else None
         )
 
+        # if the original top flow is the same as the flow to start, the flow is
+        # already active, do nothing
+        if original_top_flow is not None and original_top_flow.id == self.flow:
+            # in case continue_interrupted is not active, skip the already active start
+            # flow command
+            if not is_continue_interrupted_flow_active(stack):
+                return []
+
+            # if the continue interrupted flow is active, and the command generator
+            # predicted a start flow command for the flow which is on top of the stack,
+            # we just need to remove the pattern_continue_interrupted frame(s) from the
+            # stack
+            stack = remove_pattern_continue_interrupted_frames(stack)
+            return applied_events + tracker.create_stack_updated_events(stack)
+
+        # if the flow is already on the stack, resume it
+        if (
+            self.flow in user_flows_on_the_stack(stack)
+            and original_user_frame is not None
+        ):
+            # if pattern_continue_interrupted is active, we need to remove it
+            # from the stack before resuming the flow
+            stack = remove_pattern_continue_interrupted_frames(stack)
+            applied_events.extend(resume_flow(self.flow, tracker, stack))
+            # the current active flow is interrupted
+            applied_events.append(
+                FlowInterrupted(
+                    original_user_frame.flow_id, original_user_frame.step_id
+                )
+            )
+            return applied_events
+
         frame_type = FlowStackFrameType.REGULAR
 
+        # remove the pattern_continue_interrupted frames from the stack
+        # if it is currently active but the user digressed from the pattern
+        stack = remove_pattern_continue_interrupted_frames(stack)
+
         if original_top_flow:
+            # if the original top flow is not the same as the flow to start,
+            # interrupt the current active flow
             frame_type = FlowStackFrameType.INTERRUPT
 
             if original_user_frame is not None:
@@ -99,6 +142,24 @@ class StartFlowCommand(Command):
                     )
                 )
 
+            # If there is an active agent frame, interrupt it
+            active_agent_stack_frame = stack.find_active_agent_frame()
+            if active_agent_stack_frame:
+                structlogger.debug(
+                    "start_flow_command.interrupt_agent",
+                    command=self,
+                    agent_id=active_agent_stack_frame.agent_id,
+                    frame_id=active_agent_stack_frame.frame_id,
+                    flow_id=active_agent_stack_frame.flow_id,
+                )
+                active_agent_stack_frame.state = AgentState.INTERRUPTED
+                applied_events.append(
+                    AgentInterrupted(
+                        active_agent_stack_frame.agent_id,
+                        active_agent_stack_frame.flow_id,
+                    )
+                )
+
         structlogger.debug("start_flow_command.start_flow", command=self)
         stack.push(UserFlowStackFrame(flow_id=self.flow, frame_type=frame_type))
         return applied_events + tracker.create_stack_updated_events(stack)

rasa/dialogue_understanding/commands/utils.py

@@ -5,8 +5,23 @@ import structlog
 from rasa.dialogue_understanding.patterns.validate_slot import (
     ValidateSlotPatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+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.frames.pattern_frame import PatternFlowStackFrame
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
-from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.events import (
+    AgentResumed,
+    Event,
+    FlowResumed,
+    SlotSet,
+)
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -103,7 +118,8 @@ def create_validate_frames_from_slot_set_events(
     Args:
         tracker: The dialogue state tracker.
         events: List of events to process.
-        should_break:  whether or not to break after the first non-SlotSet event.
+        validate_frames: List to collect validation frames.
+        should_break:  whether to break after the first non-SlotSet event.
             if True, break out of the event loop as soon as the first non-SlotSet
             event is encountered.
             if False, continue processing the events until the end.
@@ -150,3 +166,109 @@ def find_default_flows_collecting_slot(
             for step in flow.get_collect_steps()
         )
     ]
+
+
+def resume_flow(
+    flow_to_resume: str,
+    tracker: DialogueStateTracker,
+    stack: DialogueStack,
+) -> List[Event]:
+    """Resumes a flow by reordering frames."""
+    applied_events: List[Event] = []
+
+    # Resume existing flow by reordering frames
+    frames_to_resume, user_frame_to_resume = collect_frames_to_resume(
+        stack, flow_to_resume
+    )
+
+    # if the flow is not on the stack, do nothing
+    # this should not happen, but just in case
+    if user_frame_to_resume is None:
+        structlogger.error(
+            "resume_flow.no_user_frame_to_resume",
+            flow_to_resume=flow_to_resume,
+        )
+        return []
+
+    # move the frames to the top of the stack, e.g. reorder the frames
+    # on the stack
+    stack.move_frames_to_top(frames_to_resume)
+
+    # create agent resumed events if the agent frame is now on top of the stack
+    agent_stack_frame = next(
+        (frame for frame in frames_to_resume if isinstance(frame, AgentStackFrame)),
+        None,
+    )
+    if agent_stack_frame:
+        agent_id = agent_stack_frame.agent_id
+        applied_events.append(AgentResumed(agent_id, agent_stack_frame.flow_id))
+
+    # Create flow interruption and resumption events
+    applied_events.extend(
+        [
+            # the flow, which was on the stack, is resumed
+            FlowResumed(user_frame_to_resume.flow_id, user_frame_to_resume.step_id),
+        ]
+    )
+
+    return applied_events + tracker.create_stack_updated_events(stack)
+
+
+def collect_frames_to_resume(
+    stack: DialogueStack,
+    target_flow_id: str,  # pyright: ignore[reportUndefinedVariable]
+) -> Tuple[List[DialogueStackFrame], Optional[UserFlowStackFrame]]:
+    """Collect frames that need to be resumed for the target flow.
+
+    Args:
+        stack: The stack to collect frames from.
+        target_flow_id: The ID of the flow to resume.
+
+    Returns:
+        A tuple containing (frames_to_resume, frame_to_resume).
+    """
+    frames_to_resume: List[DialogueStackFrame] = []
+    frame_found = False
+    frame_to_resume = None
+
+    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_resume.append(frame)
+                frame_to_resume = frame
+                frame_found = True
+                continue
+            elif frame_found:
+                break
+
+        if frame_found:
+            frames_to_resume.append(frame)
+
+    return list(frames_to_resume), frame_to_resume
+
+
+def remove_pattern_continue_interrupted_frames(stack: DialogueStack) -> DialogueStack:
+    """Remove pattern_continue_interrupted frames from the stack."""
+    from rasa.dialogue_understanding.stack.utils import (
+        is_continue_interrupted_flow_active,
+    )
+
+    if not is_continue_interrupted_flow_active(stack):
+        return stack
+
+    # remove pattern_continue_interrupted from the stack
+    top_frame = stack.top()
+    while isinstance(top_frame, PatternFlowStackFrame):
+        # If the top frame is a pattern frame, we need to remove it
+        # before continuing with the active user flow frame.
+        # This prevents the pattern frame
+        # from being left on the stack when the flow is started
+        # which would prevent pattern_completed to be triggered
+        # once the user flow is completed.
+        stack.pop()
+        top_frame = stack.top()
+
+    return stack

rasa/dialogue_understanding/generator/command_parser.py

@@ -9,9 +9,11 @@ from rasa.dialogue_understanding.commands import (
     ChitChatAnswerCommand,
     ClarifyCommand,
     Command,
+    ContinueAgentCommand,
     HumanHandoffCommand,
     KnowledgeAnswerCommand,
     RepeatBotMessagesCommand,
+    RestartAgentCommand,
     SetSlotCommand,
     SkipQuestionCommand,
     StartFlowCommand,
@@ -34,6 +36,8 @@ DEFAULT_COMMANDS = [
     HumanHandoffCommand,
     ClarifyCommand,
     RepeatBotMessagesCommand,
+    ContinueAgentCommand,
+    RestartAgentCommand,
 ]