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

rasa/dialogue_understanding/commands/change_flow_command.py

@@ -5,6 +5,10 @@ from dataclasses import dataclass
 from typing import Any, Dict, List
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.shared.core.events import Event
 from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.trackers import DialogueStateTracker
@@ -48,7 +52,14 @@ class ChangeFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "ChangeFlow()"
+        mapper = {
+            CommandSyntaxVersion.v1: "ChangeFlow()",
+            CommandSyntaxVersion.v2: "change",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @staticmethod
     def from_dsl(match: re.Match, **kwargs: Any) -> ChangeFlowCommand:
@@ -57,4 +68,11 @@ class ChangeFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"ChangeFlow\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"ChangeFlow\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*change$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/chit_chat_answer_command.py

@@ -4,6 +4,10 @@ import re
 from dataclasses import dataclass
 from typing import Any, Dict, List
 
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
@@ -59,7 +63,14 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "ChitChat()"
+        mapper = {
+            CommandSyntaxVersion.v1: "ChitChat()",
+            CommandSyntaxVersion.v2: "offtopic reply",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> ChitChatAnswerCommand:
@@ -68,4 +79,11 @@ class ChitChatAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"ChitChat\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"ChitChat\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*offtopic reply$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/clarify_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List, Optional
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.utils import extract_cleaned_options
 from rasa.dialogue_understanding.patterns.clarify import ClarifyPatternFlowStackFrame
 from rasa.shared.core.events import Event
@@ -74,7 +78,13 @@ class ClarifyCommand(Command):
 
         stack = tracker.stack
         relevant_flows = [all_flows.flow_by_id(opt) for opt in clean_options]
-        names = [flow.readable_name() for flow in relevant_flows if flow is not None]
+
+        names = [
+            flow.readable_name(language=tracker.current_language)
+            for flow in relevant_flows
+            if flow is not None
+        ]
+
         stack.push(ClarifyPatternFlowStackFrame(names=names))
         return tracker.create_stack_updated_events(stack)
 
@@ -89,7 +99,14 @@ class ClarifyCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"Clarify({', '.join(self.options)})"
+        mapper = {
+            CommandSyntaxVersion.v1: f"Clarify({', '.join(self.options)})",
+            CommandSyntaxVersion.v2: f"disambiguate flows {' '.join(self.options)}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[ClarifyCommand]:
@@ -99,4 +116,13 @@ class ClarifyCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"Clarify\(([\"\'a-zA-Z0-9_, ]*)\)",
+            CommandSyntaxVersion.v2: (
+                r"^[^\w]*disambiguate flows ([\"\'a-zA-Z0-9_, ]*)$"
+            ),
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/command.py

@@ -1,9 +1,8 @@
 from __future__ import annotations
 
 import dataclasses
-import re
 from dataclasses import dataclass
-from typing import Any, Dict, List, Optional
+from typing import Any, Dict, List
 
 import rasa.shared.utils.common
 from rasa.shared.core.events import Event
@@ -85,17 +84,3 @@ class Command:
             The events to apply to the tracker.
         """
         raise NotImplementedError()
-
-    def to_dsl(self) -> str:
-        """Converts the command to a DSL string."""
-        raise NotImplementedError()
-
-    @classmethod
-    def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[Command]:
-        """Converts the DSL string to a command."""
-        raise NotImplementedError()
-
-    @staticmethod
-    def regex_pattern() -> str:
-        """Returns the regex pattern for the command."""
-        raise NotImplementedError()

rasa/dialogue_understanding/commands/command_syntax_manager.py

@@ -0,0 +1,55 @@
+from enum import Enum
+from typing import Optional
+
+import structlog
+
+
+class CommandSyntaxVersion(Enum):
+    """Defines different syntax versions for commands."""
+
+    v1 = "v1"
+    v2 = "v2"
+
+
+structlogger = structlog.get_logger()
+
+
+class CommandSyntaxManager:
+    """A class to manage the command syntax version. It is used to set and get the
+    command syntax version. This class provides a way to introduce new syntax versions
+    for commands in the future. Hence, it is for internal use only.
+    """
+
+    _version = None  # Directly store the version as a class attribute
+
+    @classmethod
+    def set_syntax_version(cls, version: CommandSyntaxVersion) -> None:
+        """Sets the command syntax version on the class itself.
+        This method is called only once at the time of LLMCommandGenerator
+        initialization to set the command syntax version, which ensures that the command
+        syntax version remains consistent throughout the lifetime of the generator.
+        """
+        if cls._version:
+            structlogger.warn(
+                "command_syntax_manager.syntax_version_already_set",
+                event_info=(
+                    f"The command syntax version has already been set. Overwriting "
+                    f"the existing version with the new version - {version}."
+                ),
+            )
+        cls._version = version
+
+    @classmethod
+    def get_syntax_version(cls) -> Optional[CommandSyntaxVersion]:
+        """Fetches the stored command syntax version."""
+        return cls._version
+
+    @staticmethod
+    def get_default_syntax_version() -> CommandSyntaxVersion:
+        """Returns the default command syntax version."""
+        return CommandSyntaxVersion.v1
+
+    @classmethod
+    def reset_syntax_version(cls) -> None:
+        """Resets the command syntax version. Implemented for use in testing."""
+        cls._version = None

rasa/dialogue_understanding/commands/human_handoff_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.human_handoff import (
     HumanHandoffPatternFlowStackFrame,
 )
@@ -66,7 +70,14 @@ class HumanHandoffCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "HumanHandoff()"
+        mapper = {
+            CommandSyntaxVersion.v1: "HumanHandoff()",
+            CommandSyntaxVersion.v2: "hand over",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> HumanHandoffCommand:
@@ -75,4 +86,11 @@ class HumanHandoffCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"HumanHandoff\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"HumanHandoff\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*hand over$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/knowledge_answer_command.py

@@ -4,6 +4,10 @@ import re
 from dataclasses import dataclass
 from typing import Any, Dict, List
 
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.free_form_answer_command import (
     FreeFormAnswerCommand,
 )
@@ -59,7 +63,14 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "SearchAndReply()"
+        mapper = {
+            CommandSyntaxVersion.v1: "SearchAndReply()",
+            CommandSyntaxVersion.v2: "provide info",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> KnowledgeAnswerCommand:
@@ -68,4 +79,11 @@ class KnowledgeAnswerCommand(FreeFormAnswerCommand):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"SearchAndReply\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"SearchAndReply\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*provide info$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/prompt_command.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import re
+from typing import Any, Dict, List, Optional, Protocol, runtime_checkable
+
+from rasa.shared.core.events import Event
+from rasa.shared.core.flows import FlowsList
+from rasa.shared.core.trackers import DialogueStateTracker
+
+
+@runtime_checkable
+class PromptCommand(Protocol):
+    """
+    A protocol for commands predicted by the LLM model and incorporated into the prompt.
+    """
+
+    @classmethod
+    def command(cls) -> str:
+        """
+        Returns the command name.
+
+        This class method should be implemented to return the name of the command.
+        """
+        ...
+
+    @classmethod
+    def from_dict(cls, data: Dict[str, Any]) -> PromptCommand:
+        """
+        Converts the dictionary to a command.
+
+        This class method should be implemented to create a command instance from the
+        given dictionary.
+        """
+        ...
+
+    def run_command_on_tracker(
+        self,
+        tracker: DialogueStateTracker,
+        all_flows: FlowsList,
+        original_tracker: DialogueStateTracker,
+    ) -> List[Event]:
+        """
+        Runs the command on the tracker.
+
+        This method should be implemented to execute the command on the given tracker.
+        """
+        ...
+
+    def __hash__(self) -> int:
+        """
+        Returns the hash of the command.
+
+        This method should be implemented to return the hash of the command.
+        Useful for comparing commands and storing them in sets.
+        """
+        ...
+
+    def __eq__(self, other: object) -> bool:
+        """
+        Compares the command with another object.
+
+        This method should be implemented to compare the command with another object.
+        """
+        ...
+
+    def to_dsl(self) -> str:
+        """
+        Converts the command to a DSL string.
+
+        This method should be implemented to convert the command to a DSL string.
+        A DSL string is a string representation of the command that is used in the
+        prompt.
+        """
+        ...
+
+    @classmethod
+    def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[PromptCommand]:
+        """
+        Converts the regex match to a command.
+
+        This class method should be implemented to create a command instance from the
+        given DSL string.
+        """
+        ...
+
+    @staticmethod
+    def regex_pattern() -> str:
+        """
+        Returns the regex pattern for the command.
+
+        This method should be implemented to return the regex pattern that matches the
+        command in the prompt.
+        """
+        ...

rasa/dialogue_understanding/commands/repeat_bot_messages_command.py

@@ -5,6 +5,10 @@ from dataclasses import dataclass
 from typing import Any, Dict, List
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.repeat import (
     RepeatBotMessagesPatternFlowStackFrame,
 )
@@ -60,7 +64,14 @@ class RepeatBotMessagesCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "RepeatLastBotMessages()"
+        mapper = {
+            CommandSyntaxVersion.v1: "RepeatLastBotMessages()",
+            CommandSyntaxVersion.v2: "repeat message",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> RepeatBotMessagesCommand:
@@ -69,4 +80,11 @@ class RepeatBotMessagesCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"RepeatLastBotMessages\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"RepeatLastBotMessages\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*repeat message$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/set_slot_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.commands.utils import (
     clean_extracted_value,
     get_nullable_slot_value,
@@ -162,7 +166,14 @@ class SetSlotCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"SetSlot({self.name}, {self.value})"
+        mapper = {
+            CommandSyntaxVersion.v1: f"SetSlot({self.name}, {self.value})",
+            CommandSyntaxVersion.v2: f"set slot {self.name} {self.value}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SetSlotCommand:
@@ -173,4 +184,15 @@ class SetSlotCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+        mapper = {
+            CommandSyntaxVersion.v1: (
+                r"""SetSlot\(['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]?, ?['"]?(.*)['"]?\)"""
+            ),
+            CommandSyntaxVersion.v2: (
+                r"""^[^\w]*set slot ['"]?([a-zA-Z_][a-zA-Z0-9_-]*)['"]? ['"]?(.+?)['"]?$"""  # noqa: E501
+            ),
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/skip_question_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.skip_question import (
     SkipQuestionPatternFlowStackFrame,
 )
@@ -75,7 +79,14 @@ class SkipQuestionCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return "SkipQuestion()"
+        mapper = {
+            CommandSyntaxVersion.v1: "SkipQuestion()",
+            CommandSyntaxVersion.v2: "skip question",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> SkipQuestionCommand:
@@ -84,4 +95,11 @@ class SkipQuestionCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"SkipQuestion\(\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"SkipQuestion\(\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*skip question$",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )

rasa/dialogue_understanding/commands/start_flow_command.py

@@ -7,6 +7,10 @@ from typing import Any, Dict, List, Optional
 import structlog
 
 from rasa.dialogue_understanding.commands.command import Command
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
+)
 from rasa.dialogue_understanding.patterns.clarify import FLOW_PATTERN_CLARIFICATION
 from rasa.dialogue_understanding.patterns.continue_interrupted import (
     ContinueInterruptedPatternFlowStackFrame,
@@ -119,7 +123,14 @@ class StartFlowCommand(Command):
 
     def to_dsl(self) -> str:
         """Converts the command to a DSL string."""
-        return f"StartFlow({self.flow})"
+        mapper = {
+            CommandSyntaxVersion.v1: f"StartFlow({self.flow})",
+            CommandSyntaxVersion.v2: f"start flow {self.flow}",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     @classmethod
     def from_dsl(cls, match: re.Match, **kwargs: Any) -> Optional[StartFlowCommand]:
@@ -128,7 +139,14 @@ class StartFlowCommand(Command):
 
     @staticmethod
     def regex_pattern() -> str:
-        return r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)"
+        mapper = {
+            CommandSyntaxVersion.v1: r"StartFlow\(['\"]?([a-zA-Z0-9_-]+)['\"]?\)",
+            CommandSyntaxVersion.v2: r"^[^\w]*start flow ['\"]?([a-zA-Z0-9_-]+)['\"]?",
+        }
+        return mapper.get(
+            CommandSyntaxManager.get_syntax_version(),
+            mapper[CommandSyntaxManager.get_default_syntax_version()],
+        )
 
     def change_flow_frame_position_in_the_stack(
         self, stack: DialogueStack, tracker: DialogueStateTracker

rasa/dialogue_understanding/commands/utils.py

@@ -1,7 +1,18 @@
-from typing import TYPE_CHECKING, List, Optional, Union
+from typing import TYPE_CHECKING, Any, List, Optional, Tuple, Union
 
 import structlog
 
+from rasa.dialogue_understanding.patterns.validate_slot import (
+    ValidateSlotPatternFlowStackFrame,
+)
+from rasa.shared.constants import (
+    ACTION_ASK_PREFIX,
+    UTTER_ASK_PREFIX,
+)
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.slots import Slot
+from rasa.shared.core.trackers import DialogueStateTracker
+
 if TYPE_CHECKING:
     from rasa.dialogue_understanding.commands import StartFlowCommand
     from rasa.shared.core.flows import FlowsList
@@ -25,10 +36,13 @@ def start_flow_by_name(
 
 def extract_cleaned_options(options_str: str) -> List[str]:
     """Extract and clean options from a string."""
+    delimiters = [",", " "]
+
+    for delimiter in delimiters:
+        options_str = options_str.replace(delimiter, " ")
+
     return sorted(
-        opt.strip().strip('"').strip("'")
-        for opt in options_str.split(",")
-        if opt.strip()
+        opt.strip().strip('"').strip("'") for opt in options_str.split() if opt.strip()
     )
 
 
@@ -62,3 +76,83 @@ def get_nullable_slot_value(slot_value: str) -> Union[str, None]:
         The slot value or None if the value is a none value.
     """
     return slot_value if not is_none_value(slot_value) else None
+
+
+def initialize_pattern_validate_slot(
+    slot: Slot,
+) -> Optional[ValidateSlotPatternFlowStackFrame]:
+    """Initialize the pattern to validate a slot value."""
+    if not slot.requires_validation():
+        return None
+
+    validation = slot.validation
+    slot_name = slot.name
+    return ValidateSlotPatternFlowStackFrame(
+        validate=slot_name,
+        refill_utter=validation.refill_utter or f"{UTTER_ASK_PREFIX}{slot_name}",  # type: ignore[union-attr]
+        refill_action=f"{ACTION_ASK_PREFIX}{slot_name}",
+        rejections=validation.rejections,  # type: ignore[union-attr]
+    )
+
+
+def create_validate_frames_from_slot_set_events(
+    tracker: DialogueStateTracker,
+    events: List[Event],
+    validate_frames: List[ValidateSlotPatternFlowStackFrame] = [],
+    should_break: bool = False,
+    update_corrected_slots: bool = False,
+) -> Tuple[DialogueStateTracker, List[ValidateSlotPatternFlowStackFrame]]:
+    """Process SlotSet events and create validation frames.
+
+    Args:
+        tracker: The dialogue state tracker.
+        events: List of events to process.
+        should_break:  whether or not to break after the first non-SlotSet event.
+            if True, break out of the event loop as soon as the first non-SlotSet
+            event is encountered.
+            if False, continue processing the events until the end.
+        update_corrected_slots: whether or not corrected slots in the last
+            correction frame need to be updated.
+
+    Returns:
+        Tuple of (updated tracker, list of validation frames).
+    """
+    for event in events:
+        if not isinstance(event, SlotSet):
+            if should_break:
+                # we want to only process the most recent SlotSet events
+                # so we break once we encounter a different event
+                break
+            continue
+
+        slot = tracker.slots.get(event.key)
+        frame = initialize_pattern_validate_slot(slot)
+
+        if frame:
+            validate_frames.append(frame)
+            if update_corrected_slots:
+                tracker = update_corrected_slots_in_correction_frame(
+                    tracker, event.key, event.value
+                )
+
+    return tracker, validate_frames
+
+
+def update_corrected_slots_in_correction_frame(
+    tracker: DialogueStateTracker, slot_name: str, slot_value: Any
+) -> DialogueStateTracker:
+    """Update the corrected_slots and new_slot_values of the
+    CorrectionPatternFlowStackFrame with only valid values.
+    """
+    stack = tracker.stack
+    top_frame = stack.top()
+    del top_frame.corrected_slots[slot_name]  # type: ignore[union-attr]
+    top_frame.new_slot_values.remove(slot_value)  # type: ignore[union-attr]
+
+    # since we can't directly modify a stack we have to pop first
+    # and then push back the updated frame
+    stack.pop()
+    stack.push(top_frame)
+    new_events = tracker.create_stack_updated_events(stack)
+    tracker.update_with_events(new_events)
+    return tracker