rasa-pro 3.14.0.dev20250901__py3-none-any.whl → 3.14.0rc1__py3-none-any.whl

rasa/dialogue_understanding/patterns/continue_interrupted.py

@@ -1,14 +1,47 @@
 from __future__ import annotations
 
-from dataclasses import dataclass
-from typing import Any, Dict
+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.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_CANCEL_INTERRUPTED_FLOWS,
+    ACTION_CONTINUE_INTERRUPTED_FLOW,
+)
+from rasa.shared.core.domain import Domain
+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_FLOW_TO_CONTINUE_SLOT = "interrupted_flow_to_continue"
+CONTINUE_INTERRUPTED_FLOW_CONFIRMATION_SLOT = "continue_interrupted_flow_confirmation"
+
+
+structlogger = structlog.get_logger()
 
 
 @dataclass
@@ -17,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:
@@ -38,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:
@@ -47,5 +89,196 @@ 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 ActionContinueInterruptedFlow(Action):
+    def name(self) -> str:
+        return ACTION_CONTINUE_INTERRUPTED_FLOW
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> 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 []
+
+        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 []
+
+        # resume the flow the user selected
+        events = resume_flow(flow_to_continue, tracker, tracker.stack)
+
+        return events + [
+            SlotSet(INTERRUPTED_FLOW_TO_CONTINUE_SLOT, None),
+            SlotSet(CONTINUE_INTERRUPTED_FLOW_CONFIRMATION_SLOT, None),
+        ]
+
+
+class ActionCancelInterruptedFlows(Action):
+    def name(self) -> str:
+        return ACTION_CANCEL_INTERRUPTED_FLOWS
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> 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 []
+
+        interrupted_flow_ids = pattern_frame.interrupted_flow_ids
+
+        event_list: List[Event] = []
+
+        # cancel all interrupted flows
+        for flow_id in interrupted_flow_ids:
+            event_list.extend(self.cancel_flow(tracker, tracker.stack, flow_id))
+
+        return event_list + [
+            SlotSet(INTERRUPTED_FLOW_TO_CONTINUE_SLOT, None),
+            SlotSet(CONTINUE_INTERRUPTED_FLOW_CONFIRMATION_SLOT, None),
+        ]
+
+    def cancel_flow(
+        self,
+        tracker: DialogueStateTracker,
+        stack: DialogueStack,
+        flow_id: str,
+    ) -> List[Event]:
+        """Cancels a flow by flow id."""
+        applied_events: List[Event] = []
+
+        frames_to_cancel, user_frame_to_cancel = self._collect_frames_to_cancel(
+            stack, flow_id
+        )
+
+        # 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 []
+
+        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,
+            )
+        )
+
+        # 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"
+                    )
+                )
+
+        update_stack_events = tracker.create_stack_updated_events(stack)
+
+        return applied_events + update_stack_events
+
+    def _collect_frames_to_cancel(
+        self, stack: DialogueStack, target_flow_id: str
+    ) -> Tuple[List[DialogueStackFrame], Optional[UserFlowStackFrame]]:
+        """Collect frames that need to be cancelled.
+
+        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,6 +1,18 @@
 version: "3.1"
 responses:
 
+  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
+
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
 
@@ -53,12 +65,6 @@ responses:
         rephrase: True
         template: jinja
 
-  utter_flow_continue_interrupted:
-    - text: "Let's continue with {{ context.previous_flow_name }}."
-      metadata:
-        rephrase: True
-        template: jinja
-
   utter_free_chitchat_response:
     - text: "Sorry, I'm not able to answer that right now."
       metadata:
@@ -118,12 +124,20 @@ slots:
       - type: from_llm
   silence_timeout:
     type: float
-    initial_value: 6.0
+    initial_value: 7.0
     max_value: 1000000
   consecutive_silence_timeouts:
     type: float
     initial_value: 0.0
     max_value: 1000000
+  interrupted_flow_to_continue:
+    type: text
+    mappings:
+      - type: from_llm
+  continue_interrupted_flow_confirmation:
+    type: bool
+    mappings:
+      - type: from_llm
 
 flows:
   pattern_cancel_flow:
@@ -210,7 +224,31 @@ flows:
     description: Conversation repair flow for managing when users switch between different flows
     name: pattern continue interrupted
     steps:
-      - action: utter_flow_continue_interrupted
+      - noop: true
+        next:
+          - 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'."
+                next:
+                  - if: slots.interrupted_flow_to_continue != "none"
+                    then:
+                      - action: action_continue_interrupted_flow
+                        next: END
+                  - else:
+                      - action: action_cancel_interrupted_flows
+                        next: END
+          - else:
+            - 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."
+              next:
+                - if: slots.continue_interrupted_flow_confirmation
+                  then:
+                    - action: action_continue_interrupted_flow
+                      next: END
+                - else:
+                    - action: action_cancel_interrupted_flows
+                      next: END
 
   pattern_correction:
     description: Conversation repair flow for managing user input changes or error corrections

rasa/dialogue_understanding/processor/command_processor.py

@@ -2,16 +2,22 @@ from typing import Dict, List, Optional, Set, Type
 
 import structlog
 
+from rasa.agents.utils import (
+    is_agent_completed,
+    is_agent_valid,
+)
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
     CannotHandleCommand,
     ChitChatAnswerCommand,
     ClarifyCommand,
     Command,
+    ContinueAgentCommand,
     CorrectedSlot,
     CorrectSlotsCommand,
     FreeFormAnswerCommand,
     RepeatBotMessagesCommand,
+    RestartAgentCommand,
     SetSlotCommand,
     StartFlowCommand,
 )
@@ -37,6 +43,7 @@ from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
 )
 from rasa.dialogue_understanding.stack.utils import (
+    is_continue_interrupted_flow_active,
     top_flow_frame,
     top_user_flow_frame,
 )
@@ -428,22 +435,9 @@ def clean_up_commands(
             )
 
         elif isinstance(command, StartFlowCommand):
-            top_user_frame = top_user_flow_frame(
-                tracker.stack, ignore_call_and_link_frames=False
+            clean_commands = clean_up_start_flow_command(
+                clean_commands, tracker, command
             )
-            top_flow_id = top_user_frame.flow_id if top_user_frame else ""
-
-            if top_flow_id == command.flow:
-                # drop a start flow command if the starting flow is equal
-                # to the currently active flow
-                structlogger.debug(
-                    "command_processor.clean_up_commands."
-                    "skip_command_flow_already_active",
-                    command=command,
-                )
-                continue
-
-            clean_commands.append(command)
 
         # handle chitchat command differently from other free-form answer commands
         elif isinstance(command, ChitChatAnswerCommand):
@@ -473,9 +467,42 @@ def clean_up_commands(
                     "drop_clarify_given_other_commands",
                     command=command,
                 )
+
+        # Keep the Restart agent commands only if the command is referencing
+        # a valid agent that was already completed
+        elif isinstance(command, RestartAgentCommand):
+            if not is_agent_valid(command.agent_id):
+                structlogger.debug(
+                    "command_processor.clean_up_commands.skip_restart_agent_invalid_agent",
+                    agent_id=command.agent_id,
+                    command=command,
+                )
+            elif not is_agent_completed(tracker, command.agent_id):
+                structlogger.debug(
+                    "command_processor.clean_up_commands.skip_restart_agent_not_completed",
+                    agent_id=command.agent_id,
+                    command=command,
+                )
+            else:
+                clean_commands.append(command)
+
+        # Clean up Continue agent commands if there is currently no active agent
+        elif isinstance(command, ContinueAgentCommand):
+            if not tracker.stack.agent_is_active():
+                structlogger.debug(
+                    "command_processor.clean_up_commands.skip_continue_agent_no_active_agent",
+                    command=command,
+                )
+            else:
+                clean_commands.append(command)
+
         else:
             clean_commands.append(command)
 
+    # Replace CannotHandleCommands with ContinueAgentCommand when an agent is active
+    # to keep the agent running, but preserve chitchat
+    clean_commands = _replace_cannot_handle_with_continue_agent(clean_commands, tracker)
+
     # when coexistence is enabled, by default there will be a SetSlotCommand
     # for the ROUTE_TO_CALM_SLOT slot.
     if tracker.has_coexistence_routing_slot and len(clean_commands) > 2:
@@ -486,9 +513,14 @@ def clean_up_commands(
     clean_commands = ensure_max_number_of_command_type(
         clean_commands, RepeatBotMessagesCommand, 1
     )
+    clean_commands = ensure_max_number_of_command_type(
+        clean_commands, ContinueAgentCommand, 1
+    )
     structlogger.debug(
         "command_processor.clean_up_commands.final_commands",
         command=clean_commands,
+        event_info="Final commands",
+        highlight=True,
     )
 
     return clean_commands
@@ -529,6 +561,95 @@ def ensure_max_number_of_command_type(
     return filtered
 
 
+def clean_up_start_flow_command(
+    clean_commands: List[Command],
+    tracker: DialogueStateTracker,
+    command: StartFlowCommand,
+) -> List[Command]:
+    """Clean up a start flow command."""
+    continue_interrupted_flow_active = is_continue_interrupted_flow_active(
+        tracker.stack
+    )
+
+    top_user_frame = top_user_flow_frame(
+        tracker.stack, ignore_call_and_link_frames=False
+    )
+    top_flow_id = top_user_frame.flow_id if top_user_frame else ""
+
+    if top_flow_id == command.flow and not continue_interrupted_flow_active:
+        # drop a start flow command if the starting flow is equal
+        # to the currently active flow
+        structlogger.debug(
+            "command_processor.clean_up_commands." "skip_command_flow_already_active",
+            command=command,
+        )
+        return clean_commands
+
+    clean_commands.append(command)
+    return clean_commands
+
+
+def _replace_cannot_handle_with_continue_agent(
+    clean_commands: List[Command],
+    tracker: DialogueStateTracker,
+) -> List[Command]:
+    """Replace CannotHandleCommands with ContinueAgentCommand when agent is active.
+
+    ContinueAgentCommand is added in the following cases:
+
+    1. LLM Command Generation Failures:
+       - LLM parsing failures (default reason)
+       - Force slot filling failures (default reason)
+
+    2. Invalid Commands During Cleanup:
+       - Invalid SetSlot commands:
+         - Slot not in domain
+         - Incompatible extractor
+       (Note: ChitChatAnswer command failures are preserved as CannotHandleCommand)
+
+    3. Empty Commands List:
+       - When all commands are filtered out during cleanup
+
+    Preserved as CannotHandleCommand (not replaced):
+    - Chitchat: CannotHandleCommand(RASA_PATTERN_CANNOT_HANDLE_CHITCHAT)
+    """
+    if not tracker.stack.agent_is_active():
+        return clean_commands
+
+    # If no commands at all and agent is active, add ContinueAgentCommand
+    if not clean_commands:
+        clean_commands.append(ContinueAgentCommand())
+        return clean_commands
+
+    has_continue_agent = any(
+        isinstance(cmd, ContinueAgentCommand) for cmd in clean_commands
+    )
+
+    # Collect CannotHandleCommands that should be replaced with ContinueAgentCommand
+    cannot_handle_commands = [
+        cmd
+        for cmd in clean_commands
+        if isinstance(cmd, CannotHandleCommand)
+        and cmd.reason != RASA_PATTERN_CANNOT_HANDLE_CHITCHAT
+    ]
+
+    if cannot_handle_commands:
+        structlogger.debug(
+            "command_processor.clean_up_commands"
+            ".replace_cannot_handle_with_continue_agent",
+            original_commands=clean_commands,
+        )
+        # Remove the CannotHandleCommands we collected
+        for cmd in cannot_handle_commands:
+            clean_commands.remove(cmd)
+
+        # Add ContinueAgentCommand if not already present
+        if not has_continue_agent:
+            clean_commands.append(ContinueAgentCommand())
+
+    return clean_commands
+
+
 def clean_up_clarify_command(
     commands_so_far: List[Command],
     all_commands: List[Command],

rasa/dialogue_understanding/stack/dialogue_stack.py

@@ -8,6 +8,13 @@ from typing import Any, Callable, Dict, List, Optional
 import jsonpatch
 import structlog
 
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    AgentStackFrame,
+    AgentState,
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+
 if typing.TYPE_CHECKING:
     from rasa.dialogue_understanding.stack.frames import DialogueStackFrame
 
@@ -91,6 +98,42 @@ class DialogueStack:
         """
         return self.frames.pop()
 
+    def move_frames_to_top(self, frames_to_move: List["DialogueStackFrame"]) -> None:
+        """Moves specified frames to top of stack while preserving their relative order.
+
+        Args:
+            frames_to_move: The frames to move to the top of the stack.
+        """
+        # Get frames that are not being moved
+        frames_to_keep = [frame for frame in self.frames if frame not in frames_to_move]
+
+        # Reorder: keep frames first, then moved frames
+        self.frames = frames_to_keep + frames_to_move
+
+        # set all frames to interrupt except for LINK and CALL
+        for frame in self.frames:
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.LINK
+            ):
+                continue
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.CALL
+            ):
+                continue
+            if (
+                isinstance(frame, UserFlowStackFrame)
+                and frame.frame_type == FlowStackFrameType.REGULAR
+            ):
+                frame.frame_type = FlowStackFrameType.INTERRUPT
+
+        # set the first frame to regular
+        for frame in self.frames:
+            if isinstance(frame, UserFlowStackFrame):
+                frame.frame_type = FlowStackFrameType.REGULAR
+                return
+
     def current_context(self) -> Dict[str, Any]:
         """Returns the context of the topmost frame.
 
@@ -109,7 +152,7 @@ class DialogueStack:
         """Returns the topmost frame from the stack.
 
         Args:
-            ignore_frame: The ID of the flow to ignore. Picks the top most
+            ignore: The ID of the flow to ignore. Picks the top most
                 frame that has a different flow ID.
 
         Returns:
@@ -136,7 +179,8 @@ class DialogueStack:
             patch_dump: The patch to apply to the stack.
 
         Returns:
-            The updated stack."""
+        The updated stack.
+        """
         patch = jsonpatch.JsonPatch.from_string(patch_dump)
         dialogue_stack_dump = patch.apply(self.as_dict())
         return DialogueStack.from_dict(dialogue_stack_dump)
@@ -177,3 +221,55 @@ class DialogueStack:
         if patch:
             return patch.to_string()
         return None
+
+    def _find_agent_frame_by_predicate(
+        self, predicate: Callable[[AgentStackFrame], bool]
+    ) -> List[AgentStackFrame]:
+        stack_frames: List[AgentStackFrame] = []
+        for stack_frame in reversed(self.frames):
+            if isinstance(stack_frame, AgentStackFrame) and predicate(stack_frame):
+                stack_frames.append(stack_frame)
+        return stack_frames
+
+    def find_active_agent_frame(self) -> Optional[AgentStackFrame]:
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.state == AgentState.WAITING_FOR_INPUT
+        )
+        if stack_frames:
+            return stack_frames[0]
+        return None
+
+    def find_agent_stack_frame_by_agent(
+        self, agent_id: str
+    ) -> Optional[AgentStackFrame]:
+        """Get the agent stack frame for a specific agent ID.
+
+        May also include the agent stack frame in the INTERRUPTED state.
+        """
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.agent_id == agent_id
+        )
+        if stack_frames:
+            return stack_frames[0]
+        return None
+
+    def find_active_agent_stack_frame_for_flow(
+        self, flow_id: str
+    ) -> Optional[AgentStackFrame]:
+        """Get the agent stack frame of a specific flow."""
+        stack_frames = self._find_agent_frame_by_predicate(
+            lambda frame: frame.flow_id == flow_id
+        )
+        for stack_frame in stack_frames:
+            if stack_frame.state == AgentState.WAITING_FOR_INPUT:
+                return stack_frame
+        return None
+
+    def get_active_agent_id(self) -> Optional[typing.Text]:
+        agent_frame = self.find_active_agent_frame()
+        if agent_frame:
+            return agent_frame.agent_id
+        return None
+
+    def agent_is_active(self) -> bool:
+        return self.find_active_agent_frame() is not None