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

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 (
@@ -47,6 +50,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
@@ -395,6 +399,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 +553,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 +635,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 +719,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 +729,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/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
 

rasa/model_manager/warm_rasa_process.py

@@ -46,7 +46,6 @@ def _create_warm_rasa_process() -> WarmRasaProcess:
     ]
 
     envs = os.environ.copy()
-    envs["RASA_TELEMETRY_ENABLED"] = "false"
     envs[RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME] = "true"
 
     log_id = uuid.uuid4().hex

rasa/model_training.py

@@ -352,34 +352,31 @@ async def _train_graph(
         model_name = determine_model_name(fixed_model_name, training_type)
         full_model_path = Path(output_path, model_name)
 
-        with telemetry.track_model_training(
-            file_importer, model_type=training_type.model_type
-        ):
-            await trainer.train(
-                model_configuration,
-                file_importer,
-                full_model_path,
-                force_retraining=force_full_training,
-                is_finetuning=is_finetuning,
+        await trainer.train(
+            model_configuration,
+            file_importer,
+            full_model_path,
+            force_retraining=force_full_training,
+            is_finetuning=is_finetuning,
+        )
+        if remote_storage:
+            push_model_to_remote_storage(full_model_path, remote_storage)
+            if not keep_local_model_copy:
+                full_model_path.unlink()
+            structlogger.info(
+                "model_training.train.finished_training",
+                event_info=(
+                    f"Your Rasa model {model_name} is trained "
+                    f"and saved at remote storage provider '{remote_storage}'."
+                ),
+            )
+        else:
+            structlogger.info(
+                "model_training.train.finished_training",
+                event_info=(
+                    f"Your Rasa model is trained and saved at '{full_model_path}'."
+                ),
             )
-            if remote_storage:
-                push_model_to_remote_storage(full_model_path, remote_storage)
-                if not keep_local_model_copy:
-                    full_model_path.unlink()
-                structlogger.info(
-                    "model_training.train.finished_training",
-                    event_info=(
-                        f"Your Rasa model {model_name} is trained "
-                        f"and saved at remote storage provider '{remote_storage}'."
-                    ),
-                )
-            else:
-                structlogger.info(
-                    "model_training.train.finished_training",
-                    event_info=(
-                        f"Your Rasa model is trained and saved at '{full_model_path}'."
-                    ),
-                )
 
         return TrainingResult(str(full_model_path), 0)
 

rasa/shared/core/constants.py

@@ -51,6 +51,8 @@ ACTION_TRIGGER_CHITCHAT = "action_trigger_chitchat"
 ACTION_RESET_ROUTING = "action_reset_routing"
 ACTION_HANGUP = "action_hangup"
 ACTION_REPEAT_BOT_MESSAGES = "action_repeat_bot_messages"
+ACTION_BLOCK_DIGRESSION = "action_block_digression"
+ACTION_CONTINUE_DIGRESSION = "action_continue_digression"
 
 ACTION_METADATA_EXECUTION_SUCCESS = "execution_success"
 ACTION_METADATA_EXECUTION_ERROR_MESSAGE = "execution_error_message"
@@ -81,6 +83,8 @@ DEFAULT_ACTION_NAMES = [
     ACTION_RESET_ROUTING,
     ACTION_HANGUP,
     ACTION_REPEAT_BOT_MESSAGES,
+    ACTION_BLOCK_DIGRESSION,
+    ACTION_CONTINUE_DIGRESSION,
 ]
 
 ACTION_SHOULD_SEND_DOMAIN = "send_domain"
@@ -137,7 +141,10 @@ DEFAULT_SLOT_NAMES = {
 
 SLOT_MAPPINGS = "mappings"
 MAPPING_CONDITIONS = "conditions"
-MAPPING_TYPE = "type"
+KEY_MAPPING_TYPE = "type"
+KEY_ALLOW_NLU_CORRECTION = "allow_nlu_correction"
+KEY_ACTION = "action"
+KEY_RUN_ACTION_EVERY_TURN = "run_action_every_turn"
 
 
 class SlotMappingType(Enum):
@@ -148,7 +155,7 @@ class SlotMappingType(Enum):
     FROM_TRIGGER_INTENT = "from_trigger_intent"
     FROM_TEXT = "from_text"
     FROM_LLM = "from_llm"
-    CUSTOM = "custom"
+    CONTROLLED = "controlled"
 
     def __str__(self) -> str:
         """Returns the string representation that should be used in config files."""
@@ -156,7 +163,21 @@ class SlotMappingType(Enum):
 
     def is_predefined_type(self) -> bool:
         """Returns True if the mapping type is NLU-predefined."""
-        return not (self == SlotMappingType.CUSTOM or self == SlotMappingType.FROM_LLM)
+        return not (
+            self == SlotMappingType.CONTROLLED or self == SlotMappingType.FROM_LLM
+        )
+
+
+class SetSlotExtractor(Enum):
+    """The extractors that can set a slot."""
+
+    LLM = "LLM"
+    COMMAND_PAYLOAD_READER = "CommandPayloadReader"
+    NLU = "NLU"
+    CUSTOM = "CUSTOM"
+
+    def __str__(self) -> str:
+        return self.value
 
 
 # the keys for `State` (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)
@@ -181,3 +202,7 @@ POLICY_NAME_RULE = "RulePolicy"
 CLASSIFIER_NAME_FALLBACK = "FallbackClassifier"
 
 POLICIES_THAT_EXTRACT_ENTITIES = {"TEDPolicy"}
+
+# digression constants
+KEY_ASK_CONFIRM_DIGRESSIONS = "ask_confirm_digressions"
+KEY_BLOCK_DIGRESSIONS = "block_digressions"