rasa-pro 3.13.12__py3-none-any.whl → 3.14.0__py3-none-any.whl

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,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: It seems you are not there anymore. I will hang up shortly.
+    - text: I haven’t heard from you, so I’ll end our conversation shortly.
       metadata:
         rephrase: True
 
@@ -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,33 @@ 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
+          - else: collect_continue_interrupted_flow_confirmation
+      - id: collect_interrupted_flow_to_continue
+        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
+      - id: collect_continue_interrupted_flow_confirmation
+        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],