rasa-pro 3.14.0.dev5__py3-none-any.whl → 3.14.0.dev7__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:
@@ -81,7 +87,7 @@ responses:
         rephrase: True
 
   utter_inform_hangup:
-    - text: I haven’t heard from you, so I’ll end our conversation shortly.
+    - text: It seems you are not there anymore. I will hang up shortly.
       metadata:
         rephrase: True
 
@@ -124,6 +130,14 @@ slots:
     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

@@ -37,6 +37,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 +429,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):
@@ -529,6 +517,34 @@ 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 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,80 @@ 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
+
+    def get_all_user_flow_frames(
+        self, ignore_call_and_link_frames: bool = True
+    ) -> List[UserFlowStackFrame]:
+        """Get all user flow frames from the dialogue stack.
+
+        Args:
+            ignore_call_and_link_frames: Whether to ignore user frames of type `call`
+                and `link`. By default, these frames are ignored.
+
+        Returns:
+            A list of all user flow frames in the dialogue stack.
+        """
+        return [
+            frame
+            for frame in self.frames
+            if isinstance(frame, UserFlowStackFrame)
+            and (
+                not ignore_call_and_link_frames
+                or (
+                    frame.frame_type != FlowStackFrameType.CALL
+                    and frame.frame_type != FlowStackFrameType.LINK
+                )
+            )
+        ]

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -94,6 +94,18 @@ class InvalidFlowStepIdException(Exception):
         super().__init__(f"Invalid flow step ID '{step_id}' for flow '{flow_id}'.")
 
 
+class InvalidAgentState(RasaException):
+    """Raised if the agent state is invalid."""
+
+    def __init__(self, invalid_state: str) -> None:
+        """Creates a `InvalidAgentState`.
+
+        Args:
+            invalid_state: The invalid agent state.
+        """
+        super().__init__(f"Invalid agent state '{invalid_state}'.")
+
+
 @dataclass
 class BaseFlowStackFrame(DialogueStackFrame):
     flow_id: str = ""  # needed to avoid "default arg before non-default" error
@@ -171,3 +183,48 @@ class UserFlowStackFrame(BaseFlowStackFrame):
             step_id=data["step_id"],
             frame_type=FlowStackFrameType.from_str(data.get("frame_type")),
         )
+
+
+class AgentState(str, Enum):
+    INTERRUPTED = "interrupted"
+    WAITING_FOR_INPUT = "waiting_for_input"
+
+    @staticmethod
+    def from_str(state: Optional[str]) -> AgentState:
+        if state == AgentState.WAITING_FOR_INPUT.value:
+            return AgentState.WAITING_FOR_INPUT
+        elif state == AgentState.INTERRUPTED.value:
+            return AgentState.INTERRUPTED
+        else:
+            raise InvalidAgentState(state)
+
+
+@dataclass
+class AgentStackFrame(BaseFlowStackFrame):
+    agent_id: str = ""
+    state: AgentState = AgentState.WAITING_FOR_INPUT
+    metadata: Optional[Dict[str, Any]] = None
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return "agent"
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> AgentStackFrame:
+        """Creates a `AgentStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `AgentStackFrame` from.
+
+        Returns:
+            The created `AgentStackFrame`.
+        """
+        return AgentStackFrame(
+            frame_id=data["frame_id"],
+            flow_id=data["flow_id"],
+            step_id=data["step_id"],
+            agent_id=data["agent_id"],
+            state=AgentState.from_str(data["state"]),
+            metadata=data.get("metadata"),
+        )