rasa-pro 3.12.0.dev9__py3-none-any.whl → 3.12.0.dev10__py3-none-any.whl

rasa/dialogue_understanding/generator/nlu_command_adapter.py

@@ -98,9 +98,11 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
         Returns:
             The commands triggered by NLU.
         """
+        prior_commands = self._get_prior_commands(message)
+
         if tracker is None or flows.is_empty():
             # cannot do anything if there are no flows or no tracker
-            return []
+            return prior_commands
 
         domain = kwargs.get("domain", None)
         commands = self.convert_nlu_to_commands(message, tracker, flows, domain)
@@ -146,7 +148,7 @@ class NLUCommandAdapter(GraphComponent, CommandGenerator):
                 commands=commands,
             )
 
-        return commands
+        return prior_commands + commands
 
     @staticmethod
     def convert_nlu_to_commands(

rasa/dialogue_understanding/generator/single_step/command_prompt_template.jinja2

@@ -1,58 +1,58 @@
 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 small talk and knowledge requests.
 
-
-## Available Actions:
-* Starting a flow, described by "start flow_name". For example, "start transfer_money" or "start list_contacts"
-* Slot setting, described by "set slot_name slot_value". For example, "set transfer_money_recipient Freddy". Can be used to correct and change previously set values.
-* Cancelling the current flow, described by "cancel"
-* Clarifying which flow should be started in ambiguous cases. For example, "clarify list_contacts add_contact remove_contact" if the user just wrote "contacts" and there are multiple potential candidates.
-* Skipping the current question when the user explicitly asks for it, described by "skip".
-* Responding to knowledge-oriented user messages, described by "search"
-* Responding to a casual, non-task-oriented user message, described by "chat".
-* Handing over to a human, in case the user seems frustrated or explicitly asks to speak to one, described by "hand over".
-
-
-## General Tips
-* Do not fill slots with abstract values or placeholders.
-* Only use information provided by the user.
-* Use clarification in ambiguous cases.
-* Multiple flows can be started. If a user wants to digress into a second flow, you do not need to cancel the current flow.
-* Strictly adhere to the provided action format.
-* For categorical slots try to match the user message with potential slot values. Use "other" if you cannot match it
-* Focus on the last message and take it one step at a time.
-* Use the previous conversation steps only to aid understanding.
-
-
-## Available Flows:
+These are the flows that can be started, with their description and slots:
 {% for flow in available_flows %}
-* {{ flow.name }}: {{ flow.description }}
+{{ flow.name }}: {{ flow.description }}
     {% for slot in flow.slots -%}
-    * {{ slot.name }}{% if slot.description %} ({{ slot.description }}){% endif %}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
+    slot: {{ slot.name }}{% if slot.description %} ({{ slot.description }}){% endif %}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
     {% endfor %}
 {%- endfor %}
 
+===
+Here is what happened previously in the conversation:
+{{ current_conversation }}
 
-## Current State
+===
 {% if current_flow != None %}
 You are currently in the flow "{{ current_flow }}".
 You have just asked the user for the slot "{{ current_slot }}"{% if current_slot_description %} ({{ current_slot_description }}){% endif %}.
 
 {% if flow_slots|length > 0 %}
-Here are the slots of the flow "{{ current_flow }}":
+Here are the slots of the currently active flow:
 {% for slot in flow_slots -%}
-* name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}, description: {{ slot.description}}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
+- name: {{ slot.name }}, value: {{ slot.value }}, type: {{ slot.type }}, description: {{ slot.description}}{% if slot.allowed_values %}, allowed values: {{ slot.allowed_values }}{% endif %}
 {% endfor %}
 {% endif %}
 {% else %}
-You are currently not inside any flow.
+You are currently not in any flow and so there are no active slots.
+This means you can only set a slot if you first start a flow that requires that slot.
 {% endif %}
-
-
-## Conversation History
-{{ current_conversation }}
-
-
-## Task
-Create an action list with one action per line in response to the users last message: """{{ user_message }}""".
-
-Your action list:
+If you start a flow, first start the flow and then optionally fill that flow's slots with information the user provided in their message.
+
+The user just said """{{ user_message }}""".
+
+===
+Based on this information generate a list of actions you want to take. Your job is to start flows and to fill slots where appropriate. Any logic of what happens afterwards is handled by the flow engine. These are your available actions:
+* Slot setting, described by "SetSlot(slot_name, slot_value)". An example would be "SetSlot(recipient, Freddy)"
+* Starting another flow, described by "StartFlow(flow_name)". An example would be "StartFlow(transfer_money)"
+* Cancelling the current flow, described by "CancelFlow()"
+* Clarifying which flow should be started. An example would be Clarify(list_contacts, add_contact, remove_contact) if the user just wrote "contacts" and there are multiple potential candidates. It also works with a single flow name to confirm you understood correctly, as in Clarify(transfer_money).
+* Intercepting and handle user messages with the intent to bypass the current step in the flow, described by "SkipQuestion()". Examples of user skip phrases are: "Go to the next question", "Ask me something else".
+* Responding to knowledge-oriented user messages, described by "SearchAndReply()"
+* Responding to a casual, non-task-oriented user message, described by "ChitChat()".
+* Handing off to a human, in case the user seems frustrated or explicitly asks to speak to one, described by "HumanHandoff()".
+* Repeat the last bot messages, described by "RepeatLastBotMessages()". This is useful when the user asks to repeat the last bot messages.
+
+===
+Write out the actions you want to take, one per line, in the order they should take place.
+Do not fill slots with abstract values or placeholders.
+Only use information provided by the user.
+Only start a flow if it's completely clear what the user wants. Imagine you were a person reading this message. If it's not 100% clear, clarify the next step.
+Don't be overly confident. Take a conservative approach and clarify before proceeding.
+If the user asks for two things which seem contradictory, clarify before starting a flow.
+If it's not clear whether the user wants to skip the step or to cancel the flow, cancel the flow.
+Strictly adhere to the provided action types listed above.
+Focus on the last message and take it one step at a time.
+Use the previous conversation steps only to aid understanding.
+
+Your action list:

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -51,7 +51,6 @@ from rasa.shared.utils.llm import (
     sanitize_message_for_prompt,
     tracker_as_readable_transcript,
 )
-from rasa.utils.beta import BetaNotEnabledException, ensure_beta_feature_is_enabled
 from rasa.utils.log_utils import log_llm
 
 COMMAND_PROMPT_FILE_NAME = "command_prompt.jinja2"
@@ -111,7 +110,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         )
 
         self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
-        self.repeat_command_enabled = self.is_repeat_command_enabled()
 
     ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
@@ -198,9 +196,14 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         Returns:
             The commands generated by the llm.
         """
+        prior_commands = self._get_prior_commands(message)
+
         if tracker is None or flows.is_empty():
             # cannot do anything if there are no flows or no tracker
-            return []
+            return prior_commands
+
+        if self._should_skip_llm_call(prior_commands, flows, tracker):
+            return prior_commands
 
         try:
             commands = await self._predict_commands(message, flows, tracker)
@@ -209,7 +212,7 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             # "predict" the ErrorCommand
             commands = [ErrorCommand()]
 
-        if not commands:
+        if not commands and not prior_commands:
             # no commands are parsed or there's an invalid command
             structlogger.warning(
                 "single_step_llm_command_generator.predict_commands",
@@ -230,7 +233,10 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             commands=commands,
         )
 
-        return commands
+        domain = kwargs.get("domain")
+        commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
+
+        return prior_commands + commands
 
     async def _predict_commands(
         self,
@@ -406,20 +412,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             "current_slot": current_slot,
             "current_slot_description": current_slot_description,
             "user_message": latest_user_message,
-            "is_repeat_command_enabled": self.repeat_command_enabled,
         }
 
         return self.compile_template(self.prompt_template).render(**inputs)
-
-    def is_repeat_command_enabled(self) -> bool:
-        """Check for feature flag"""
-        RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME = "RASA_PRO_BETA_REPEAT_COMMAND"
-        try:
-            ensure_beta_feature_is_enabled(
-                "Repeat Command",
-                env_flag=RASA_PRO_BETA_REPEAT_COMMAND_ENV_VAR_NAME,
-            )
-        except BetaNotEnabledException:
-            return False
-
-        return True

rasa/dialogue_understanding/patterns/correction.py

@@ -54,6 +54,8 @@ class CorrectionPatternFlowStackFrame(PatternFlowStackFrame):
     """The ID of the flow to reset to."""
     reset_step_id: Optional[str] = None
     """The ID of the step to reset to."""
+    new_slot_values: List[Any] = field(default_factory=list)
+    """The new values for the corrected slots."""
 
     @classmethod
     def type(cls) -> str:
@@ -70,6 +72,10 @@ class CorrectionPatternFlowStackFrame(PatternFlowStackFrame):
         Returns:
             The created `DialogueStackFrame`.
         """
+        new_slot_values = [
+            val.get("value") for _, val in data["corrected_slots"].items()
+        ]
+
         return CorrectionPatternFlowStackFrame(
             frame_id=data["frame_id"],
             step_id=data["step_id"],
@@ -77,6 +83,7 @@ class CorrectionPatternFlowStackFrame(PatternFlowStackFrame):
             corrected_slots=data["corrected_slots"],
             reset_flow_id=data["reset_flow_id"],
             reset_step_id=data["reset_step_id"],
+            new_slot_values=new_slot_values,
         )
 
 
@@ -118,7 +125,12 @@ class ActionCorrectFlowSlot(action.Action):
             )
             events.extend(tracker.create_stack_updated_events(updated_stack))
 
-        events.extend([SlotSet(k, v) for k, v in top.corrected_slots.items()])
+        events.extend(
+            [
+                SlotSet(name, value=val.get("value"), filled_by=val.get("filled_by"))
+                for name, val in top.corrected_slots.items()
+            ]
+        )
         return events
 
 

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -1,6 +1,17 @@
 version: "3.1"
 responses:
 
+  utter_ask_continue_previous_flow:
+    - text: "Confirm if you would like to continue with the initial topic: {{context.interrupted_flow_id}}?"
+      metadata:
+        rephrase: True
+        template: jinja
+      buttons:
+        - title: Continue with the previous topic.
+          payload: /SetSlots(continue_previous_flow=True)
+        - title: Switch to new topic.
+          payload: /SetSlots(continue_previous_flow=False)
+
   utter_ask_rephrase:
     - text: I’m sorry I am unable to understand you, could you please rephrase?
 
@@ -9,6 +20,20 @@ responses:
       metadata:
         rephrase: True
 
+  utter_block_digressions:
+    - text: "We can look into {{ context.interrupting_flow_id }} later. Let's focus on the current topic: {{ context.interrupted_flow_id }}."
+      metadata:
+        rephrase: True
+        template: jinja
+    - text: "Let's continue with the current topic: {{ context.interrupted_flow_id }}."
+      condition:
+        - type: slot
+          name: continue_previous_flow
+          value: True
+      metadata:
+        rephrase: True
+        template: jinja
+
   utter_boolean_slot_rejection:
     - text: "Sorry, the value you provided, `{{value}}`, is not valid. Please respond with a valid value."
       metadata:
@@ -35,8 +60,14 @@ responses:
         rephrase: True
         template: jinja
 
+  utter_continue_interruption:
+    - text: "Let's continue with the chosen topic instead: {{ context.interrupting_flow_id }}."
+      metadata:
+        rephrase: True
+        template: jinja
+
   utter_corrected_previous_input:
-    - text: "Ok, I am updating {{ context.corrected_slots.keys()|join(', ') }} to {{ context.corrected_slots.values()|join(', ') }} respectively."
+    - text: "Ok, I am updating {{ context.corrected_slots.keys()|join(', ') }} to {{ context.new_slot_values | join(', ') }} respectively."
       metadata:
         rephrase: True
         template: jinja
@@ -119,7 +150,10 @@ slots:
     type: float
     initial_value: 0.0
     max_value: 1000000
-
+  continue_previous_flow:
+    type: bool
+    mappings:
+      - type: from_llm
 
 flows:
   pattern_cancel_flow:
@@ -163,6 +197,7 @@ flows:
     steps:
       - action: action_clarify_flows
       - action: utter_clarification_options_rasa
+      - action: action_listen
 
   pattern_code_change:
     description: Conversation repair flow for cleaning the stack after an assistant update
@@ -212,6 +247,31 @@ flows:
                 next: END
           - else: END
 
+  pattern_handle_digressions:
+    description: Conversation repair flow for handling digressions
+    name: pattern handle digressions
+    steps:
+      - noop: true
+        id: branching
+        next:
+          - if: context.ask_confirm_digressions contains context.interrupting_flow_id
+            then: continue_previous_flow
+          - if: context.block_digressions contains context.interrupting_flow_id
+            then: block_digression
+          - else: continue_digression
+      - id: continue_previous_flow
+        collect: continue_previous_flow
+        next:
+          - if: slots.continue_previous_flow
+            then: block_digression
+          - else: continue_digression
+      - id: block_digression
+        action: action_block_digression
+        next: END
+      - id: continue_digression
+        action: action_continue_digression
+        next: END
+
   pattern_human_handoff:
     description: Conversation repair flow for switching users to a human agent if their request can't be handled
     name: pattern human handoff

rasa/dialogue_understanding/patterns/handle_digressions.py

@@ -0,0 +1,81 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, Set
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.constants import (
+    KEY_ASK_CONFIRM_DIGRESSIONS,
+    KEY_BLOCK_DIGRESSIONS,
+)
+
+FLOW_PATTERN_HANDLE_DIGRESSIONS = (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX + "handle_digressions"
+)
+
+
+@dataclass
+class HandleDigressionsPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame that gets added if an interruption is completed."""
+
+    flow_id: str = FLOW_PATTERN_HANDLE_DIGRESSIONS
+    """The ID of the flow."""
+    interrupting_flow_id: str = ""
+    """The ID of the flow that interrupted the active flow."""
+    interrupted_flow_id: str = ""
+    """The name of the active flow that was interrupted."""
+    interrupted_step_id: str = ""
+    """The ID of the step that was interrupted."""
+    ask_confirm_digressions: Set[str] = field(default_factory=set)
+    """The set of interrupting flow names to confirm."""
+    block_digressions: Set[str] = field(default_factory=set)
+    """The set of interrupting flow names to block."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_HANDLE_DIGRESSIONS
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> HandleDigressionsPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return HandleDigressionsPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            interrupted_step_id=data["interrupted_step_id"],
+            interrupted_flow_id=data["interrupted_flow_id"],
+            interrupting_flow_id=data["interrupting_flow_id"],
+            ask_confirm_digressions=set(data.get(KEY_ASK_CONFIRM_DIGRESSIONS, [])),
+            # This attribute must be converted to a set to enable usage
+            # of subset `contains` pypred operator in the default pattern
+            # conditional branching
+            block_digressions=set(data.get(KEY_BLOCK_DIGRESSIONS, [])),
+        )
+
+    def __eq__(self, other: Any) -> bool:
+        if not isinstance(other, HandleDigressionsPatternFlowStackFrame):
+            return False
+        return (
+            self.flow_id == other.flow_id
+            and self.interrupted_step_id == other.interrupted_step_id
+            and self.interrupted_flow_id == other.interrupted_flow_id
+            and self.interrupting_flow_id == other.interrupting_flow_id
+            and self.ask_confirm_digressions == other.ask_confirm_digressions
+            and self.block_digressions == other.block_digressions
+        )
+
+    def as_dict(self) -> Dict[str, Any]:
+        """Returns the frame as a dictionary."""
+        data = super().as_dict()
+        # converting back to list to avoid serialization issues
+        data[KEY_ASK_CONFIRM_DIGRESSIONS] = list(self.ask_confirm_digressions)
+        data[KEY_BLOCK_DIGRESSIONS] = list(self.block_digressions)
+        return data

rasa/dialogue_understanding/processor/command_processor.py

@@ -18,6 +18,9 @@ from rasa.dialogue_understanding.commands import (
 from rasa.dialogue_understanding.commands.handle_code_change_command import (
     HandleCodeChangeCommand,
 )
+from rasa.dialogue_understanding.commands.handle_digressions_command import (
+    HandleDigressionsCommand,
+)
 from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.patterns.collect_information import (
@@ -42,6 +45,8 @@ from rasa.shared.constants import (
 from rasa.shared.core.constants import (
     ACTION_TRIGGER_CHITCHAT,
     FLOW_HASHES_SLOT,
+    KEY_ALLOW_NLU_CORRECTION,
+    KEY_MAPPING_TYPE,
     SlotMappingType,
 )
 from rasa.shared.core.events import Event, SlotSet
@@ -395,6 +400,28 @@ def clean_up_commands(
                 command=command,
             )
 
+        elif isinstance(command, StartFlowCommand) and active_flow is not None:
+            # push handle digressions command if we are at a collect step of
+            # a flow and a new flow is started
+            collect_info = get_current_collect_step(tracker.stack, all_flows)
+            current_flow = all_flows.flow_by_id(active_flow)
+            current_flow_condition = current_flow and (
+                current_flow.ask_confirm_digressions or current_flow.block_digressions
+            )
+
+            if collect_info and (
+                collect_info.ask_confirm_digressions
+                or collect_info.block_digressions
+                or current_flow_condition
+            ):
+                clean_commands.append(HandleDigressionsCommand(flow=command.flow))
+                structlogger.debug(
+                    "command_processor.clean_up_commands.push_handle_digressions",
+                    command=command,
+                )
+            else:
+                clean_commands.append(command)
+
         # handle chitchat command differently from other free-form answer commands
         elif isinstance(command, ChitChatAnswerCommand):
             clean_commands = clean_up_chitchat_command(
@@ -527,13 +554,48 @@ def clean_up_slot_command(
         )
         return resulting_commands
 
-    if not should_slot_be_set(slot, command):
+    if not should_slot_be_set(slot, command, resulting_commands):
+        structlogger.debug(
+            "command_processor.clean_up_slot_command.skip_command.extractor_"
+            "does_not_match_slot_mapping",
+            extractor=command.extractor,
+            slot_name=slot.name,
+        )
+
+        # prevent adding a cannot handle command in case commands_so_far already
+        # contains a valid prior set slot command for the same slot whose current
+        # slot command was rejected by should_slot_be_set
+        slot_command_exists_already = any(
+            isinstance(command, SetSlotCommand) and command.name == slot.name
+            for command in resulting_commands
+        )
+
         cannot_handle = CannotHandleCommand(reason=CANNOT_HANDLE_REASON)
-        if cannot_handle not in resulting_commands:
+        if not slot_command_exists_already and cannot_handle not in resulting_commands:
             resulting_commands.append(cannot_handle)
 
         return resulting_commands
 
+    if (
+        slot.filled_by == SetSlotExtractor.NLU.value
+        and command.extractor == SetSlotExtractor.LLM.value
+    ):
+        allow_nlu_correction = any(
+            [
+                mapping.get(KEY_ALLOW_NLU_CORRECTION, False)
+                for mapping in slot.mappings
+                if mapping.get(KEY_MAPPING_TYPE) == SlotMappingType.FROM_LLM.value
+            ]
+        )
+
+        if not allow_nlu_correction:
+            structlogger.debug(
+                "command_processor.clean_up_slot_command"
+                ".skip_command.disallow_llm_correction_of_nlu_set_value",
+                command=command,
+            )
+            return resulting_commands
+
     if command.name in slots_so_far and command.name != ROUTE_TO_CALM_SLOT:
         current_collect_info = get_current_collect_step(stack, all_flows)
 
@@ -574,7 +636,7 @@ def clean_up_slot_command(
         )
 
         # Group all corrections into one command
-        corrected_slot = CorrectedSlot(command.name, command.value)
+        corrected_slot = CorrectedSlot(command.name, command.value, command.extractor)
         for c in resulting_commands:
             if isinstance(c, CorrectSlotsCommand):
                 c.corrected_slots.append(corrected_slot)
@@ -658,7 +720,9 @@ def clean_up_chitchat_command(
     return resulting_commands
 
 
-def should_slot_be_set(slot: Slot, command: SetSlotCommand) -> bool:
+def should_slot_be_set(
+    slot: Slot, command: SetSlotCommand, commands_so_far: Optional[List[Command]] = None
+) -> bool:
     """Check if a slot should be set by a command."""
     if command.extractor == SetSlotExtractor.COMMAND_PAYLOAD_READER.value:
         # if the command is issued by the command payload reader, it means the slot
@@ -666,37 +730,62 @@ def should_slot_be_set(slot: Slot, command: SetSlotCommand) -> bool:
         # we can always set it
         return True
 
+    if commands_so_far is None:
+        commands_so_far = []
+
+    set_slot_commands_so_far = [
+        command
+        for command in commands_so_far
+        if isinstance(command, SetSlotCommand) and command.name == slot.name
+    ]
+
     slot_mappings = slot.mappings
 
-    if not slot_mappings:
-        slot_mappings = [{"type": SlotMappingType.FROM_LLM.value}]
+    if not slot.mappings:
+        slot_mappings = [{KEY_MAPPING_TYPE: SlotMappingType.FROM_LLM.value}]
 
-    for mapping in slot_mappings:
-        mapping_type = SlotMappingType(
-            mapping.get("type", SlotMappingType.FROM_LLM.value)
-        )
+    mapping_types = [
+        SlotMappingType(mapping.get(KEY_MAPPING_TYPE, SlotMappingType.FROM_LLM.value))
+        for mapping in slot_mappings
+    ]
 
-        should_be_set_by_llm = (
-            command.extractor == SetSlotExtractor.LLM.value
-            and mapping_type == SlotMappingType.FROM_LLM
-        )
-        should_be_set_by_nlu = (
-            command.extractor == SetSlotExtractor.NLU.value
-            and mapping_type.is_predefined_type()
+    slot_has_nlu_mapping = any(
+        [mapping_type.is_predefined_type() for mapping_type in mapping_types]
+    )
+    slot_has_llm_mapping = any(
+        [mapping_type == SlotMappingType.FROM_LLM for mapping_type in mapping_types]
+    )
+    slot_has_custom_mapping = any(
+        [mapping_type == SlotMappingType.CUSTOM for mapping_type in mapping_types]
+    )
+
+    if set_slot_commands_so_far and command.extractor == SetSlotExtractor.LLM.value:
+        # covers the following scenarios:
+        # scenario 1: NLU mapping extracts a value for slot_a → If LLM extracts a value for slot_a, it is discarded.  # noqa: E501
+        # scenario 2: NLU mapping is unable to extract a value for slot_a → If LLM extracts a value for slot_a, it is accepted.  # noqa: E501
+        command_has_nlu_extractor = any(
+            [
+                command.extractor == SetSlotExtractor.NLU.value
+                for command in set_slot_commands_so_far
+            ]
         )
+        return not command_has_nlu_extractor and slot_has_llm_mapping
 
-        if should_be_set_by_llm or should_be_set_by_nlu:
-            # if the extractor matches the mapping type, we can continue
-            # setting the slot
-            break
+    if (
+        slot_has_nlu_mapping
+        and command.extractor == SetSlotExtractor.LLM.value
+        and not slot_has_llm_mapping
+    ):
+        return False
 
-        structlogger.debug(
-            "command_processor.clean_up_slot_command.skip_command.extractor_"
-            "does_not_match_slot_mapping",
-            extractor=command.extractor,
-            slot_name=slot.name,
-            mapping_type=mapping_type.value,
-        )
+    if (
+        slot_has_llm_mapping
+        and command.extractor == SetSlotExtractor.NLU.value
+        and not slot_has_nlu_mapping
+    ):
+        return False
+
+    if slot_has_custom_mapping and not (slot_has_nlu_mapping or slot_has_llm_mapping):
         return False
 
     return True

rasa/dialogue_understanding/utils.py

@@ -5,7 +5,10 @@ from rasa.dialogue_understanding.commands import Command
 from rasa.dialogue_understanding.constants import (
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME,
 )
+from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import (
+    COMMANDS,
     KEY_COMPONENT_NAME,
     KEY_LLM_RESPONSE_METADATA,
     KEY_PROMPT_NAME,
@@ -13,6 +16,7 @@ from rasa.shared.nlu.constants import (
     KEY_USER_PROMPT,
     PREDICTED_COMMANDS,
     PROMPTS,
+    SET_SLOT_COMMAND,
 )
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
@@ -131,3 +135,30 @@ def add_prompt_to_message_parse_data(
 
     # Update the message with the new prompts list.
     message.set(PROMPTS, prompts, add_to_output=True)
+
+
+def _handle_via_nlu_in_coexistence(
+    tracker: Optional[DialogueStateTracker], message: Message
+) -> bool:
+    """Check if the message should be handled by the NLU subsystem in coexistence mode."""  # noqa: E501
+    if not tracker:
+        return False
+
+    if not tracker.has_coexistence_routing_slot:
+        return False
+
+    value = tracker.get_slot(ROUTE_TO_CALM_SLOT)
+    if value is not None:
+        return not value
+
+    # routing slot has been reset so we need to check
+    # the command issued by the Router component
+    if message.get(COMMANDS):
+        for command in message.get(COMMANDS):
+            if (
+                command.get("command") == SET_SLOT_COMMAND
+                and command.get("name") == ROUTE_TO_CALM_SLOT
+            ):
+                return not command.get("value")
+
+    return False