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

rasa/dialogue_understanding/generator/prompt_templates/agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2

@@ -0,0 +1,81 @@
+## Task Description
+Your task is to analyze the current conversation context and generate a list of actions to start new business processes that we call flows, to extract slots, or respond to off-topic and knowledge requests.
+
+---
+
+## Available Flows and Slots
+Use the following structured data:
+```json
+{"flows":[{% for flow in available_flows %}{"name":"{{ flow.name }}","description":{{ flow.description | to_json_escaped_string }}{% if flow.agent_info %},"sub-agents":[{% for agent in flow.agent_info %}{"name":"{{ agent.name }}","description":{{ agent.description | to_json_escaped_string }}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}{% if flow.slots %},"slots":[{% for slot in flow.slots %}{"name":"{{ slot.name }}"{% if slot.description %},"description":{{ slot.description | to_json_escaped_string }}{% endif %}{% if slot.allowed_values %},"allowed_values":{{ slot.allowed_values }}{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]}
+```
+
+---
+
+## Available Actions:
+* `start flow flow_name`: Start a flow. For example, `start flow transfer_money` or `start flow list_contacts`.
+* `set slot slot_name slot_value`: Set a slot for the active flow. For example, `set slot transfer_money_recipient Freddy`. Can be used to correct and change previously set values.
+* `disambiguate flows flow_name1 flow_name2 ... flow_name_n`: When a message could refer to multiple flows, list the possible flows as options to clarify. Example: `disambiguate flows list_contacts add_contact remove_contact`.
+* `search and reply`: Provide a response from the knowledge base to address the user’s inquiry when no flows fit, including domain knowledge, FAQs, and all off-topic or social messages.
+* `cancel flow`: Cancel the current flow if the user requests it.
+* `repeat message`: Repeat the last bot message.
+{% if active_agent %} * `continue agent`: Continue the currently active agent {{ active_agent.name }}.{% endif %}
+{% if completed_agents %}* `restart agent agent_name`: Restart the agent with the given name, in case the user wants to change some answer to a previous question asked by the agent. For example, `restart agent car_research_agent` if the user chnaged his mind about the car he wants to buy.{% endif %}
+
+---
+
+## General Instructions
+### Start Flow
+* Only start a flow if the user's message is clear and fully addressed by that flow's description and purpose.
+* Pay close attention to exact wording and scope in the flow description — do not assume or “stretch” the intended use of a flow.
+### Set Slot
+* Do not fill slots with abstract values or placeholders.
+* For categorical slots try to match the user message with allowed slot values. Use "other" if you cannot match it.
+* Set the boolean slots based on the user response. Map positive responses to `True`, and negative to `False`.
+* Extract text slot values exactly as provided by the user. Avoid assumptions, format changes, or partial extractions.
+### Disambiguate Flows
+* Use `disambiguate flows` when the user's message matches multiple flows and you cannot decide which flow is most appropriate.
+* If the user message is short and not precise enough to start a flow or `search and reply`, disambiguate.
+* If a single flow is a strong/plausible fit, prefer starting that flow directly.
+* If a user's message unambiguously and distinctly matches multiple flows, start all relevant flows at once (rather than disambiguating).
+### Search and Reply
+* Only start `search and reply` if the user intent is clear.
+* Flow Priority: If you are unsure between starting a flow or `search and reply`, always prioritize starting a flow.
+### Cancel Flow
+* Do not cancel any flow unless the user explicitly requests it.
+* Multiple flows can be started without cancelling the previous, if the user wants to pursue multiple processes.
+### General Tips
+* Only use information provided by the user.
+* Strictly adhere to the provided action format.
+* Focus on the last message and take it one step at a time.
+* Use the previous conversation steps only to aid understanding.
+
+---
+
+## Decision Rule Table
+| Condition                                             | Action             |
+|-------------------------------------------------------|--------------------|
+| Flow perfectly matches user's message                 | start flow         |
+| Multiple flows are equally strong, relevant matches   | disambiguate flows |
+| User's message is unclear or imprecise                | disambiguate flows |
+| No flow fits at all, but knowledge base may help      | search and reply   |
+
+---
+
+## Current State
+{% if current_flow != None %}Use the following structured data:
+```json
+{"active_flow": "{{ current_flow }}","current_step": {"requested_slot": "{{ current_slot }}","requested_slot_description": {{ current_slot_description | to_json_escaped_string }}},"slots": [{% for slot in flow_slots %}{"name": "{{ slot.name }}","value": "{{ slot.value }}","type": "{{ slot.type }}"{{ "," if slot.description or slot.allowed_values else "" }}{% if slot.description %}"description": {{ slot.description | to_json_escaped_string }}{{ "," if slot.allowed_values else "" }}{% endif %}{% if slot.allowed_values %}"allowed_values": "{{ slot.allowed_values }}"{% endif %}}{% if not loop.last %},{% endif %}{% endfor %}]{% if active_agent or completed_agents %},{% endif %}{% if active_agent %}"active_agent": {"name": "{{ active_agent.name }}","description": "{{ active_agent.description }}"}{% if completed_agents %},{% endif %}{% endif %}{% if completed_agents %}"completed_agents": [{% for agent in completed_agents %}{"name": "{{ agent.name }}","description": "{{ agent.description }}"}{% if not loop.last %},{% endif %}{% endfor %}]{% endif %}}
+```{% else %}
+You are currently not inside any flow.{% endif %}
+
+---
+
+## Conversation History
+{{ current_conversation }}
+
+---
+
+## Task
+Create an action list with one action per line in response to the user's last message: """{{ user_message }}""".
+
+Your action list:

rasa/dialogue_understanding/generator/single_step/compact_llm_command_generator.py

@@ -45,29 +45,30 @@ DEFAULT_LLM_CONFIG = {
     TIMEOUT_CONFIG_KEY: 7,
 }
 
+# TODO: only load the agent prompt template in cases where agents are actually used
 MODEL_PROMPT_MAPPER = {
     f"{OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+        "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AZURE_OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+        "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AWS_BEDROCK_PROVIDER}/anthropic.{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}-v1:0": (
-        "command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
+        "agent_command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
     ),
     f"{ANTHROPIC_PROVIDER}/{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}": (
-        "command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
+        "agent_command_prompt_v2_claude_3_5_sonnet_20240620_template.jinja2"
     ),
 }
 
 # When model is not configured, then we use the default prompt template
 DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+    "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
 )
 # When the configured model is not found in the model prompt mapper, then we use the
 # fallback prompt template
 FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
+    "agent_command_prompt_v2_gpt_4o_2024_11_20_template.jinja2"
 )
 
 

rasa/dialogue_understanding/generator/single_step/search_ready_llm_command_generator.py

@@ -44,25 +44,26 @@ DEFAULT_LLM_CONFIG = {
     TIMEOUT_CONFIG_KEY: 7,
 }
 
+# TODO: only load the agent prompt template in cases where agents are actually used
 DEFAULT_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+    "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
 )
 FALLBACK_COMMAND_PROMPT_TEMPLATE_FILE_NAME = (
-    "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+    "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
 )
 MODEL_PROMPT_MAPPER = {
     f"{OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+        "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AZURE_OPENAI_PROVIDER}/{MODEL_NAME_GPT_4O_2024_11_20}": (
-        "command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
+        "agent_command_prompt_v3_gpt_4o_2024_11_20_template.jinja2"
     ),
     f"{AWS_BEDROCK_PROVIDER}/anthropic."
     f"{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}-v1:0": (
-        "command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
+        "agent_command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
     ),
     f"{ANTHROPIC_PROVIDER}/{MODEL_NAME_CLAUDE_3_5_SONNET_20240620}": (
-        "command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
+        "agent_command_prompt_v3_claude_3_5_sonnet_20240620_template.jinja2"
     ),
 }
 

rasa/dialogue_understanding/generator/single_step/single_step_based_llm_command_generator.py

@@ -5,6 +5,7 @@ from typing import Any, Dict, List, Literal, Optional, Text
 import structlog
 
 import rasa.shared.utils.io
+from rasa.core.available_agents import AvailableAgents
 from rasa.dialogue_understanding.commands import (
     CannotHandleCommand,
     Command,
@@ -44,6 +45,7 @@ from rasa.shared.constants import (
     PROMPT_TEMPLATE_CONFIG_KEY,
     ROUTE_TO_CALM_SLOT,
 )
+from rasa.shared.core.events import AgentCompleted
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import ProviderClientAPIException
@@ -396,13 +398,15 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
             current_slot_allowed_values = allowed_values_for_slot(
                 tracker.slots.get(current_slot)
             )
-        current_conversation = tracker_as_readable_transcript(tracker)
+        current_conversation = tracker_as_readable_transcript(
+            tracker, highlight_agent_turns=True
+        )
         latest_user_message = sanitize_message_for_prompt(message.get(TEXT))
         current_conversation += f"\nUSER: {latest_user_message}"
 
         inputs = {
             "available_flows": self.prepare_flows_for_template(
-                startable_flows, tracker
+                startable_flows, tracker, add_agent_info=True
             ),
             "current_conversation": current_conversation,
             "flow_slots": flow_slots,
@@ -412,6 +416,10 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
             "current_slot_type": current_slot_type,
             "current_slot_allowed_values": current_slot_allowed_values,
             "user_message": latest_user_message,
+            "active_agent": self._get_active_agent(tracker, top_flow.id)
+            if top_flow
+            else None,
+            "completed_agents": self._get_completed_agents(tracker),
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)
@@ -459,3 +467,34 @@ class SingleStepBasedLLMCommandGenerator(LLMBasedCommandGenerator, ABC):
     ) -> Optional[str]:
         """Get the prompt template from the config or the default prompt template."""
         pass
+
+    def _get_active_agent(
+        self, tracker: DialogueStateTracker, active_flow_id: str
+    ) -> Optional[Dict[str, Any]]:
+        agent_frame = tracker.stack.find_active_agent_stack_frame_for_flow(
+            active_flow_id
+        )
+        if agent_frame:
+            return self._get_agent_info(agent_frame.agent_id)
+        return None
+
+    def _get_completed_agents(
+        self, tracker: DialogueStateTracker
+    ) -> List[Dict[str, Any]]:
+        completed_agents: List[Dict[str, Any]] = []
+        for event in reversed(tracker.events):
+            if isinstance(event, AgentCompleted):
+                agent_info = self._get_agent_info(event.agent_id)
+                if agent_info:
+                    completed_agents.append(agent_info)
+        return completed_agents
+
+    def _get_agent_info(self, agent_id: str) -> Optional[Dict[str, Any]]:
+        agent_config = AvailableAgents.get_agent_config(agent_id)
+        if agent_config is None:
+            return None
+
+        return {
+            "name": agent_config.agent.name,
+            "description": agent_config.agent.description,
+        }

rasa/dialogue_understanding/patterns/continue_interrupted.py

@@ -1,14 +1,31 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict
+from typing import Any, Dict, List, Optional, Text
 
+from rasa.core.actions.action import Action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
 from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.constants import (
+    ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE,
+    ACTION_CANCEL_INTERRUPTED_FLOW,
+    ACTION_CONTINUE_INTERRUPTED_FLOW,
+    ACTION_SET_INTERRUPTED_FLOWS,
+)
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.trackers import DialogueStateTracker
 
 FLOW_PATTERN_CONTINUE_INTERRUPTED = (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX + "continue_interrupted"
 )
+INTERRUPTED_FLOWS_SLOT = "interrupted_flows"
+INTERRUPTED_FLOW_TO_CONTINUE_SLOT = "interrupted_flow_to_continue"
+MULTIPLE_FLOWS_INTERRUPTED_SLOT = "multiple_flows_interrupted"
+CONFIRMATION_CONTINUE_INTERRUPTED_FLOW_SLOT = "confirmation_continue_interrupted_flow"
 
 
 @dataclass
@@ -49,3 +66,148 @@ class ContinueInterruptedPatternFlowStackFrame(PatternFlowStackFrame):
             and self.step_id == other.step_id
             and self.previous_flow_name == other.previous_flow_name
         )
+
+
+class ActionSetInterruptedFlows(Action):
+    def name(self) -> str:
+        return ACTION_SET_INTERRUPTED_FLOWS
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> list[Event]:
+        interrupted_flows_set = set()
+        interrupted_user_flow_stack_frames = tracker.stack.get_all_user_flow_frames()
+
+        for frame in interrupted_user_flow_stack_frames:
+            interrupted_flows_set.add(frame.flow_id)
+
+        interrupted_flows = list(interrupted_flows_set)
+        multiple_flows_interrupted = len(interrupted_flows) > 1
+
+        return [
+            SlotSet(INTERRUPTED_FLOWS_SLOT, interrupted_flows),
+            SlotSet(MULTIPLE_FLOWS_INTERRUPTED_SLOT, multiple_flows_interrupted),
+        ]
+
+
+class ActionAskInterruptedFlowToContinue(Action):
+    def name(self) -> str:
+        return ACTION_ASK_INTERRUPTED_FLOW_TO_CONTINUE
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
+
+        buttons = [
+            {
+                "title": flow_id,
+                "payload": f'/SetSlots{{"{INTERRUPTED_FLOW_TO_CONTINUE_SLOT}": '
+                f'"{flow_id}"}}',
+            }
+            for flow_id in interrupted_flows or []
+        ]
+        buttons.append(
+            {
+                "title": "None of them",
+                "payload": f'/SetSlots{{"{INTERRUPTED_FLOW_TO_CONTINUE_SLOT}": '
+                f'"none"}}',
+            }
+        )
+
+        await output_channel.send_text_with_buttons(
+            tracker.sender_id,
+            "You previously started several other tasks. "
+            "Would you like to resume any of them?",
+            buttons=buttons,
+        )
+
+        return []
+
+
+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]:
+        from rasa.dialogue_understanding.commands import StartFlowCommand
+
+        # get all necessary slot values
+        multiple = tracker.get_slot(MULTIPLE_FLOWS_INTERRUPTED_SLOT)
+        selected_flow = tracker.get_slot(INTERRUPTED_FLOW_TO_CONTINUE_SLOT)
+        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
+
+        original_user_frame = top_user_flow_frame(tracker.stack)
+
+        # case of multiple interrupted flows, where the user selected a flow to continue
+        if multiple:
+            flow_id = selected_flow if selected_flow else None
+        # case of single interrupted flow, so there is only one flow to continue
+        else:
+            flow_id = interrupted_flows[0] if interrupted_flows else None
+
+        event_list = []
+        if flow_id:
+            # TODO: refactor to avoid creating a StartFlowCommand first
+            # resume the flow with the provided flow id
+            start_flow_command = StartFlowCommand(flow_id)
+            event_list = start_flow_command.resume_flow(
+                tracker, tracker.stack, original_user_frame
+            )
+        else:
+            await output_channel.send_text_message(
+                tracker.sender_id,
+                "You haven't selected a valid task to resume. "
+                "Please specify the task you would like to continue.",
+            )
+
+        return event_list
+
+
+class ActionCancelInterruptedFlow(Action):
+    def name(self) -> str:
+        return ACTION_CANCEL_INTERRUPTED_FLOW
+
+    async def run(
+        self,
+        output_channel: OutputChannel,
+        nlg: NaturalLanguageGenerator,
+        tracker: DialogueStateTracker,
+        domain: Domain,
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        from rasa.dialogue_understanding.commands import CancelFlowCommand
+
+        interrupted_flows = tracker.get_slot(INTERRUPTED_FLOWS_SLOT) or []
+
+        event_list = []
+        for flow_id in interrupted_flows:
+            # TODO: refactor to avoid creating a CancelFlowCommand first
+            cancel_flow_command = CancelFlowCommand()
+            event_list.extend(
+                cancel_flow_command.cancel_flow(tracker, tracker.stack, flow_id)
+            )
+
+        return event_list + [
+            SlotSet(INTERRUPTED_FLOWS_SLOT, None),
+            SlotSet(INTERRUPTED_FLOW_TO_CONTINUE_SLOT, None),
+            SlotSet(MULTIPLE_FLOWS_INTERRUPTED_SLOT, None),
+            SlotSet(CONFIRMATION_CONTINUE_INTERRUPTED_FLOW_SLOT, None),
+        ]

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -1,6 +1,17 @@
 version: "3.1"
 responses:
 
+  utter_ask_continue_interrupted_flow:
+    - text: "Would you like to continue with {{ context.previous_flow_name }}?"
+      metadata:
+        rephrase: True
+        template: jinja
+      buttons:
+        - title: "Yes"
+          payload: "/SetSlots(confirmation_continue_interrupted_flow=true)"
+        - title: "No"
+          payload: "/SetSlots(confirmation_continue_interrupted_flow=false)"
+
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
 
@@ -53,12 +64,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 +86,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 +129,19 @@ slots:
     type: float
     initial_value: 0.0
     max_value: 1000000
+  interrupted_flows:
+    type: list
+  multiple_flows_interrupted:
+    type: bool
+    initial_value: false
+  confirmation_continue_interrupted_flow:
+    type: bool
+    mappings:
+      - type: from_llm
+  interrupted_flow_to_continue:
+    type: text
+    mappings:
+      - type: from_llm
 
 flows:
   pattern_cancel_flow:
@@ -210,7 +228,33 @@ flows:
     description: Conversation repair flow for managing when users switch between different flows
     name: pattern continue interrupted
     steps:
-      - action: utter_flow_continue_interrupted
+      - action: action_set_interrupted_flows
+      - noop: true
+        next:
+          - if: slots.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_flow
+                        next: END
+          - else:
+            - collect: confirmation_continue_interrupted_flow
+              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."
+              utter: utter_ask_continue_interrupted_flow
+              next:
+                - if: slots.confirmation_continue_interrupted_flow
+                  then:
+                    - action: action_continue_interrupted_flow
+                      next: END
+                - else:
+                    - action: action_cancel_interrupted_flow
+                      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],