rasa-pro 3.9.18__py3-none-any.whl

rasa/dialogue_understanding/patterns/correction.py

@@ -0,0 +1,278 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, Text, List, Optional
+
+import structlog
+from rasa.core.actions import action
+from rasa.core.channels import OutputChannel
+from rasa.core.nlg import NaturalLanguageGenerator
+from rasa.dialogue_understanding.patterns.collect_information import (
+    CollectInformationPatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.dialogue_stack import DialogueStack
+from rasa.dialogue_understanding.stack.frames import (
+    BaseFlowStackFrame,
+    PatternFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.dialogue_stack_frame import (
+    DialogueStackFrame,
+)
+from rasa.dialogue_understanding.stack.frames.flow_stack_frame import (
+    FlowStackFrameType,
+    UserFlowStackFrame,
+)
+from rasa.dialogue_understanding.stack.utils import top_user_flow_frame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from rasa.shared.core.constants import ACTION_CORRECT_FLOW_SLOT
+from rasa.shared.core.domain import Domain
+from rasa.shared.core.events import Event, SlotSet
+from rasa.shared.core.flows.flow import ContinueFlowStep, END_STEP, START_STEP
+from rasa.shared.core.trackers import DialogueStateTracker
+
+structlogger = structlog.get_logger()
+
+FLOW_PATTERN_CORRECTION_ID = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "correction"
+
+
+@dataclass
+class CorrectionPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which gets added if a slot value is corrected."""
+
+    flow_id: str = FLOW_PATTERN_CORRECTION_ID
+    """The ID of the flow."""
+    is_reset_only: bool = False
+    """Whether the correction is only a reset of the flow.
+
+    This is the case if all corrected slots have `ask_before_filling=True`.
+    In this case, we do not set their value directly but rather reset the flow
+    to the position where the first question is asked to fill the slot."""
+    corrected_slots: Dict[str, Any] = field(default_factory=dict)
+    """The slots that were corrected."""
+    reset_flow_id: Optional[str] = None
+    """The ID of the flow to reset to."""
+    reset_step_id: Optional[str] = None
+    """The ID of the step to reset to."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_CORRECTION_ID
+
+    @staticmethod
+    def from_dict(data: Dict[Text, Any]) -> CorrectionPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return CorrectionPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            is_reset_only=data["is_reset_only"],
+            corrected_slots=data["corrected_slots"],
+            reset_flow_id=data["reset_flow_id"],
+            reset_step_id=data["reset_step_id"],
+        )
+
+
+class ActionCorrectFlowSlot(action.Action):
+    """Action which corrects a slots value in a flow."""
+
+    def __init__(self) -> None:
+        """Creates a `ActionCorrectFlowSlot`."""
+        super().__init__()
+
+    def name(self) -> Text:
+        """Return the flow name."""
+        return ACTION_CORRECT_FLOW_SLOT
+
+    async def run(
+        self,
+        output_channel: "OutputChannel",
+        nlg: "NaturalLanguageGenerator",
+        tracker: "DialogueStateTracker",
+        domain: "Domain",
+        metadata: Optional[Dict[Text, Any]] = None,
+    ) -> List[Event]:
+        """Correct the slots."""
+        stack = tracker.stack
+        if not (top := stack.top()):
+            structlogger.warning("action.correct_flow_slot.no_active_flow")
+            return []
+
+        if not isinstance(top, CorrectionPatternFlowStackFrame):
+            structlogger.warning(
+                "action.correct_flow_slot.no_correction_frame", top=top
+            )
+            return []
+
+        events: List[Event] = []
+        if top.reset_flow_id:
+            updated_stack = reset_stack_on_tracker_to_prior_state(
+                top.reset_flow_id, top.reset_step_id or START_STEP, tracker
+            )
+            events.extend(tracker.create_stack_updated_events(updated_stack))
+
+        events.extend([SlotSet(k, v) for k, v in top.corrected_slots.items()])
+        return events
+
+
+def find_previous_state_to_reset_to(
+    reset_flow_id: str, reset_step_id: str, tracker: DialogueStateTracker
+) -> Optional[DialogueStack]:
+    """Find the previous stack state where the reset step was the active stack frame.
+
+    Looks for the most recent state of the stack in the tracker where the top
+    flow has the same flow id and step id as the reset flow id and reset step id.
+    """
+    stack_to_reset_to: Optional[DialogueStack] = None
+    for previous_stack_state in tracker.previous_stack_states():
+        top_frame = previous_stack_state.top()
+        if (
+            isinstance(top_frame, BaseFlowStackFrame)
+            and top_frame.flow_id == reset_flow_id
+            and top_frame.step_id == reset_step_id
+        ):
+            stack_to_reset_to = previous_stack_state
+    return stack_to_reset_to
+
+
+def slice_of_stack_below_target(
+    target_frame: DialogueStackFrame, stack: DialogueStack
+) -> List[DialogueStackFrame]:
+    """Get all the frames from the current stack up until the target frame.
+
+    The target frame is not included."""
+    replacement_stack: List[DialogueStackFrame] = []
+
+    for frame in stack.frames:
+        if frame.frame_id == target_frame.frame_id:
+            break
+        replacement_stack.append(frame)
+    return replacement_stack
+
+
+def slice_of_stack_with_target_and_above(
+    target_frame: DialogueStackFrame, stack: DialogueStack
+) -> List[DialogueStackFrame]:
+    """Get all the frames from the current stack starting at the target frame."""
+    replacement_frames: List[DialogueStackFrame] = []
+    for frame in reversed(stack.frames):
+        replacement_frames.insert(0, frame)  # push to front, since reversed
+        if frame.frame_id == target_frame.frame_id:
+            break
+    return replacement_frames
+
+
+def set_topmost_flow_frame_to_continue(stack_frames: List[DialogueStackFrame]) -> None:
+    """Ensure that the topmost flow frame continues its step.
+
+    This ensures that the topmost step can be re-executed."""
+    for frame in reversed(stack_frames):
+        if isinstance(frame, BaseFlowStackFrame) and frame.step_id != START_STEP:
+            frame.step_id = ContinueFlowStep.continue_step_for_id(frame.step_id)
+            break
+
+
+def create_termination_frames_for_missing_frames(
+    new_stack_frames: List[DialogueStackFrame], previous_stack: DialogueStack
+) -> List[DialogueStackFrame]:
+    """Terminate frames that are part in the previous stack but not in the new stack.
+
+    The frames are terminated by setting them to the END_STEP. This allows
+    them to be properly wrapped up.
+    """
+
+    reused_frame_ids = {frame.frame_id for frame in new_stack_frames}
+
+    frames_to_terminate: List[DialogueStackFrame] = []
+    for frame in reversed(previous_stack.frames):
+        if frame.frame_id in reused_frame_ids:
+            # this frame already exists in the replacement stack, skip it
+            # shouldn't be terminated
+            continue
+        if (
+            isinstance(frame, UserFlowStackFrame)
+            and frame.frame_type == FlowStackFrameType.CALL
+        ):
+            frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
+        if isinstance(frame, CollectInformationPatternFlowStackFrame):
+            frame.step_id = ContinueFlowStep.continue_step_for_id(END_STEP)
+        frames_to_terminate.insert(0, frame)
+    return frames_to_terminate
+
+
+def reset_stack_on_tracker_to_prior_state(
+    reset_flow_id: str, reset_step_id: str, tracker: DialogueStateTracker
+) -> DialogueStack:
+    """Reset the stack on the tracker to the prior state."""
+    # assumption is that we have already been at the reset step id in the reset flow
+    # at some point before in the tracker. we'll search for that point in time and
+    # update the current stack to be as close to that time as possible,
+    # jumping back in time.
+    stack_to_reset_to: Optional[DialogueStack] = find_previous_state_to_reset_to(
+        reset_flow_id, reset_step_id, tracker
+    )
+
+    if not stack_to_reset_to:
+        structlogger.warning(
+            "action.correct_flow_slot.no_frame_found",
+            reset_step_id=reset_step_id,
+            reset_flow_id=reset_flow_id,
+        )
+        return tracker.stack
+
+    target_frame = top_user_flow_frame(stack_to_reset_to)
+
+    if not target_frame:
+        structlogger.warning(
+            "action.correct_flow_slot.no_target_frame_found",
+            reset_step_id=reset_step_id,
+            reset_flow_id=reset_flow_id,
+            stack_to_reset_to=stack_to_reset_to,
+        )
+        return tracker.stack
+
+    current_stack = tracker.stack
+
+    # Approach we use to reset the stack:
+    # 1. Search through all past stack states and identify the most recent
+    #    state where the stack had the given flow and step id on top. This
+    #    stack is the reference stack.
+    # 2. On the reference stack, identify the top most user flow frame that
+    #    was not started through a flow call. This frame is the reference frame.
+    # 3. Create a new stack by stacking the following frames: A) all frames
+    #    from the current stack that are strictly below the reference
+    #    frame. B) all frames including the reference frame and frames above
+    #    it from the reference stack. C) all frames from the current stack
+    #    that are strictly above the reference frame and set them to their
+    #    end step.
+    # 4. This will ensure A) we keep anything from the current stack that is
+    #    below the current active user flow. B) We reset the current user
+    #    flow to the desired position. C) we wrap up all unfinished frames
+    #    above the current user flow from the current state.
+
+    replacement_stack: List[DialogueStackFrame] = []
+
+    # get all the frames from the current stack up until the target frame
+    # and put them into the replacement stack. the target frame is not included
+    replacement_stack.extend(slice_of_stack_below_target(target_frame, current_stack))
+
+    replacement_stack.extend(
+        slice_of_stack_with_target_and_above(target_frame, stack_to_reset_to)
+    )
+
+    # ensure that we continue the topmost frames step
+    set_topmost_flow_frame_to_continue(replacement_stack)
+
+    # terminate all the frames from the original stack that are not part of the
+    # replacement stack. this will add these frames to the replacement stack,
+    # but with their step set to END_STEP. this allows them to be properly
+    # wrapped up before we head into the correction.
+    replacement_stack.extend(
+        create_termination_frames_for_missing_frames(replacement_stack, current_stack)
+    )
+    return DialogueStack(frames=replacement_stack)

rasa/dialogue_understanding/patterns/default_flows_for_patterns.yml

@@ -0,0 +1,248 @@
+version: "3.1"
+responses:
+
+  utter_ask_rephrase:
+    - text: I’m sorry I am unable to understand you, could you please rephrase?
+
+  utter_boolean_slot_rejection:
+    - text: "Sorry, the value you provided, `{{value}}`, is not valid. Please respond with a valid value."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_can_do_something_else:
+    - text: "What else can I help you with?"
+      metadata:
+        rephrase: True
+
+  utter_cannot_handle:
+    - text: I'm sorry, I'm not trained to help with that.
+
+  utter_categorical_slot_rejection:
+    - text: "Sorry, you responded with an invalid value - `{{value}}`. Please select one of the available options."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_clarification_options_rasa:
+    - text: "I can help, but I need more information. Which of these would you like to do: {{context.clarification_options}}?"
+      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."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_float_slot_rejection:
+    - text: "Sorry, it seems the value you provided `{{value}}` is not a valid number. Please provide a valid number in your response."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_flow_cancelled_rasa:
+    - text: "Okay, stopping {{ context.canceled_name }}."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_flow_continue_interrupted:
+    - text: "Let's continue with {{ context.previous_flow_name }}."
+      metadata:
+        rephrase: True
+        template: jinja
+
+  utter_free_chitchat_response:
+    - text: "Sorry, I'm not able to answer that right now."
+      metadata:
+        rephrase: True
+        rephrase_prompt: |
+          You are an incredibly friendly assistant. Generate a short
+          response to the user's comment in simple english.
+
+          User: {{current_input}}
+          Response:
+
+  utter_human_handoff_not_available:
+    - text: I understand you want to be connected to a human agent, but that's something I cannot help you with at the moment. Is there something else I can help you with?
+      metadata:
+        rephrase: True
+
+  utter_inform_code_change:
+    - text: There has been an update to my code. I need to wrap up our running dialogue and start from scratch.
+      metadata:
+        rephrase: True
+
+  utter_internal_error_rasa:
+    - text: Sorry, I am having trouble with that. Please try again in a few minutes.
+
+  utter_no_knowledge_base:
+    - text: I am afraid, I don't know the answer. At this point, I don't have access to a knowledge base.
+      metadata:
+        rephrase: True
+
+  utter_skip_question_answer:
+    - text: I'm here to provide you with the best assistance, and in order to do so, I kindly request that we complete this step together. Your input is essential for a seamless experience!
+      metadata:
+        rephrase: True
+
+  utter_user_input_empty_error_rasa:
+    - text: I see an empty message. What can I assist you with?
+
+  utter_user_input_too_long_error_rasa:
+    - text: I'm sorry, but your message is too long for me to process. Please keep your message concise and within {% if context.info.max_characters %}{{context.info.max_characters}} characters.{% else %}a reasonable length.{% endif %}
+      metadata:
+        template: jinja
+
+slots:
+  confirm_correction:
+    type: bool
+    mappings:
+      - type: from_llm
+
+flows:
+  pattern_cancel_flow:
+    description: Conversation repair flow that starts when a flow is cancelled
+    name: pattern_cancel_flow
+    steps:
+      - action: action_cancel_flow
+      - action: utter_flow_cancelled_rasa
+
+  pattern_cannot_handle:
+    description: |
+      Conversation repair flow for addressing failed command generation scenarios
+    name: pattern cannot handle
+    steps:
+      - noop: true
+        next:
+          # chitchat fallback
+          - if: "'{{context.reason}}' = 'cannot_handle_chitchat'"
+            then:
+              - action: utter_cannot_handle
+                next: "END"
+          # fallback for things that are not supported
+          - if: "'{{context.reason}}' = 'cannot_handle_not_supported'"
+            then:
+              - action: utter_cannot_handle
+                next: END
+          # default
+          - else:
+              - action: utter_ask_rephrase
+                next: END
+
+  pattern_chitchat:
+    description: Conversation repair flow for off-topic interactions that won't disrupt the main conversation
+    name: pattern chitchat
+    steps:
+      - action: action_trigger_chitchat
+
+  pattern_clarification:
+    description: Conversation repair flow for handling ambiguous requests that could match multiple flows
+    name: pattern clarification
+    steps:
+      - action: action_clarify_flows
+      - action: utter_clarification_options_rasa
+
+  pattern_code_change:
+    description: Conversation repair flow for cleaning the stack after an assistant update
+    name: pattern code change
+    steps:
+      - action: utter_inform_code_change
+      - action: action_clean_stack
+
+  pattern_collect_information:
+    description: Flow for collecting information from users
+    name: pattern collect information
+    steps:
+      - id: start
+        action: action_run_slot_rejections
+      - action: validate_{{context.collect}}
+        next:
+          - if: "slots.{{context.collect}} is not null"
+            then: END
+          - else: ask_collect
+      - id: ask_collect
+        action: "{{context.utter}}"
+      - action: "{{context.collect_action}}"
+      - action: action_listen
+        next: start
+
+  pattern_completed:
+    description: Flow that asks if the user needs more help after completing their initiated use cases
+    name: pattern completed
+    steps:
+      - action: utter_can_do_something_else
+
+  pattern_continue_interrupted:
+    description: Conversation repair flow for managing when users switch between different flows
+    name: pattern continue interrupted
+    steps:
+      - action: utter_flow_continue_interrupted
+
+  pattern_correction:
+    description: Conversation repair flow for managing user input changes or error corrections
+    name: pattern correction
+    steps:
+      - action: action_correct_flow_slot
+        next:
+          - if: not context.is_reset_only
+            then:
+              - action: utter_corrected_previous_input
+                next: END
+          - else: 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
+    steps:
+      - action: utter_human_handoff_not_available
+
+  pattern_internal_error:
+    description: Conversation repair flow for informing users about internal errors
+    name: pattern internal error
+    steps:
+      - noop: true
+        next:
+          - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_too_long'"
+            then:
+              - action: utter_user_input_too_long_error_rasa
+                next: END
+          - if: "'{{context.error_type}}' = 'rasa_internal_error_user_input_empty'"
+            then:
+              - action: utter_user_input_empty_error_rasa
+                next: END
+          - else:
+              - action: utter_internal_error_rasa
+                next: END
+
+
+  pattern_restart:
+    description: Flow for restarting the conversation
+    name: pattern restart
+    nlu_trigger:
+      - intent: restart
+    steps:
+      - action: action_restart
+
+  pattern_search:
+    description: Flow for handling knowledge-based questions
+    name: pattern search
+    steps:
+      - action: utter_no_knowledge_base
+      # - action: action_trigger_search to use doc search policy if present
+
+  pattern_session_start:
+    description: Flow for starting the conversation
+    name: pattern session start
+    nlu_trigger:
+      - intent: session_start
+    steps:
+      - action: action_session_start
+
+  pattern_skip_question:
+    description: Conversation repair flow for managing user intents to skip questions (steps)
+    name: pattern skip question
+    steps:
+      - action: utter_skip_question_answer

rasa/dialogue_understanding/patterns/human_handoff.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_HUMAN_HANDOFF = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "human_handoff"
+
+
+@dataclass
+class HumanHandoffPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame which hands off to a human."""
+
+    flow_id: str = FLOW_PATTERN_HUMAN_HANDOFF
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_HUMAN_HANDOFF
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> HumanHandoffPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return HumanHandoffPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/internal_error.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import Any, Dict, Optional, Text
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX,
+    RASA_PATTERN_INTERNAL_ERROR_DEFAULT,
+)
+
+FLOW_PATTERN_INTERNAL_ERROR_ID = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "internal_error"
+
+
+@dataclass
+class InternalErrorPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame that gets added if an internal error occurs."""
+
+    flow_id: str = FLOW_PATTERN_INTERNAL_ERROR_ID
+    """The ID of the flow."""
+
+    error_type: Optional[Text] = RASA_PATTERN_INTERNAL_ERROR_DEFAULT
+    """Error type used in switch-case of the error pattern flow."""
+
+    info: Dict[Text, Any] = field(default_factory=dict)
+    """Additional info to be provided to the user"""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_INTERNAL_ERROR_ID
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> InternalErrorPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return InternalErrorPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+            error_type=data.get("error_type", RASA_PATTERN_INTERNAL_ERROR_DEFAULT),
+            info=data.get("info", {}),
+        )

rasa/dialogue_understanding/patterns/search.py

@@ -0,0 +1,37 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+
+FLOW_PATTERN_SEARCH = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "search"
+
+
+@dataclass
+class SearchPatternFlowStackFrame(PatternFlowStackFrame):
+    """A stack frame that gets added to respond to knowledge-oriented questions."""
+
+    flow_id: str = FLOW_PATTERN_SEARCH
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_SEARCH
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SearchPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return SearchPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )

rasa/dialogue_understanding/patterns/skip_question.py

@@ -0,0 +1,38 @@
+from __future__ import annotations
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from rasa.dialogue_understanding.stack.frames import PatternFlowStackFrame
+from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+
+FLOW_PATTERN_SKIP_QUESTION = RASA_DEFAULT_FLOW_PATTERN_PREFIX + "skip_question"
+
+
+@dataclass
+class SkipQuestionPatternFlowStackFrame(PatternFlowStackFrame):
+    """A pattern flow stack frame that gets added if user interrupts the current flow by
+    trying to bypass the collect information step.
+    """
+
+    flow_id: str = FLOW_PATTERN_SKIP_QUESTION
+    """The ID of the flow."""
+
+    @classmethod
+    def type(cls) -> str:
+        """Returns the type of the frame."""
+        return FLOW_PATTERN_SKIP_QUESTION
+
+    @staticmethod
+    def from_dict(data: Dict[str, Any]) -> SkipQuestionPatternFlowStackFrame:
+        """Creates a `DialogueStackFrame` from a dictionary.
+
+        Args:
+            data: The dictionary to create the `DialogueStackFrame` from.
+
+        Returns:
+            The created `DialogueStackFrame`.
+        """
+        return SkipQuestionPatternFlowStackFrame(
+            frame_id=data["frame_id"],
+            step_id=data["step_id"],
+        )