rasa-pro 3.12.0.dev12__py3-none-any.whl → 3.12.0rc1__py3-none-any.whl

rasa/dialogue_understanding/patterns/validate_slot.py

@@ -0,0 +1,65 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List
+
+from rasa.dialogue_understanding.stack.frames import (
+    PatternFlowStackFrame,
+)
+from rasa.shared.constants import (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX,
+    REFILL_UTTER,
+    REJECTIONS,
+)
+from rasa.shared.core.slots import SlotRejection
+
+FLOW_PATTERN_VALIDATE_SLOT = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "validate_slot"
+
+
+@dataclass
+class ValidateSlotPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame to validate slots."""
+
+    flow_id: str = FLOW_PATTERN_VALIDATE_SLOT
+    """The ID of the flow."""
+    validate: str = ""
+    """The slot that should be validated."""
+    refill_utter: str = ""
+    """The utter action that should be executed to ask the user to refill the
+    information."""
+    refill_action: str = ""
+    """The action that should be executed to ask the user to refill the
+    information."""
+    rejections: List[SlotRejection] = field(default_factory=list)
+    """The predicate check that should be applied to the filled slot.
+    If a predicate check fails, its `utter` action indicated under rejections
+    will be executed.
+    """
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_VALIDATE_SLOT
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> ValidateSlotPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        rejections = [
+            SlotRejection.from_dict(rejection) for rejection in data.get(REJECTIONS, [])
+        ]
+
+        return ValidateSlotPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            validate=data["validate"],
+            refill_action=data["refill_action"],
+            refill_utter=data[REFILL_UTTER],
+            rejections=rejections,
+        )

rasa/dialogue_understanding/processor/command_processor.py

@@ -18,7 +18,13 @@ 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.commands.utils import (
+    create_validate_frames_from_slot_set_events,
+)
 from rasa.dialogue_understanding.patterns.chitchat import FLOW_PATTERN_CHITCHAT
 from rasa.dialogue_understanding.patterns.collect_information import (
     CollectInformationPatternFlowStackFrame,
@@ -26,6 +32,9 @@ from rasa.dialogue_understanding.patterns.collect_information import (
 from rasa.dialogue_understanding.patterns.correction import (
     CorrectionPatternFlowStackFrame,
 )
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
 from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
 from rasa.dialogue_understanding.stack.frames import (
     BaseFlowStackFrame,
@@ -47,6 +56,7 @@ from rasa.shared.core.constants import (
 from rasa.shared.core.events import Event, SlotSet
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
+from rasa.shared.core.slot_mappings import SlotMapping
 from rasa.shared.core.slots import Slot
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.core.training_data.structures import StoryGraph
@@ -230,18 +240,51 @@ def execute_commands(
     # and then pushing the commands onto the stack in the reversed order.
     reversed_commands = list(reversed(commands))
 
+    # we need to keep track of the ValidateSlotPatternFlowStackFrame that
+    # should be pushed onto the stack before executing the StartFlowCommands.
+    # This is necessary to make sure that slots filled before the start of a
+    # flow can be immediately validated without waiting till the flow is started
+    # and completed.
+    stack_frames_to_follow_commands: List[ValidateSlotPatternFlowStackFrame] = []
+
     validate_state_of_commands(commands)
 
     for command in reversed_commands:
         new_events = command.run_command_on_tracker(
             tracker, all_flows, original_tracker
         )
+
+        _, stack_frames_to_follow_commands = (
+            create_validate_frames_from_slot_set_events(
+                tracker, new_events, stack_frames_to_follow_commands
+            )
+        )
+
         events.extend(new_events)
         tracker.update_with_events(new_events)
 
+        new_events = push_stack_frames_to_follow_commands(
+            tracker, stack_frames_to_follow_commands
+        )
+        events.extend(new_events)
+
     return remove_duplicated_set_slots(events)
 
 
+def push_stack_frames_to_follow_commands(
+    tracker: DialogueStateTracker, stack_frames: List
+) -> List[Event]:
+    """Push stack frames to follow commands."""
+    new_events = []
+
+    for frame in stack_frames:
+        stack = tracker.stack
+        stack.push(frame)
+        new_events.extend(tracker.create_stack_updated_events(stack))
+    tracker.update_with_events(new_events)
+    return new_events
+
+
 def remove_duplicated_set_slots(events: List[Event]) -> List[Event]:
     """Removes duplicated set slot events.
 
@@ -395,6 +438,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 +592,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.allow_nlu_correction is True
+                for mapping in slot.mappings
+                if mapping.type == SlotMappingType.FROM_LLM
+            ]
+        )
+
+        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 +674,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 +758,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 +768,61 @@ 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 = [SlotMapping(type=SlotMappingType.FROM_LLM)]
 
-    for mapping in slot_mappings:
-        mapping_type = SlotMappingType(
-            mapping.get("type", SlotMappingType.FROM_LLM.value)
-        )
+    mapping_types = [mapping.type 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_controlled_mapping = any(
+        [mapping_type == SlotMappingType.CONTROLLED 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_controlled_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

rasa/dialogue_understanding_test/README.md

@@ -377,3 +377,53 @@ Test cases in **to_review** may require manual intervention because the E2E test
 Review these cases to ensure that the converted test cases are correct and the list of commands and
 bot responses is complete.
 
+
+## Converting DUT test from one DSL to a another DSL
+
+If you need to transform your commands from one DSL format to another
+(for instance, updating `StartFlow(flow_name)` to `start flow_name` or `SetSlot(slot_name, slot_value)` to `set slot_name slot_value`),
+you can use a standalone Python script:
+
+```bash
+python convert_dut_dsl.py --dut-tests-dir <path> --output-dir <path> --dsl-mappings <path>
+```
+
+The script has the following required parameters:
+
+- `--dut-tests-dir <path>`: The directory (relative or absolute) containing your
+  existing Dialogue Understanding Tests (DUT). The script will look for `.yaml` or 
+  `.yml` files within this folder (and subfolders).
+- `--output-dir <path>`: The directory where transformed files will be saved. The folder
+  structure from your `dut-tests-dir` is preserved.
+- `--dsl-mappings <path>`: The YAML file defining your DSL mapping rules.
+
+The YAML file containing the mappings must adhere to the following format: 
+  ```yaml
+  mappings:
+  
+  - from_dsl_regex: "^StartFlow\\(([^)]*)\\)$"
+    to_dsl_pattern: "start {1}"
+  
+  - from_dsl_regex: "^SetSlot\\(([^,]+),\\s*(.*)\\)$"
+    to_dsl_pattern: "set {1} {2}"
+  
+  - from_dsl_regex: "Clarify\(([\"\'a-zA-Z0-9_, ]*)\)"
+    to_dsl_pattern: "clarify {1}"
+    input_separators:
+      - ","
+      - " "
+    output_separator: " "
+  
+  # ... add more mappings here
+
+  ```
+
+- `from_dsl_regex`: A regular expression (string) used to match the old DSL command.
+  Must include any necessary anchors (like ^ and $) and capturing groups ( ... ) for 
+  dynamic parts.
+- `to_dsl_pattern`: A string that contains placeholders like `{1}`, `{2}`, etc. Each
+  placeholder corresponds to a capturing group in from_dsl_regex, in order of
+  appearance.
+- `input_separators`: Optional list of separators of the captured groups that can be replaced
+  with the `output_separator`
+- `output_separator`: Output separator to replace separators from the list of `input_separators` in the captured group.

rasa/dialogue_understanding_test/du_test_case.py

@@ -2,7 +2,7 @@ from typing import Any, Dict, Iterator, List, Optional, Tuple
 
 from pydantic import BaseModel, Field
 
-from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding.generator.command_parser import parse_commands
 from rasa.dialogue_understanding_test.command_comparison import are_command_lists_equal
 from rasa.dialogue_understanding_test.constants import (
@@ -30,6 +30,7 @@ from rasa.shared.nlu.constants import (
 KEY_USAGE = "usage"
 KEY_PROMPT_TOKENS = "prompt_tokens"
 KEY_COMPLETION_TOKENS = "completion_tokens"
+KEY_CHOICES = "choices"
 
 
 class DialogueUnderstandingOutput(BaseModel):
@@ -65,11 +66,18 @@ class DialogueUnderstandingOutput(BaseModel):
     """
 
     # Dict with component name as key and list of commands as value
-    commands: Dict[str, List[Command]]
+    commands: Dict[str, List[PromptCommand]]
     # List of prompts
     prompts: Optional[List[Dict[str, Any]]] = None
 
-    def get_predicted_commands(self) -> List[Command]:
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
+    def get_predicted_commands(self) -> List[PromptCommand]:
         """Get all commands from the output."""
         return [
             command
@@ -144,6 +152,11 @@ class DialogueUnderstandingOutput(BaseModel):
                         KEY_COMPLETION_TOKENS
                     )
 
+            choices = prompt_data.get(KEY_LLM_RESPONSE_METADATA, {}).get(KEY_CHOICES)
+            if choices and len(choices) > 0:
+                # Add the action list returned by the LLM to the prompt_info
+                prompt_info[KEY_CHOICES] = choices[0]
+
             data[component_name].append(prompt_info)
 
         return data
@@ -155,9 +168,16 @@ class DialogueUnderstandingTestStep(BaseModel):
     template: Optional[str] = None
     line: Optional[int] = None
     metadata_name: Optional[str] = None
-    commands: Optional[List[Command]] = None
+    commands: Optional[List[PromptCommand]] = None
     dialogue_understanding_output: Optional[DialogueUnderstandingOutput] = None
 
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
     def as_dict(self) -> Dict[str, Any]:
         if self.actor == ACTOR_USER:
             if self.commands:
@@ -178,7 +198,7 @@ class DialogueUnderstandingTestStep(BaseModel):
     def from_dict(
         step: Dict[str, Any],
         flows: FlowsList,
-        custom_command_classes: List[Command] = [],
+        custom_command_classes: List[PromptCommand] = [],
         remove_default_commands: List[str] = [],
     ) -> "DialogueUnderstandingTestStep":
         """Creates a DialogueUnderstandingTestStep from a dictionary.
@@ -224,7 +244,7 @@ class DialogueUnderstandingTestStep(BaseModel):
             commands=commands,
         )
 
-    def get_predicted_commands(self) -> List[Command]:
+    def get_predicted_commands(self) -> List[PromptCommand]:
         """Get all predicted commands from the test case."""
         if self.dialogue_understanding_output is None:
             return []
@@ -314,7 +334,7 @@ class DialogueUnderstandingTestCase(BaseModel):
         input_test_case: Dict[str, Any],
         flows: FlowsList,
         file: Optional[str] = None,
-        custom_command_classes: List[Command] = [],
+        custom_command_classes: List[PromptCommand] = [],
         remove_default_commands: List[str] = [],
     ) -> "DialogueUnderstandingTestCase":
         """Creates a DialogueUnderstandingTestCase from a dictionary.
@@ -361,7 +381,7 @@ class DialogueUnderstandingTestCase(BaseModel):
 
         return [step.to_str() for step in steps]
 
-    def get_expected_commands(self) -> List[Command]:
+    def get_expected_commands(self) -> List[PromptCommand]:
         """Get all commands from the test steps."""
         return [
             command

rasa/dialogue_understanding_test/du_test_result.py

@@ -5,16 +5,13 @@ from typing import Any, Dict, List, Optional, Text
 import numpy as np
 from pydantic import BaseModel
 
-from rasa.dialogue_understanding.commands import Command
+from rasa.dialogue_understanding.commands.prompt_command import PromptCommand
 from rasa.dialogue_understanding_test.du_test_case import (
     DialogueUnderstandingTestCase,
     DialogueUnderstandingTestStep,
 )
 from rasa.dialogue_understanding_test.utils import get_command_comparison
-from rasa.shared.nlu.constants import (
-    KEY_SYSTEM_PROMPT,
-    KEY_USER_PROMPT,
-)
+from rasa.shared.nlu.constants import KEY_SYSTEM_PROMPT, KEY_USER_PROMPT
 
 if typing.TYPE_CHECKING:
     from rasa.dialogue_understanding_test.command_metric_calculation import (
@@ -46,7 +43,7 @@ class DialogueUnderstandingTestResult(BaseModel):
     passed: bool
     error_line: Optional[int] = None
 
-    def get_expected_commands(self) -> List[Command]:
+    def get_expected_commands(self) -> List[PromptCommand]:
         return self.test_case.get_expected_commands()
 
 
@@ -60,10 +57,17 @@ class FailedTestStep(BaseModel):
     pass_status: bool
     command_generators: List[str]
     prompts: Optional[Dict[str, List[Dict[str, Any]]]] = None
-    expected_commands: List[Command]
-    predicted_commands: Dict[str, List[Command]]
+    expected_commands: List[PromptCommand]
+    predicted_commands: Dict[str, List[PromptCommand]]
     conversation_with_diff: List[str]
 
+    class Config:
+        """Skip validation for PromptCommand protocol as pydantic does not know how to
+        serialize or handle instances of a protocol.
+        """
+
+        arbitrary_types_allowed = True
+
     @classmethod
     def from_dialogue_understanding_test_step(
         cls,
@@ -74,7 +78,7 @@ class FailedTestStep(BaseModel):
         user_utterance = step.text or ""
         line_number = step.line or -1
 
-        predicted_commands: Dict[str, List[Command]] = {}
+        predicted_commands: Dict[str, List[PromptCommand]] = {}
         prompts: Optional[Dict[str, List[Dict[str, Any]]]] = None
         command_generators: List[str] = []
 

rasa/dialogue_understanding_test/io.py

@@ -8,6 +8,7 @@ import rasa.shared.data
 from rasa.dialogue_understanding_test.command_metric_calculation import CommandMetrics
 from rasa.dialogue_understanding_test.constants import SCHEMA_FILE_PATH
 from rasa.dialogue_understanding_test.du_test_case import (
+    KEY_CHOICES,
     KEY_COMPLETION_TOKENS,
     KEY_PROMPT_TOKENS,
 )
@@ -309,6 +310,7 @@ def print_failed_cases(
                 print_prompt(step)
             rich.print("\n[red3]-- CONVERSATION --[/red3]")
             rich.print("\n".join(step.conversation_with_diff))
+            print_llm_output(step)
 
 
 def print_prompt(step: FailedTestStep) -> None:
@@ -341,6 +343,18 @@ def print_prompt(step: FailedTestStep) -> None:
             )
 
 
+def print_llm_output(step: FailedTestStep) -> None:
+    if not step.prompts:
+        return
+
+    for component, component_prompts in step.prompts.items():
+        for prompt_data in component_prompts:
+            if KEY_CHOICES in prompt_data:
+                rich.print("\n[red3]-- CHOICES --[/red3]")
+                rich.print(prompt_data.get(KEY_CHOICES))
+                rich.print("[red3]-------------[/red3]")
+
+
 def print_command_summary(metrics: Dict[str, CommandMetrics]) -> None:
     """Print the command summary.
 

rasa/dialogue_understanding_test/test_case_simulation/test_case_tracker_simulator.py

@@ -20,7 +20,7 @@ from rasa.dialogue_understanding_test.test_case_simulation.exception import (
 )
 from rasa.dialogue_understanding_test.utils import filter_metadata
 from rasa.e2e_test.e2e_test_case import Fixture, Metadata
-from rasa.shared.core.constants import MAPPING_TYPE, SlotMappingType
+from rasa.shared.core.constants import SlotMappingType
 from rasa.shared.core.events import BotUttered, SlotSet, UserUttered
 from rasa.shared.core.trackers import DialogueStateTracker
 from rasa.shared.nlu.constants import COMMANDS, ENTITIES, INTENT
@@ -328,8 +328,8 @@ class TestCaseTrackerSimulator:
                     command.extractor = SetSlotExtractor.COMMAND_PAYLOAD_READER.value
                 # Use the SetSlotExtractor.NLU extractor if the slot mapping type is
                 # not FROM_LLM.
-                elif SlotMappingType.FROM_LLM.value not in [
-                    mapping[MAPPING_TYPE] for mapping in slot_definition.mappings
+                elif SlotMappingType.FROM_LLM not in [
+                    mapping.type for mapping in slot_definition.mappings
                 ]:
                     command.extractor = SetSlotExtractor.NLU.value