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

rasa/dialogue_understanding/commands/handle_digressions_command.py

@@ -0,0 +1,150 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Any, Dict, List
+
+import structlog
+
+from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.patterns.cannot_handle import (
+    CannotHandlePatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.patterns.handle_digressions import (
+    HandleDigressionsPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import (
+    top_flow_frame,
+    user_flows_on_the_stack,
+)
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.flows.steps import CollectInformationFlowStep
+from rasa.shared.core.flows.utils import ALL_LABEL
+from rasa.shared.core.trackers import DialogueStateTracker
+from rasa.shared.nlu.constants import HANDLE_DIGRESSIONS_COMMAND
+
+structlogger = structlog.get_logger()
+
+
+@dataclass
+class HandleDigressionsCommand(Command):
+    """A command to handle digressions during an active flow."""
+
+    flow: str
+    """The interrupting flow."""
+
+    @classmethod
+    def command(cls) -> str:
+        """Returns the command type."""
+        return HANDLE_DIGRESSIONS_COMMAND
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> HandleDigressionsCommand:
+        """Converts the dictionary to a command.
+
+        Returns:
+            The converted dictionary.
+        """
+        try:
+            return HandleDigressionsCommand(flow=data["flow"])
+        except KeyError as e:
+            raise ValueError(
+                f"Missing parameter '{e}' while parsing HandleDigressionsCommand."
+            ) from e
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """Runs the command on the tracker.
+
+        Args:
+            tracker: The tracker to run the command on.
+            all_flows: All flows in the assistant.
+            original_tracker: The tracker before any command was executed.
+
+        Returns:
+            The events to apply to the tracker.
+        """
+        stack = tracker.stack
+        original_stack = original_tracker.stack
+
+        if self.flow in user_flows_on_the_stack(stack):
+            structlogger.debug(
+                "command_executor.skip_command.already_started_flow", command=self
+            )
+            return []
+        elif self.flow not in all_flows.flow_ids:
+            structlogger.debug(
+                "command_executor.push_cannot_handle.start_invalid_flow_id",
+                command=self,
+            )
+            stack.push(CannotHandlePatternFlowStackFrame())
+            return tracker.create_stack_updated_events(stack)
+
+        # this allows to include called user flows in the stack search
+        latest_user_frame = top_flow_frame(original_stack, ignore_call_frames=False)
+
+        if latest_user_frame is None:
+            structlogger.debug(
+                "command_executor.skip_command.no_top_flow", command=self
+            )
+            return []
+
+        original_top_flow = latest_user_frame.flow(all_flows)
+        current_step = original_top_flow.step_by_id(latest_user_frame.step_id)
+        if not isinstance(current_step, CollectInformationFlowStep):
+            structlogger.debug(
+                "command_executor.skip_command.not_at_a_collect_step", command=self
+            )
+            return []
+
+        ask_confirm_digressions = set(
+            current_step.ask_confirm_digressions
+            + original_top_flow.ask_confirm_digressions
+        )
+
+        block_digressions = set(
+            current_step.block_digressions + original_top_flow.block_digressions
+        )
+
+        if block_digressions:
+            if ALL_LABEL in block_digressions:
+                block_digressions.remove(ALL_LABEL)
+                block_digressions.add(self.flow)
+
+        if ask_confirm_digressions:
+            if ALL_LABEL in ask_confirm_digressions:
+                ask_confirm_digressions.remove(ALL_LABEL)
+                ask_confirm_digressions.add(self.flow)
+
+        structlogger.debug(
+            "command_executor.push_handle_digressions",
+            interrupting_flow_id=self.flow,
+            interrupted_flow_id=original_top_flow.id,
+            interrupted_step_id=current_step.id,
+            ask_confirm_digressions=ask_confirm_digressions,
+            block_digressions=block_digressions,
+        )
+        stack.push(
+            HandleDigressionsPatternFlowStackFrame(
+                interrupting_flow_id=self.flow,
+                interrupted_flow_id=original_top_flow.id,
+                interrupted_step_id=current_step.id,
+                ask_confirm_digressions=ask_confirm_digressions,
+                block_digressions=block_digressions,
+            )
+        )
+
+        return tracker.create_stack_updated_events(stack)
+
+    def __hash__(self) -> int:
+        return hash(self.flow)
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, HandleDigressionsCommand):
+            return False
+
+        return other.flow == self.flow

rasa/dialogue_understanding/commands/human_handoff_command.py

@@ -66,7 +66,7 @@ class HumanHandoffCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "hand over"
+        return "HumanHandoff()"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> HumanHandoffCommand:
@@ -75,4 +75,4 @@ class HumanHandoffCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^hand over$"
+        return r"HumanHandoff\(\)"

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -59,7 +59,7 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "search"
+        return "SearchAndReply()"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> KnowledgeAnswerCommand:
@@ -68,4 +68,4 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^search$"
+        return r"SearchAndReply\(\)"

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -60,7 +60,7 @@ class RepeatBotMessagesCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "repeat message"
+        return "RepeatLastBotMessages()"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> RepeatBotMessagesCommand:
@@ -69,4 +69,4 @@ class RepeatBotMessagesCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^repeat message$"
+        return r"RepeatLastBotMessages\(\)"

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import re
 from dataclasses import dataclass
-from enum import Enum
 from typing import Any, Dict, List
 
 import structlog
@@ -19,6 +18,7 @@ from rasa.dialogue_understanding.stack.utils import (
     get_collect_steps_excluding_ask_before_filling_for_active_flow,
 )
 from rasa.shared.constants import ROUTE_TO_CALM_SLOT
+from rasa.shared.core.constants import SetSlotExtractor
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -27,17 +27,6 @@ from rasa.shared.nlu.constants import SET_SLOT_COMMAND
 structlogger = structlog.get_logger()
 
 
-class SetSlotExtractor(Enum):
-    """The extractors that can set a slot."""
-
-    LLM = "LLM"
-    COMMAND_PAYLOAD_READER = "CommandPayloadReader"
-    NLU = "NLU"
-
-    def __str__(self) -> str:
-        return self.value
-
-
 def get_flows_predicted_to_start_from_tracker(
     tracker: DialogueStateTracker,
 ) -> List[str]:
@@ -137,6 +126,7 @@ class SetSlotCommand(Command):
             in {
                 SetSlotExtractor.LLM.value,
                 SetSlotExtractor.COMMAND_PAYLOAD_READER.value,
+                SetSlotExtractor.NLU.value,
             }
         ):
             # Get the other predicted flows from the most recent message on the tracker.
@@ -154,7 +144,9 @@ class SetSlotCommand(Command):
                 return []
 
         structlogger.debug("command_executor.set_slot", command=self)
-        return [SlotSet(self.name, slot.coerce_value(self.value))]
+        return [
+            SlotSet(self.name, slot.coerce_value(self.value), filled_by=self.extractor)
+        ]
 
     def __hash__(self) -> int:
         return hash(self.value) + hash(self.name)
@@ -170,7 +162,7 @@ class SetSlotCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"set {self.name} {self.value}"
+        return f"SetSlot({self.name}, {self.value})"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SetSlotCommand:
@@ -181,4 +173,4 @@ class SetSlotCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"""^set ['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]? ['"]?(.+?)['"]?$"""
+        return r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""

rasa/dialogue_understanding/commands/skip_question_command.py

@@ -75,7 +75,7 @@ class SkipQuestionCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "skip"
+        return "SkipQuestion()"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SkipQuestionCommand:
@@ -84,4 +84,4 @@ class SkipQuestionCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^skip$"
+        return r"SkipQuestion\(\)"

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -7,6 +7,11 @@ from typing import Any, Dict, List, Optional
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.patterns.clarify import FLOW_PATTERN_CLARIFICATION
+from rasa.dialogue_understanding.patterns.continue_interrupted import (
+    ContinueInterruptedPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
     FlowStackFrameType,
     UserFlowStackFrame,
@@ -68,6 +73,10 @@ class StartFlowCommand(Command):
         applied_events: List[Event] = []
 
         if self.flow in user_flows_on_the_stack(stack):
+            top_frame = stack.top()
+            if top_frame is not None and top_frame.type() == FLOW_PATTERN_CLARIFICATION:
+                return self.change_flow_frame_position_in_the_stack(stack, tracker)
+
             structlogger.debug(
                 "command_executor.skip_command.already_started_flow", command=self
             )
@@ -110,7 +119,7 @@ class StartFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"start {self.flow}"
+        return f"StartFlow({self.flow})"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[StartFlowCommand]:
@@ -119,4 +128,36 @@ class StartFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^start ['\"]?([a-zA-Z0-9_-]+)['\"]?$"
+        return r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)"
+
+    def change_flow_frame_position_in_the_stack(
+        self, stack: DialogueStack, tracker: DialogueStateTracker
+    ) -> List[Event]:
+        """Changes the position of the flow frame in the stack.
+
+        This is a special case when pattern clarification is the active flow and
+        the same flow is selected to start. In this case, the existing flow frame
+        should be moved up in the stack.
+        """
+        frames = stack.frames[:]
+
+        for idx, frame in enumerate(frames):
+            if isinstance(frame, UserFlowStackFrame) and frame.flow_id == self.flow:
+                structlogger.debug(
+                    "command_executor.change_flow_position_during_clarification",
+                    command=self,
+                    index=idx,
+                )
+                # pop the continue interrupted flow frame if it exists
+                next_frame = frames[idx + 1] if idx + 1 < len(frames) else None
+                if (
+                    isinstance(next_frame, ContinueInterruptedPatternFlowStackFrame)
+                    and next_frame.previous_flow_name == self.flow
+                ):
+                    stack.frames.pop(idx + 1)
+                # move up the existing flow from the stack
+                stack.frames.pop(idx)
+                stack.push(frame)
+                return tracker.create_stack_updated_events(stack)
+
+        return []

rasa/dialogue_understanding/commands/utils.py

@@ -27,7 +27,7 @@ def extract_cleaned_options(options_str: str) -> List[str]:
     """Extract and clean options from a string."""
     return sorted(
         opt.strip().strip('"').strip("'")
-        for opt in options_str.split(" ")
+        for opt in options_str.split(",")
         if opt.strip()
     )
 

rasa/dialogue_understanding/constants.py

@@ -1 +1,2 @@
 RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME = "RASA_RECORD_COMMANDS_AND_PROMPTS"
+KEY_MINIMIZE_NUM_CALLS = "minimize_num_calls"

rasa/dialogue_understanding/generator/command_generator.py

@@ -6,18 +6,17 @@ import structlog
 from rasa.dialogue_understanding.commands import (
     Command,
     ErrorCommand,
-    SetSlotCommand,
     StartFlowCommand,
 )
-from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
+from rasa.dialogue_understanding.utils import (
+    _handle_via_nlu_in_coexistence,
+)
 from rasa.shared.constants import (
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_EMPTY,
     RASA_PATTERN_INTERNAL_ERROR_USER_INPUT_TOO_LONG,
 )
-from rasa.shared.core.constants import SlotMappingType
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.slot_mappings import SlotFillingManager
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import (
     COMMANDS,
@@ -92,9 +91,9 @@ class CommandGenerator:
         )
 
         for message in messages:
-            if message.get(COMMANDS):
-                # do not overwrite commands if they are already present
-                # i.e. another command generator already predicted commands
+            if _handle_via_nlu_in_coexistence(tracker, message):
+                # Skip running the CALM pipeline if the message should
+                # be handled by the NLU-based system in a coexistence mode.
                 continue
 
             commands = await self._evaluate_and_predict(
@@ -106,9 +105,6 @@ class CommandGenerator:
             commands = self._check_commands_against_startable_flows(
                 commands, startable_flows
             )
-            commands = self._check_commands_against_slot_mappings(
-                commands, tracker, domain
-            )
             commands_dicts = [command.as_dict() for command in commands]
             message.set(COMMANDS, commands_dicts, add_to_output=True)
 
@@ -278,70 +274,8 @@ class CommandGenerator:
         return len(message.get(TEXT, "").strip()) == 0
 
     @staticmethod
-    def _check_commands_against_slot_mappings(
-        commands: List[Command],
-        tracker: DialogueStateTracker,
-        domain: Optional[Domain] = None,
-    ) -> List[Command]:
-        """Check if the LLM-issued slot commands are fillable.
-
-        The LLM-issued slot commands are fillable if the slot
-        mappings are satisfied.
-        """
-        if not domain:
-            return commands
-
-        llm_fillable_slot_names = [
-            command.name
-            for command in commands
-            if isinstance(command, SetSlotCommand)
-            and command.extractor == SetSlotExtractor.LLM.value
-        ]
-
-        if not llm_fillable_slot_names:
-            return commands
-
-        llm_fillable_slots = [
-            slot for slot in domain.slots if slot.name in llm_fillable_slot_names
-        ]
-
-        slot_filling_manager = SlotFillingManager(domain, tracker)
-        slots_to_be_removed = []
-
-        structlogger.debug(
-            "command_processor.check_commands_against_slot_mappings.active_flow",
-            active_flow=tracker.active_flow,
-        )
-
-        for slot in llm_fillable_slots:
-            should_fill_slot = False
-            for mapping in slot.mappings:
-                mapping_type = SlotMappingType(mapping.get("type"))
-
-                should_fill_slot = slot_filling_manager.should_fill_slot(
-                    slot.name, mapping_type, mapping
-                )
-
-                if should_fill_slot:
-                    break
-
-            if not should_fill_slot:
-                structlogger.debug(
-                    "command_processor.check_commands_against_slot_mappings.slot_not_fillable",
-                    slot_name=slot.name,
-                )
-                slots_to_be_removed.append(slot.name)
-
-        if not slots_to_be_removed:
-            return commands
-
-        filtered_commands = [
-            command
-            for command in commands
-            if not (
-                isinstance(command, SetSlotCommand)
-                and command.name in slots_to_be_removed
-            )
+    def _get_prior_commands(message: Message) -> List[Command]:
+        """Get the prior commands from the tracker."""
+        return [
+            Command.command_from_json(command) for command in message.get(COMMANDS, [])
         ]
-
-        return filtered_commands

rasa/dialogue_understanding/generator/command_parser.py

@@ -125,7 +125,7 @@ def _parse_standard_commands(
     commands: List[Command] = []
     for command_clz in standard_commands:
         pattern = _get_compiled_pattern(command_clz.regex_pattern())
-        if match := pattern.search(action.strip()):
+        if match := pattern.search(action):
             parsed_command = command_clz.from_dsl(match, **kwargs)
             if _additional_parsing_fn := _get_additional_parsing_logic(command_clz):
                 parsed_command = _additional_parsing_fn(parsed_command, flows, **kwargs)

rasa/dialogue_understanding/generator/llm_based_command_generator.py

@@ -8,7 +8,10 @@ from jinja2 import Template
 import rasa.shared.utils.io
 from rasa.dialogue_understanding.commands import (
     Command,
+    SetSlotCommand,
+    StartFlowCommand,
 )
+from rasa.dialogue_understanding.constants import KEY_MINIMIZE_NUM_CALLS
 from rasa.dialogue_understanding.generator import CommandGenerator
 from rasa.dialogue_understanding.generator.constants import (
     DEFAULT_LLM_CONFIG,
@@ -18,13 +21,20 @@ from rasa.dialogue_understanding.generator.constants import (
     LLM_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
+from rasa.dialogue_understanding.stack.utils import top_flow_frame
 from rasa.engine.graph import ExecutionContext, GraphComponent
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
+from rasa.shared.core.constants import (
+    KEY_MAPPING_TYPE,
+    SetSlotExtractor,
+    SlotMappingType,
+)
 from rasa.shared.core.domain import Domain
 from rasa.shared.core.flows import Flow, FlowsList, FlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slot_mappings import SlotFillingManager
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.exceptions import FileIOException, ProviderClientAPIException
 from rasa.shared.nlu.constants import FLOWS_IN_PROMPT
@@ -357,8 +367,7 @@ class LLMBasedCommandGenerator(
                     "slots": slots_with_info,
                 }
             )
-
-        return sorted(result, key=lambda x: x["name"])
+        return result
 
     @staticmethod
     def is_extractable(
@@ -454,3 +463,118 @@ class LLMBasedCommandGenerator(
             if isinstance(current_step, CollectInformationFlowStep)
             else (None, None)
         )
+
+    @staticmethod
+    def _prior_commands_contain_start_flow(prior_commands: List[Command]) -> bool:
+        return any(isinstance(command, StartFlowCommand) for command in prior_commands)
+
+    @staticmethod
+    def _prior_commands_contain_set_slot_for_active_collect_step(
+        prior_commands: List[Command],
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+    ) -> bool:
+        latest_user_frame = top_flow_frame(tracker.stack, ignore_call_frames=False)
+
+        if latest_user_frame is None:
+            return False
+
+        active_flow = latest_user_frame.flow(flows)
+        active_step = active_flow.step_by_id(latest_user_frame.step_id)
+
+        if not isinstance(active_step, CollectInformationFlowStep):
+            return False
+
+        return any(
+            command.name == active_step.collect
+            for command in prior_commands
+            if isinstance(command, SetSlotCommand)
+        )
+
+    def _should_skip_llm_call(
+        self,
+        prior_commands: List[Command],
+        flows: FlowsList,
+        tracker: DialogueStateTracker,
+    ) -> bool:
+        """Skip invoking the LLM.
+
+        This returns True if the bot builder sets the property
+        KEY_MINIMIZE_NUM_CALLS to True and the prior commands
+        either contain a StartFlowCommand or a SetSlot command
+        for the current collect step.
+        """
+        return self.config.get(KEY_MINIMIZE_NUM_CALLS, False) and (
+            self._prior_commands_contain_start_flow(prior_commands)
+            or self._prior_commands_contain_set_slot_for_active_collect_step(
+                prior_commands, flows, tracker
+            )
+        )
+
+    @staticmethod
+    def _check_commands_against_slot_mappings(
+        commands: List[Command],
+        tracker: DialogueStateTracker,
+        domain: Optional[Domain] = None,
+    ) -> List[Command]:
+        """Check if the LLM-issued slot commands are fillable.
+
+        The LLM-issued slot commands are fillable if the slot
+        mappings are satisfied (in particular the mapping conditions).
+        """
+        if not domain:
+            return commands
+
+        llm_fillable_slots = [
+            tracker.slots.get(command.name)
+            for command in commands
+            if isinstance(command, SetSlotCommand)
+            and command.extractor == SetSlotExtractor.LLM.value
+            and tracker.slots.get(command.name) is not None
+        ]
+
+        if not llm_fillable_slots:
+            return commands
+
+        slot_filling_manager = SlotFillingManager(domain, tracker)
+        slots_to_be_removed = []
+
+        structlogger.debug(
+            "command_processor.check_commands_against_slot_mappings.active_flow",
+            active_flow=tracker.active_flow,
+        )
+
+        for slot in llm_fillable_slots:
+            should_fill_slot = False
+            for mapping in slot.mappings:  # type: ignore[union-attr]
+                mapping_type = SlotMappingType(mapping.get(KEY_MAPPING_TYPE))
+
+                should_fill_slot = slot_filling_manager.should_fill_slot(
+                    slot.name,  # type: ignore[union-attr]
+                    mapping_type,
+                    mapping,
+                )
+
+                if should_fill_slot:
+                    break
+
+            if not should_fill_slot:
+                structlogger.debug(
+                    "command_processor.check_commands_against_slot_mappings.slot_not_fillable",
+                    slot_name=slot.name,  # type: ignore[union-attr]
+                )
+                slots_to_be_removed.append(slot.name)  # type: ignore[union-attr]
+
+        if not slots_to_be_removed:
+            return commands
+
+        filtered_commands = [
+            command
+            for command in commands
+            if not (
+                isinstance(command, SetSlotCommand)
+                and command.name in slots_to_be_removed
+            )
+        ]
+
+        return filtered_commands

rasa/dialogue_understanding/generator/multi_step/multi_step_llm_command_generator.py

@@ -190,9 +190,14 @@ class MultiStepLLMCommandGenerator(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_with_multi_step(
@@ -221,7 +226,10 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             commands=commands,
         )
 
-        return commands
+        domain = kwargs.get("domain")
+        commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
+
+        return prior_commands + commands
 
     @classmethod
     def parse_commands(