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

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -48,7 +48,7 @@ class ChangeFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "change"
+        return "ChangeFlow()"
 
     @staticmethod
     def from_dsl(match: re.Match, **kwargs: Any) -> ChangeFlowCommand:
@@ -57,4 +57,4 @@ class ChangeFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^change"
+        return r"ChangeFlow\(\)"

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

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

rasa/dialogue_understanding/commands/clarify_command.py

@@ -89,7 +89,7 @@ class ClarifyCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"clarify {' '.join(self.options)}"
+        return f"Clarify({', '.join(self.options)})"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[ClarifyCommand]:
@@ -99,4 +99,4 @@ class ClarifyCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"^clarify([\"\'a-zA-Z0-9_, ]*)$"
+        return r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)"

rasa/dialogue_understanding/commands/correct_slots_command.py

@@ -31,6 +31,7 @@ class CorrectedSlot:
 
     name: str
     value: Any
+    filled_by: Optional[str] = None
 
 
 @dataclass
@@ -54,7 +55,9 @@ class CorrectSlotsCommand(Command):
         try:
             return CorrectSlotsCommand(
                 corrected_slots=[
-                    CorrectedSlot(s["name"], value=s["value"])
+                    CorrectedSlot(
+                        s["name"], value=s["value"], filled_by=s.get("filled_by", None)
+                    )
                     for s in data["corrected_slots"]
                 ]
             )
@@ -135,7 +138,10 @@ class CorrectSlotsCommand(Command):
         proposed_slots = {}
         for corrected_slot in self.corrected_slots:
             if tracker.get_slot(corrected_slot.name) != corrected_slot.value:
-                proposed_slots[corrected_slot.name] = corrected_slot.value
+                proposed_slots[corrected_slot.name] = {
+                    "value": corrected_slot.value,
+                    "filled_by": corrected_slot.filled_by,
+                }
             else:
                 structlogger.debug(
                     "command_executor.skip_correction.slot_already_set", command=self
@@ -240,6 +246,9 @@ class CorrectSlotsCommand(Command):
             corrected_slots=proposed_slots,
             reset_flow_id=earliest_collect.flow_id if earliest_collect else None,
             reset_step_id=earliest_collect.step.id if earliest_collect else None,
+            new_slot_values=[
+                value.get("value") for slot, value in proposed_slots.items()
+            ],
         )
 
     def run_command_on_tracker(

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

@@ -1,23 +1,24 @@
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, List, Optional, Set, Text, Tuple
 
 import structlog
 
 from rasa.dialogue_understanding.commands import (
     Command,
+    CorrectSlotsCommand,
     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 +93,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 +107,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)
 
@@ -202,6 +200,94 @@ class CommandGenerator:
         """
         raise NotImplementedError()
 
+    def _check_commands_overlap(
+        self, prior_commands: List[Command], commands: List[Command]
+    ) -> List[Command]:
+        """Check if there is overlap between the prior commands and the current ones.
+
+        Args:
+            prior_commands: The prior commands.
+            commands: The commands to check.
+
+        Returns:
+            The final commands.
+        """
+        if not prior_commands:
+            return commands
+
+        prior_commands, commands = self._check_slot_command_overlap(
+            prior_commands, commands
+        )
+
+        prior_start_flow_names = {
+            command.flow
+            for command in prior_commands
+            if isinstance(command, StartFlowCommand)
+        }
+        current_start_flow_names = {
+            command.flow
+            for command in commands
+            if isinstance(command, StartFlowCommand)
+        }
+
+        return self._check_start_flow_command_overlap(
+            prior_commands,
+            commands,
+            prior_start_flow_names,
+            current_start_flow_names,
+        )
+
+    def _check_start_flow_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        prior_start_flow_names: Set[str],
+        current_start_flow_names: Set[str],
+    ) -> List[Command]:
+        """Get the final commands.
+
+        Args:
+            prior_commands: The prior commands.
+            commands: The currently predicted commands to check.
+            prior_start_flow_names: The names of the flows from the prior commands.
+            current_start_flow_names: The names of the flows from the current commands.
+
+        Returns:
+            The final commands.
+        """
+        raise NotImplementedError()
+
+    def _check_slot_command_overlap(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Check if the current commands overlap with the prior commands."""
+        prior_slot_names = gather_slot_names(prior_commands)
+        current_slot_names = gather_slot_names(commands)
+        overlapping_slot_names = prior_slot_names.intersection(current_slot_names)
+
+        structlogger.debug(
+            "command_generator.check_slot_command_overlap",
+            overlapping_slot_names=overlapping_slot_names,
+        )
+
+        if not overlapping_slot_names:
+            return prior_commands, commands
+
+        return self._filter_slot_commands(
+            prior_commands, commands, overlapping_slot_names
+        )
+
+    def _filter_slot_commands(
+        self,
+        prior_commands: List[Command],
+        commands: List[Command],
+        overlapping_slot_names: Set[str],
+    ) -> Tuple[List[Command], List[Command]]:
+        """Filter out the overlapping slot commands."""
+        raise NotImplementedError()
+
     def _check_commands_against_startable_flows(
         self, commands: List[Command], startable_flows: FlowsList
     ) -> List[Command]:
@@ -278,70 +364,21 @@ 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
+    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, [])
         ]
 
-        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 gather_slot_names(commands: List[Command]) -> Set[str]:
+    """Gather all slot names from the commands."""
+    slot_names = set()
+    for command in commands:
+        if isinstance(command, SetSlotCommand):
+            slot_names.add(command.name)
+        if isinstance(command, CorrectSlotsCommand):
+            for slot in command.corrected_slots:
+                slot_names.add(slot.name)
 
-        return filtered_commands
+    return slot_names