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

rasa/dialogue_understanding/generator/single_step/single_step_llm_command_generator.py

@@ -1,34 +1,21 @@
 import importlib.resources
-from typing import Any, Dict, List, Optional, Text
+from typing import Any, Dict, Optional, Text
 
 import structlog
 
-import rasa.shared.utils.io
-from rasa.dialogue_understanding.commands import (
-    CannotHandleCommand,
-    Command,
-    ErrorCommand,
-    SetSlotCommand,
-)
-from rasa.dialogue_understanding.generator.command_parser import (
-    parse_commands as parse_commands_using_command_parsers,
+from rasa.dialogue_understanding.commands.command_syntax_manager import (
+    CommandSyntaxManager,
+    CommandSyntaxVersion,
 )
 from rasa.dialogue_understanding.generator.constants import (
-    DEFAULT_LLM_CONFIG,
     FLOW_RETRIEVAL_KEY,
     LLM_CONFIG_KEY,
     USER_INPUT_CONFIG_KEY,
 )
 from rasa.dialogue_understanding.generator.flow_retrieval import FlowRetrieval
-from rasa.dialogue_understanding.generator.llm_based_command_generator import (
-    LLMBasedCommandGenerator,
-)
-from rasa.dialogue_understanding.stack.utils import top_flow_frame
-from rasa.dialogue_understanding.utils import (
-    add_commands_to_message_parse_data,
-    add_prompt_to_message_parse_data,
+from rasa.dialogue_understanding.generator.single_step.compact_llm_command_generator import (  # noqa: E501
+    CompactLLMCommandGenerator,
 )
-from rasa.engine.graph import ExecutionContext
 from rasa.engine.recipes.default_recipe import DefaultV1Recipe
 from rasa.engine.storage.resource import Resource
 from rasa.engine.storage.storage import ModelStorage
@@ -36,31 +23,15 @@ from rasa.shared.constants import (
     EMBEDDINGS_CONFIG_KEY,
     PROMPT_CONFIG_KEY,
     PROMPT_TEMPLATE_CONFIG_KEY,
-    ROUTE_TO_CALM_SLOT,
 )
-from rasa.shared.core.flows import FlowsList
-from rasa.shared.core.trackers import DialogueStateTracker
-from rasa.shared.exceptions import ProviderClientAPIException
-from rasa.shared.nlu.constants import LLM_COMMANDS, LLM_PROMPT, TEXT
-from rasa.shared.nlu.training_data.message import Message
-from rasa.shared.providers.llm.llm_response import LLMResponse
 from rasa.shared.utils.io import deep_container_fingerprint
-from rasa.shared.utils.llm import (
-    get_prompt_template,
-    resolve_model_client_config,
-    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"
+from rasa.shared.utils.llm import get_prompt_template, resolve_model_client_config
 
 DEFAULT_COMMAND_PROMPT_TEMPLATE = importlib.resources.read_text(
-    "rasa.dialogue_understanding.generator.single_step",
+    "rasa.dialogue_understanding.generator.prompt_templates",
     "command_prompt_template.jinja2",
 )
-SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE = "config.json"
+
 
 structlogger = structlog.get_logger()
 
@@ -71,7 +42,7 @@ structlogger = structlog.get_logger()
     ],
     is_trainable=True,
 )
-class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
+class SingleStepLLMCommandGenerator(CompactLLMCommandGenerator):
     """A single step LLM-based command generator."""
 
     def __init__(
@@ -110,10 +81,9 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             DEFAULT_COMMAND_PROMPT_TEMPLATE,
         )
 
-        self.trace_prompt_tokens = self.config.get("trace_prompt_tokens", False)
-        self.repeat_command_enabled = self.is_repeat_command_enabled()
+        # Set the command syntax version to v1
+        CommandSyntaxManager.set_syntax_version(CommandSyntaxVersion.v1)
 
-    ### Implementations of LLMBasedCommandGenerator parent
     @staticmethod
     def get_default_config() -> Dict[str, Any]:
         """The component's default config (see parent class for full docstring)."""
@@ -125,216 +95,6 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
             FLOW_RETRIEVAL_KEY: FlowRetrieval.get_default_config(),
         }
 
-    @classmethod
-    def load(
-        cls: Any,
-        config: Dict[str, Any],
-        model_storage: ModelStorage,
-        resource: Resource,
-        execution_context: ExecutionContext,
-        **kwargs: Any,
-    ) -> "SingleStepLLMCommandGenerator":
-        """Loads trained component (see parent class for full docstring)."""
-        # Perform health check of the LLM API endpoint
-        llm_config = resolve_model_client_config(config.get(LLM_CONFIG_KEY, {}))
-        cls.perform_llm_health_check(
-            llm_config,
-            DEFAULT_LLM_CONFIG,
-            "single_step_llm_command_generator.load",
-            SingleStepLLMCommandGenerator.__name__,
-        )
-
-        # load prompt template from the model storage.
-        prompt_template = cls.load_prompt_template_from_model_storage(
-            model_storage, resource, COMMAND_PROMPT_FILE_NAME
-        )
-
-        # init base command generator
-        command_generator = cls(config, model_storage, resource, prompt_template)
-        # load flow retrieval if enabled
-        if command_generator.enabled_flow_retrieval:
-            command_generator.flow_retrieval = cls.load_flow_retrival(
-                command_generator.config, model_storage, resource
-            )
-
-        return command_generator
-
-    def persist(self) -> None:
-        """Persist this component to disk for future loading."""
-        self._persist_prompt_template()
-        self._persist_config()
-        if self.flow_retrieval is not None:
-            self.flow_retrieval.persist()
-
-    def _persist_prompt_template(self) -> None:
-        """Persist prompt template for future loading."""
-        with self._model_storage.write_to(self._resource) as path:
-            rasa.shared.utils.io.write_text_file(
-                self.prompt_template, path / COMMAND_PROMPT_FILE_NAME
-            )
-
-    def _persist_config(self) -> None:
-        """Persist config as a source of truth for resolved clients."""
-        with self._model_storage.write_to(self._resource) as path:
-            rasa.shared.utils.io.dump_obj_as_json_to_file(
-                path / SINGLE_STEP_LLM_COMMAND_GENERATOR_CONFIG_FILE, self.config
-            )
-
-    async def predict_commands(
-        self,
-        message: Message,
-        flows: FlowsList,
-        tracker: Optional[DialogueStateTracker] = None,
-        **kwargs: Any,
-    ) -> List[Command]:
-        """Predict commands using the LLM.
-
-        Args:
-            message: The message from the user.
-            flows: The flows available to the user.
-            tracker: The tracker containing the current state of the conversation.
-            **kwargs: Keyword arguments for forward compatibility.
-
-        Returns:
-            The commands generated by the llm.
-        """
-        if tracker is None or flows.is_empty():
-            # cannot do anything if there are no flows or no tracker
-            return []
-
-        try:
-            commands = await self._predict_commands(message, flows, tracker)
-        except ProviderClientAPIException:
-            # if command predictions resulted in API exception
-            # "predict" the ErrorCommand
-            commands = [ErrorCommand()]
-
-        if not commands:
-            # no commands are parsed or there's an invalid command
-            structlogger.warning(
-                "single_step_llm_command_generator.predict_commands",
-                message="No commands were predicted as the LLM response could "
-                "not be parsed or the LLM responded with an invalid command."
-                "Returning a CannotHandleCommand instead.",
-            )
-            commands = [CannotHandleCommand()]
-
-        if tracker.has_coexistence_routing_slot:
-            # if coexistence feature is used, set the routing slot
-            commands += [SetSlotCommand(ROUTE_TO_CALM_SLOT, True)]
-
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.finished",
-            commands=commands,
-        )
-
-        return commands
-
-    async def _predict_commands(
-        self,
-        message: Message,
-        flows: FlowsList,
-        tracker: Optional[DialogueStateTracker] = None,
-    ) -> List[Command]:
-        """Predict commands using the LLM.
-
-        Args:
-            message: The message from the user.
-            flows: The flows available to the user.
-            tracker: The tracker containing the current state of the conversation.
-
-        Returns:
-            The commands generated by the llm.
-
-        Raises:
-            ProviderClientAPIException: If API calls raised an error.
-        """
-        # retrieve flows
-        filtered_flows = await self.filter_flows(message, flows, tracker)
-
-        flow_prompt = self.render_template(message, tracker, filtered_flows, flows)
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.prompt_rendered",
-            prompt=flow_prompt,
-        )
-
-        response = await self.invoke_llm(flow_prompt)
-        llm_response = LLMResponse.ensure_llm_response(response)
-        # The check for 'None' maintains compatibility with older versions
-        # of LLMCommandGenerator. In previous implementations, 'invoke_llm'
-        # might return 'None' to indicate a failure to generate actions.
-        if llm_response is None or not llm_response.choices:
-            return [ErrorCommand()]
-
-        action_list = llm_response.choices[0]
-
-        log_llm(
-            logger=structlogger,
-            log_module="SingleStepLLMCommandGenerator",
-            log_event="llm_command_generator.predict_commands.actions_generated",
-            action_list=action_list,
-        )
-
-        commands = self.parse_commands(action_list, tracker, flows)
-
-        self._update_message_parse_data_for_fine_tuning(message, commands, flow_prompt)
-        add_commands_to_message_parse_data(
-            message, SingleStepLLMCommandGenerator.__name__, commands
-        )
-        add_prompt_to_message_parse_data(
-            message=message,
-            component_name=SingleStepLLMCommandGenerator.__name__,
-            prompt_name="command_generator_prompt",
-            user_prompt=flow_prompt,
-            llm_response=llm_response,
-        )
-
-        return commands
-
-    @staticmethod
-    def _update_message_parse_data_for_fine_tuning(
-        message: Message, commands: List[Command], prompt: str
-    ) -> None:
-        from rasa.llm_fine_tuning.annotation_module import preparing_fine_tuning_data
-
-        if preparing_fine_tuning_data:
-            # Add commands and prompt to the message object in order to create
-            # prompt -> commands pairs for fine-tuning
-            message.set(
-                LLM_COMMANDS,
-                [command.as_dict() for command in commands],
-                add_to_output=True,
-            )
-            message.set(LLM_PROMPT, prompt, add_to_output=True)
-
-    @classmethod
-    def parse_commands(
-        cls, actions: Optional[str], tracker: DialogueStateTracker, flows: FlowsList
-    ) -> List[Command]:
-        """Parse the actions returned by the llm into intent and entities.
-
-        Args:
-            actions: The actions returned by the llm.
-            tracker: The tracker containing the current state of the conversation.
-            flows: the list of flows
-
-        Returns:
-            The parsed commands.
-        """
-        commands = parse_commands_using_command_parsers(actions, flows)
-        if not commands:
-            structlogger.debug(
-                "single_step_llm_command_generator.parse_commands",
-                message="No commands were parsed from the LLM actions.",
-                actions=actions,
-            )
-
-        return commands
-
     @classmethod
     def fingerprint_addon(cls: Any, config: Dict[str, Any]) -> Optional[str]:
         """Add a fingerprint for the graph."""
@@ -357,69 +117,3 @@ class SingleStepLLMCommandGenerator(LLMBasedCommandGenerator):
         return deep_container_fingerprint(
             [prompt_template, llm_config, embedding_config]
         )
-
-    ### Helper methods
-    def render_template(
-        self,
-        message: Message,
-        tracker: DialogueStateTracker,
-        startable_flows: FlowsList,
-        all_flows: FlowsList,
-    ) -> str:
-        """Render the jinja template to create the prompt for the LLM.
-
-        Args:
-            message: The current message from the user.
-            tracker: The tracker containing the current state of the conversation.
-            startable_flows: The flows startable at this point in time by the user.
-            all_flows: all flows present in the assistant
-
-        Returns:
-            The rendered prompt template.
-        """
-        # need to make this distinction here because current step of the
-        # top_calling_frame would be the call step, but we need the collect step from
-        # the called frame. If no call is active calling and called frame are the same.
-        top_calling_frame = top_flow_frame(tracker.stack)
-        top_called_frame = top_flow_frame(tracker.stack, ignore_call_frames=False)
-
-        top_flow = top_calling_frame.flow(all_flows) if top_calling_frame else None
-        current_step = top_called_frame.step(all_flows) if top_called_frame else None
-
-        flow_slots = self.prepare_current_flow_slots_for_template(
-            top_flow, current_step, tracker
-        )
-        current_slot, current_slot_description = self.prepare_current_slot_for_template(
-            current_step
-        )
-        current_conversation = tracker_as_readable_transcript(tracker)
-        latest_user_message = sanitize_message_for_prompt(message.get(TEXT))
-        current_conversation += f"\nUSER: {latest_user_message}"
-
-        inputs = {
-            "available_flows": self.prepare_flows_for_template(
-                startable_flows, tracker
-            ),
-            "current_conversation": current_conversation,
-            "flow_slots": flow_slots,
-            "current_flow": top_flow.id if top_flow is not None else None,
-            "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/generator/utils.py

@@ -1,14 +1,16 @@
-from typing import Dict, Type
+from typing import Dict, List, Set, Type
 
 from rasa.dialogue_understanding.commands import (
     CancelFlowCommand,
     CannotHandleCommand,
     ChitChatAnswerCommand,
     Command,
+    CorrectSlotsCommand,
     HumanHandoffCommand,
     KnowledgeAnswerCommand,
     RestartCommand,
     SessionStartCommand,
+    SetSlotCommand,
     SkipQuestionCommand,
 )
 from rasa.dialogue_understanding.commands.user_silence_command import UserSilenceCommand
@@ -43,3 +45,32 @@ triggerable_pattern_to_command_class: Dict[str, Type[Command]] = {
     CannotHandlePatternFlowStackFrame.flow_id: CannotHandleCommand,
     RestartPatternFlowStackFrame.flow_id: RestartCommand,
 }
+
+
+def filter_slot_commands(
+    commands: List[Command], overlapping_slot_names: Set[str]
+) -> List[Command]:
+    """Filter out slot commands that set overlapping slots."""
+    filtered_commands = []
+
+    for command in commands:
+        if (
+            isinstance(command, SetSlotCommand)
+            and command.name in overlapping_slot_names
+        ):
+            continue
+
+        if isinstance(command, CorrectSlotsCommand):
+            allowed_slots = [
+                slot
+                for slot in command.corrected_slots
+                if slot.name not in overlapping_slot_names
+            ]
+            if not allowed_slots:
+                continue
+
+            command.corrected_slots = allowed_slots
+
+        filtered_commands.append(command)
+
+    return filtered_commands

rasa/dialogue_understanding/patterns/collect_information.py

@@ -8,7 +8,7 @@ from rasa.dialogue_understanding.stack.frames import (
     PatternFlowStackFrame,
 )
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
-from rasa.shared.core.flows.steps.collect import SlotRejection
+from rasa.shared.core.slots import SlotRejection
 
 FLOW_PATTERN_COLLECT_INFORMATION = (
     RASA_DEFAULT_FLOW_PATTERN_PREFIX + "collect_information"

rasa/dialogue_understanding/patterns/correction.py

@@ -54,6 +54,8 @@ 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:
@@ -70,6 +72,10 @@ 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"],
@@ -77,6 +83,7 @@ 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,
         )
 
 
@@ -118,7 +125,12 @@ class ActionCorrectFlowSlot(action.Action):
             )
             events.extend(tracker.create_stack_updated_events(updated_stack))
 
-        events.extend([SlotSet(k, v) for k, v in top.corrected_slots.items()])
+        events.extend(
+            [
+                SlotSet(name, value=val.get("value"), filled_by=val.get("filled_by"))
+                for name, val in top.corrected_slots.items()
+            ]
+        )
         return events
 
 

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
@@ -299,3 +359,19 @@ flows:
               - action: action_hangup
                 next: END
           - else: END
+
+  pattern_validate_slot:
+    description: Flow for running validations on slots
+    name: pattern validate slot
+    steps:
+      - id: start
+        action: action_run_slot_rejections
+        next:
+          - if: "slots.{{context.validate}} is not null"
+            then: END
+          - else: ask_refill
+      - id: ask_refill
+        action: "{{context.refill_utter}}"
+      - action: "{{context.refill_action}}"
+      - action: action_listen
+        next: start

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