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

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -7,11 +7,6 @@ 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,
@@ -73,10 +68,6 @@ 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
             )
@@ -119,7 +110,7 @@ class StartFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"StartFlow({self.flow})"
+        return f"start flow {self.flow}"
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[StartFlowCommand]:
@@ -128,36 +119,4 @@ class StartFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        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 []
+        return r"^start flow ['\"]?([a-zA-Z0-9_-]+)['\"]?$"

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,2 +1 @@
 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,17 +6,18 @@ import structlog
 from rasa.dialogue_understanding.commands import (
     Command,
     ErrorCommand,
+    SetSlotCommand,
     StartFlowCommand,
 )
-from rasa.dialogue_understanding.utils import (
-    _handle_via_nlu_in_coexistence,
-)
+from rasa.dialogue_understanding.commands.set_slot_command import SetSlotExtractor
 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,
@@ -91,9 +92,9 @@ class CommandGenerator:
         )
 
         for message in messages:
-            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.
+            if message.get(COMMANDS):
+                # do not overwrite commands if they are already present
+                # i.e. another command generator already predicted commands
                 continue
 
             commands = await self._evaluate_and_predict(
@@ -105,6 +106,9 @@ 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)
 
@@ -274,8 +278,70 @@ class CommandGenerator:
         return len(message.get(TEXT, "").strip()) == 0
 
     @staticmethod
-    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, [])
+    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
+            )
         ]
+
+        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):
+        if match := pattern.search(action.strip()):
             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,10 +8,7 @@ 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,
@@ -21,20 +18,13 @@ 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
@@ -367,7 +357,8 @@ class LLMBasedCommandGenerator(
                     "slots": slots_with_info,
                 }
             )
-        return result
+
+        return sorted(result, key=lambda x: x["name"])
 
     @staticmethod
     def is_extractable(
@@ -463,118 +454,3 @@ 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,14 +190,9 @@ 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 prior_commands
-
-        if self._should_skip_llm_call(prior_commands, flows, tracker):
-            return prior_commands
+            return []
 
         try:
             commands = await self._predict_commands_with_multi_step(
@@ -226,10 +221,7 @@ class MultiStepLLMCommandGenerator(LLMBasedCommandGenerator):
             commands=commands,
         )
 
-        domain = kwargs.get("domain")
-        commands = self._check_commands_against_slot_mappings(commands, tracker, domain)
-
-        return prior_commands + commands
+        return commands
 
     @classmethod
     def parse_commands(

rasa/dialogue_understanding/generator/nlu_command_adapter.py

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

rasa/dialogue_understanding/generator/single_step/command_prompt_template.jinja2

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

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

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

rasa/dialogue_understanding/patterns/correction.py

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