rasa-pro 3.12.18.dev1__py3-none-any.whl → 3.13.0a1.dev1__py3-none-any.whl

rasa/shared/core/constants.py

@@ -113,10 +113,11 @@ FLOW_HASHES_SLOT = "flow_hashes"
 FLOW_SLOT_NAMES = [FLOW_HASHES_SLOT]
 
 # slots for audio timeout
-SLOT_SILENCE_TIMEOUT = "silence_timeout"
+GLOBAL_SILENCE_TIMEOUT_KEY = "global_silence_timeout"
+SILENCE_TIMEOUT_SLOT = "silence_timeout"
 SLOT_CONSECUTIVE_SILENCE_TIMEOUTS = "consecutive_silence_timeouts"
-SILENCE_TIMEOUT_DEFAULT_VALUE = 6.0
-SILENCE_SLOTS = [SLOT_SILENCE_TIMEOUT, SLOT_CONSECUTIVE_SILENCE_TIMEOUTS]
+GLOBAL_SILENCE_TIMEOUT_DEFAULT_VALUE = 7.0
+SILENCE_SLOTS = [SILENCE_TIMEOUT_SLOT, SLOT_CONSECUTIVE_SILENCE_TIMEOUTS]
 # slots for knowledge base
 SLOT_LISTED_ITEMS = "knowledge_base_listed_objects"
 SLOT_LAST_OBJECT = "knowledge_base_last_object"

rasa/shared/core/domain.py

@@ -32,6 +32,7 @@ from ruamel.yaml.scalarstring import DoubleQuotedScalarString
 import rasa.shared.core.slot_mappings
 import rasa.shared.utils.common
 import rasa.shared.utils.io
+from rasa.core.available_endpoints import AvailableEndpoints
 from rasa.shared.constants import (
     DEFAULT_CARRY_OVER_SLOTS_TO_NEW_SESSION,
     DEFAULT_SESSION_EXPIRATION_TIME_IN_MINUTES,
@@ -48,6 +49,7 @@ from rasa.shared.core.constants import (
     ACTION_SHOULD_SEND_DOMAIN,
     KEY_MAPPING_TYPE,
     KNOWLEDGE_BASE_SLOT_NAMES,
+    SILENCE_TIMEOUT_SLOT,
     SLOT_MAPPINGS,
     SlotMappingType,
 )
@@ -134,6 +136,22 @@ ALL_DOMAIN_KEYS = [
 
 PREV_PREFIX = "prev_"
 
+MERGE_FUNC_MAPPING: Dict[Text, Callable[..., Any]] = {
+    KEY_ACTIONS: rasa.shared.utils.common.merge_lists_of_dicts,
+    KEY_RESPONSES: rasa.shared.utils.common.merge_dicts,
+    KEY_SLOTS: rasa.shared.utils.common.merge_dicts,
+    KEY_INTENTS: rasa.shared.utils.common.merge_lists_of_dicts,
+    KEY_ENTITIES: rasa.shared.utils.common.merge_lists_of_dicts,
+    KEY_E2E_ACTIONS: rasa.shared.utils.common.merge_lists,
+    KEY_FORMS: rasa.shared.utils.common.merge_dicts,
+}
+
+DICT_DATA_KEYS = [
+    key
+    for key, value in MERGE_FUNC_MAPPING.items()
+    if value == rasa.shared.utils.common.merge_dicts
+]
+
 # State is a dictionary with keys (USER, PREVIOUS_ACTION, SLOTS, ACTIVE_LOOP)
 # representing the origin of a SubState;
 # the values are SubStates, that contain the information needed for featurization
@@ -290,6 +308,11 @@ class Domain:
         responses = data.get(KEY_RESPONSES, {})
 
         domain_slots = data.get(KEY_SLOTS, {})
+        for slot_name, slot in domain_slots.items():
+            if slot_name == SILENCE_TIMEOUT_SLOT:
+                slot["initial_value"] = (
+                    AvailableEndpoints.get_instance().interaction_handling.global_silence_timeout
+                )
         slots = cls.collect_slots(domain_slots)
         domain_actions = data.get(KEY_ACTIONS, [])
         actions = cls._collect_action_names(domain_actions)
@@ -466,17 +489,7 @@ class Domain:
 
         duplicates: Dict[Text, List[Text]] = {}
 
-        merge_func_mappings: Dict[Text, Callable[..., Any]] = {
-            KEY_INTENTS: rasa.shared.utils.common.merge_lists_of_dicts,
-            KEY_ENTITIES: rasa.shared.utils.common.merge_lists_of_dicts,
-            KEY_ACTIONS: rasa.shared.utils.common.merge_lists_of_dicts,
-            KEY_E2E_ACTIONS: rasa.shared.utils.common.merge_lists,
-            KEY_FORMS: rasa.shared.utils.common.merge_dicts,
-            KEY_RESPONSES: rasa.shared.utils.common.merge_dicts,
-            KEY_SLOTS: rasa.shared.utils.common.merge_dicts,
-        }
-
-        for key, merge_func in merge_func_mappings.items():
+        for key, merge_func in MERGE_FUNC_MAPPING.items():
             duplicates[key] = rasa.shared.utils.common.extract_duplicates(
                 combined.get(key, []), domain_dict.get(key, [])
             )
@@ -494,6 +507,74 @@ class Domain:
 
         return combined
 
+    def partial_merge(self, other: Domain) -> Domain:
+        """
+        Returns a new Domain with intersection-based merging:
+          - For each domain section only overwrite items that already exist in self.
+          - Brand-new items in `other` are ignored.
+
+        Args:
+            other: The domain to merge with.
+
+        Returns:
+            A new Domain object with the merged content.
+        """
+        updated_self = copy.deepcopy(self.as_dict())
+        other_dict = other.as_dict()
+
+        keys_to_merge = MERGE_FUNC_MAPPING.keys()
+        for key in keys_to_merge:
+            if key in DICT_DATA_KEYS:
+                # Merge dictionaries
+                self_val = updated_self.get(key, {})
+                other_val = other_dict.get(key, {})
+                updated_self[key] = rasa.shared.utils.common.partial_merge_dict(
+                    self_val, other_val
+                )
+            else:
+                # Merge lists
+                self_val = updated_self.get(key, [])
+                other_val = other_dict.get(key, [])
+                is_same_item_fn = SAME_ITEM_FUNCTIONS.get(key, default_is_same_item)
+                updated_self[key] = rasa.shared.utils.common.partial_merge_list(
+                    self_val, other_val, is_same_item_fn
+                )
+
+        return Domain.from_dict(updated_self)
+
+    def difference(self, other: Domain) -> Domain:
+        """
+        Returns a new Domain containing items in `self` that are NOT in `other`,
+        using simple equality checks for dict/list items.
+
+        Args:
+            other: The domain to compare with.
+
+        Returns:
+            A new Domain object with the difference content.
+        """
+        self_dict = self.as_dict()
+        other_dict = other.as_dict()
+
+        difference_dict = {}
+        for key in MERGE_FUNC_MAPPING.keys():
+            is_dict = key in DICT_DATA_KEYS
+            self_val = self_dict.get(key, {} if is_dict else [])
+            other_val = other_dict.get(key, {} if is_dict else [])
+
+            if is_dict and isinstance(self_val, dict) and isinstance(other_val, dict):
+                difference_dict[key] = {
+                    k: v
+                    for k, v in self_val.items()
+                    if k not in other_val or v != other_val[k]
+                }
+            else:
+                difference_dict[key] = [
+                    item for item in self_val if item not in other_val
+                ]  # type: ignore[assignment]
+
+        return Domain.from_dict(difference_dict)
+
     def _preprocess_domain_dict(
         self,
         data: Dict,
@@ -2120,6 +2201,11 @@ class Domain:
         """Remove all builtin slots from the domain."""
         self.slots = [slot for slot in self.slots if not slot.is_builtin]
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Domain):
+            return self.as_dict() == other.as_dict()
+        return False
+
 
 def warn_about_duplicates_found_during_domain_merging(
     duplicates: Dict[Text, List[Text]],
@@ -2178,3 +2264,78 @@ def _validate_forms(forms: Union[Dict, List]) -> None:
                 f"the keyword `{REQUIRED_SLOTS_KEY}` is required. "
                 f"Please see {DOCS_URL_FORMS} for more information."
             )
+
+
+def is_same_entity(e1: Any, e2: Any) -> bool:
+    """Check if two entities are the 'same' (string or dict).
+
+    Args:
+        e1: First entity to compare.
+        e2: Second entity to compare.
+
+    Returns:
+        True if the entities are the same, False otherwise.
+    """
+    if isinstance(e1, str) and isinstance(e2, str):
+        return e1 == e2
+
+    if isinstance(e1, dict) and isinstance(e2, dict):
+        return (
+            e1.get(ENTITY_ATTRIBUTE_TYPE) == e2.get(ENTITY_ATTRIBUTE_TYPE)
+            and e1.get(ENTITY_ATTRIBUTE_ROLE) == e2.get(ENTITY_ATTRIBUTE_ROLE)
+            and e1.get(ENTITY_ATTRIBUTE_GROUP) == e2.get(ENTITY_ATTRIBUTE_GROUP)
+        )
+
+    return False
+
+
+def is_same_intent(i1: Any, i2: Any) -> bool:
+    """Check if two intents are the 'same' (string or dict).
+
+    Args:
+        i1: First intent to compare.
+        i2: Second intent to compare.
+
+    Returns:
+        True if the intents are the same, False otherwise.
+    """
+    if isinstance(i1, str) and isinstance(i2, str):
+        return i1 == i2
+
+    if isinstance(i1, dict) and isinstance(i2, dict):
+        key1, key2 = next(iter(i1.keys())), next(iter((i2.keys())))
+        return key1 == key2
+
+    return False
+
+
+def is_same_action(a1: Any, a2: Any) -> bool:
+    """Check if two actions are the 'same' (string or dict).
+
+    Args:
+        a1: First action to compare.
+        a2: Second action to compare.
+
+    Returns:
+        True if the actions are the same, False otherwise.
+    """
+    if isinstance(a1, str) and isinstance(a2, str):
+        return a1 == a2
+
+    if isinstance(a1, dict) and isinstance(a2, dict):
+        key1, key2 = next(iter((a1.keys()))), next(iter((a2.keys())))
+        return key1 == key2
+
+    return False
+
+
+def default_is_same_item(a: Any, b: Any) -> bool:
+    """Fallback exact equality check if a key doesn't need special handling."""
+    return a == b
+
+
+SAME_ITEM_FUNCTIONS: Dict[Text, Callable[[Any, Any], bool]] = {
+    KEY_ENTITIES: is_same_entity,
+    KEY_INTENTS: is_same_intent,
+    KEY_ACTIONS: is_same_action,
+}

rasa/shared/core/events.py

@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import abc
 import copy
 import json
@@ -6,7 +8,7 @@ import re
 import time
 import uuid
 from abc import ABC
-from datetime import datetime
+from datetime import datetime, timezone
 from typing import (
     TYPE_CHECKING,
     Any,
@@ -107,6 +109,8 @@ if TYPE_CHECKING:
 logger = logging.getLogger(__name__)
 structlogger = structlog.get_logger()
 
+INVALID_DATETIME_ERROR_MESSAGE = "`anonymized_at` must be a datetime object."
+
 
 def deserialise_events(serialized_events: List[Dict[Text, Any]]) -> List["Event"]:
     """Convert a list of dictionaries to a list of corresponding events.
@@ -122,9 +126,7 @@ def deserialise_events(serialized_events: List[Dict[Text, Any]]) -> List["Event"
             if event:
                 deserialised.append(event)
             else:
-                structlogger.warning(
-                    "event.deserialization.failed", rasa_event=copy.deepcopy(event)
-                )
+                structlogger.warning("event.deserialization.failed")
 
     return deserialised
 
@@ -451,6 +453,7 @@ class UserUttered(Event):
         message_id: Optional[Text] = None,
         metadata: Optional[Dict] = None,
         use_text_for_featurization: Optional[bool] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event for incoming user message.
 
@@ -465,6 +468,7 @@ class UserUttered(Event):
             message_id: Unique ID for message.
             use_text_for_featurization: `True` if the message's text was used to predict
                 next action. `False` if the message's intent was used.
+            anonymized_at: When the event was anonymized in the tracker store.
 
         """
         self.text = text
@@ -498,6 +502,27 @@ class UserUttered(Event):
         if parse_data:
             self.parse_data.update(**parse_data)
 
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
+
+    @property
+    def anonymized_at(self) -> Optional[datetime]:
+        """Returns the time when the event was anonymized in the tracker store.
+
+        If the event was not anonymized, it returns None.
+        """
+        return self._anonymized_at
+
+    @anonymized_at.setter
+    def anonymized_at(self, value: Optional[datetime]) -> None:
+        """Sets the time when the event was anonymized in the tracker store."""
+        if value is not None and not isinstance(value, datetime):
+            raise ValueError(INVALID_DATETIME_ERROR_MESSAGE)
+        self._anonymized_at = value
+
     @staticmethod
     def _from_parse_data(
         text: Text,
@@ -506,6 +531,7 @@ class UserUttered(Event):
         input_channel: Optional[Text] = None,
         message_id: Optional[Text] = None,
         metadata: Optional[Dict] = None,
+        anonymized_at: Optional[float] = None,
     ) -> "UserUttered":
         return UserUttered(
             text,
@@ -516,6 +542,7 @@ class UserUttered(Event):
             input_channel,
             message_id,
             metadata,
+            anonymized_at,
         )
 
     def __hash__(self) -> int:
@@ -614,6 +641,9 @@ class UserUttered(Event):
                 "input_channel": getattr(self, "input_channel", None),
                 "message_id": getattr(self, "message_id", None),
                 "metadata": self.metadata,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return _dict
@@ -673,6 +703,7 @@ class UserUttered(Event):
                     parameters.get("input_channel"),
                     parameters.get("message_id"),
                     parameters.get("metadata"),
+                    parameters.get("anonymized_at"),
                 )
             ]
         except KeyError as e:
@@ -900,6 +931,7 @@ class BotUttered(SkipEventInMDStoryMixin):
         data: Optional[Dict] = None,
         metadata: Optional[Dict[Text, Any]] = None,
         timestamp: Optional[float] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event for a bot response.
 
@@ -908,11 +940,32 @@ class BotUttered(SkipEventInMDStoryMixin):
             data: Additional data for more complex utterances (e.g. buttons).
             timestamp: When the event was created.
             metadata: Additional event metadata.
+            anonymized_at: When the event was anonymized in the tracker store.
         """
         self.text = text
         self.data = data or {}
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
         super().__init__(timestamp, metadata)
 
+    @property
+    def anonymized_at(self) -> Optional[datetime]:
+        """Returns the time when the event was anonymized in the tracker store.
+
+        If the event was not anonymized, it returns None.
+        """
+        return self._anonymized_at
+
+    @anonymized_at.setter
+    def anonymized_at(self, value: Optional[datetime]) -> None:
+        """Sets the time when the event was anonymized in the tracker store."""
+        if value is not None and not isinstance(value, datetime):
+            raise ValueError(INVALID_DATETIME_ERROR_MESSAGE)
+        self._anonymized_at = value
+
     def __members(self) -> Tuple[Optional[Text], Text, Text]:
         data_no_nones = {k: v for k, v in self.data.items() if v is not None}
         meta_no_nones = {k: v for k, v in self.metadata.items() if v is not None}
@@ -999,7 +1052,16 @@ class BotUttered(SkipEventInMDStoryMixin):
     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update({"text": self.text, "data": self.data, "metadata": self.metadata})
+        d.update(
+            {
+                "text": self.text,
+                "data": self.data,
+                "metadata": self.metadata,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
+            }
+        )
         return d
 
     @classmethod
@@ -1010,6 +1072,7 @@ class BotUttered(SkipEventInMDStoryMixin):
                 parameters.get("data"),
                 parameters.get("metadata"),
                 parameters.get("timestamp"),
+                parameters.get("anonymized_at"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse bot uttered event. {e}")
@@ -1034,6 +1097,7 @@ class SlotSet(Event):
         timestamp: Optional[float] = None,
         metadata: Optional[Dict[Text, Any]] = None,
         filled_by: Optional[str] = None,
+        anonymized_at: Optional[float] = None,
     ) -> None:
         """Creates event to set slot.
 
@@ -1046,8 +1110,28 @@ class SlotSet(Event):
         self.key = key
         self.value = value
         self._filled_by = filled_by
+        self._anonymized_at: Optional[datetime] = (
+            datetime.fromtimestamp(anonymized_at, tz=timezone.utc)
+            if anonymized_at is not None
+            else None
+        )
         super().__init__(timestamp, metadata)
 
+    @property
+    def anonymized_at(self) -> Optional[datetime]:
+        """Returns the time when the event was anonymized in the tracker store.
+
+        If the event was not anonymized, it returns None.
+        """
+        return self._anonymized_at
+
+    @anonymized_at.setter
+    def anonymized_at(self, value: Optional[datetime]) -> None:
+        """Sets the time when the event was anonymized in the tracker store."""
+        if value is not None and not isinstance(value, datetime):
+            raise ValueError(INVALID_DATETIME_ERROR_MESSAGE)
+        self._anonymized_at = value
+
     def __repr__(self) -> Text:
         """Returns text representation of event."""
         return f"SlotSet(key: {self.key}, value: {self.value})"
@@ -1092,7 +1176,16 @@ class SlotSet(Event):
     def as_dict(self) -> Dict[Text, Any]:
         """Returns serialized event."""
         d = super().as_dict()
-        d.update({"name": self.key, "value": self.value, "filled_by": self.filled_by})
+        d.update(
+            {
+                "name": self.key,
+                "value": self.value,
+                "filled_by": self.filled_by,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
+            }
+        )
         return d
 
     @classmethod
@@ -1104,6 +1197,7 @@ class SlotSet(Event):
                 parameters.get("timestamp"),
                 parameters.get("metadata"),
                 filled_by=parameters.get("filled_by"),
+                anonymized_at=parameters.get("anonymized_at"),
             )
         except KeyError as e:
             raise ValueError(f"Failed to parse set slot event. {e}")

rasa/shared/core/flows/flow.py

@@ -53,6 +53,8 @@ from rasa.shared.core.slots import Slot
 
 structlogger = structlog.get_logger()
 
+DEFAULT_RUN_PATTERN_COMPLETED = True
+
 
 class FlowLanguageTranslation(BaseModel):
     """Represents the translation of the flow properties in a specific language."""
@@ -61,8 +63,15 @@ class FlowLanguageTranslation(BaseModel):
     """The human-readable name of the flow."""
 
     class Config:
+        """Config for the FlowLanguageTranslation class."""
+
         extra = "ignore"
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, FlowLanguageTranslation):
+            return self.name == other.name
+        return False
+
 
 @dataclass
 class Flow:
@@ -90,8 +99,25 @@ class Flow:
     """The path to the file where the flow is stored."""
     persisted_slots: List[str] = field(default_factory=list)
     """The list of slots that should be persisted after the flow ends."""
-    run_pattern_completed: bool = True
+    run_pattern_completed: bool = DEFAULT_RUN_PATTERN_COMPLETED
     """Whether the pattern_completed flow should be run after the flow ends."""
+    metadata: Dict[Text, Any] = field(default_factory=dict)
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, Flow):
+            return (
+                self.id == other.id
+                and self.custom_name == other.custom_name
+                and self.description == other.description
+                and self.translation == other.translation
+                and self.guard_condition == other.guard_condition
+                and self.step_sequence == other.step_sequence
+                and self.nlu_triggers == other.nlu_triggers
+                and self.always_include_in_prompt == other.always_include_in_prompt
+                and self.persisted_slots == other.persisted_slots
+                and self.run_pattern_completed == other.run_pattern_completed
+            )
+        return False
 
     @staticmethod
     def from_json(
@@ -130,7 +156,9 @@ class Flow:
             # data. When the model is trained, take the provided file_path.
             file_path=data.get(KEY_FILE_PATH) if KEY_FILE_PATH in data else file_path,
             persisted_slots=data.get(KEY_PERSISTED_SLOTS, []),
-            run_pattern_completed=data.get(KEY_RUN_PATTERN_COMPLETED, True),
+            run_pattern_completed=data.get(
+                KEY_RUN_PATTERN_COMPLETED, DEFAULT_RUN_PATTERN_COMPLETED
+            ),
             translation=extract_translations(
                 translation_data=data.get(KEY_TRANSLATION, {})
             ),
@@ -209,7 +237,7 @@ class Flow:
         if self.persisted_slots:
             data[KEY_PERSISTED_SLOTS] = self.persisted_slots
         if self.run_pattern_completed is not None:
-            data["run_pattern_completed"] = self.run_pattern_completed
+            data[KEY_RUN_PATTERN_COMPLETED] = self.run_pattern_completed
         if self.translation:
             data[KEY_TRANSLATION] = {
                 language_code: translation.dict()
@@ -232,9 +260,9 @@ class Flow:
         return translation.name if translation else None
 
     def readable_name(self, language: Optional[Language] = None) -> str:
-        """
-        Returns the flow's name in the specified language if available; otherwise
-        falls back to the flow's name, and finally the flow's ID.
+        """Returns the flow's name in the specified language if available.
+
+        Otherwise falls back to the flow's name, and finally the flow's ID.
 
         Args:
             language: Preferred language code.
@@ -378,8 +406,7 @@ class Flow:
             structlogger.error(
                 "command_generator.validate_flow_starting_conditions.error",
                 predicate=self.guard_condition,
-                context=context,
-                slots=slots,
+                flow_id=self.id,
                 error=str(e),
             )
             return False

rasa/shared/core/flows/flow_step.py

@@ -52,7 +52,13 @@ def step_from_json(flow_id: Text, data: Dict[Text, Any]) -> FlowStep:
         return SetSlotsFlowStep.from_json(flow_id, data)
     if "noop" in data:
         return NoOperationFlowStep.from_json(flow_id, data)
-    raise RasaException(f"Failed to parse step from json. Unknown type for {data}.")
+
+    required_properties = ["action", "collect", "link", "call", "set_slots", "noop"]
+    raise RasaException(
+        f"Failed to parse step from json. Unknown type for {data}. "
+        f"At lest one of the following properties is required: "
+        f"{', '.join(required_properties)}"
+    )
 
 
 @dataclass
@@ -100,7 +106,9 @@ class FlowStep:
         """Most steps allow linking to the next step. But some don't."""
         return True
 
-    def as_json(self) -> Dict[Text, Any]:
+    def as_json(
+        self, step_properties: Optional[Dict[Text, Any]] = None
+    ) -> Dict[Text, Any]:
         """Serialize the FlowStep object.
 
         Returns:
@@ -108,10 +116,13 @@ class FlowStep:
         """
         data: Dict[Text, Any] = {"id": self.id}
 
-        if dumped_next := self.next.as_json():
-            data["next"] = dumped_next
+        if step_properties:
+            data.update(step_properties)
+
         if self.description:
             data["description"] = self.description
+        if dumped_next := self.next.as_json():
+            data["next"] = dumped_next
         if self.metadata:
             data["metadata"] = self.metadata
         return data
@@ -143,6 +154,17 @@ class FlowStep:
         """Return all the utterances used in this step."""
         return set()
 
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, FlowStep):
+            return False
+
+        return (
+            self.idx == other.idx
+            and self.description == other.description
+            and self.next == other.next
+            and self.flow_id == other.flow_id
+        )
+
 
 @dataclass
 class FlowStepWithFlowReference:

rasa/shared/core/flows/flow_step_links.py

@@ -74,6 +74,11 @@ class FlowStepLinks:
             depth = max(depth, link.depth_in_tree())
         return depth
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, FlowStepLinks):
+            return self.links == other.links
+        return False
+
 
 class FlowStepLink:
     """A flow step link that links two steps in a single flow."""
@@ -193,6 +198,11 @@ class BranchingFlowStepLink(FlowStepLink):
             return depth + 1
         return 1
 
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, BranchingFlowStepLink):
+            return self.target_reference == other.target_reference
+        return False
+
 
 @dataclass
 class IfFlowStepLink(BranchingFlowStepLink):
@@ -324,3 +334,8 @@ class StaticFlowStepLink(FlowStepLink):
     def depth_in_tree(self) -> int:
         """Returns the depth in the tree."""
         return 0
+
+    def __eq__(self, other: object) -> bool:
+        if isinstance(other, StaticFlowStepLink):
+            return self.target_step_id == other.target_step_id
+        return False

rasa/shared/core/flows/flow_step_sequence.py

@@ -70,3 +70,9 @@ class FlowStepSequence:
     def empty(cls) -> FlowStepSequence:
         """Create an empty FlowStepSequence object."""
         return cls(child_steps=[])
+
+    def __eq__(self, other: object) -> bool:
+        return (
+            isinstance(other, FlowStepSequence)
+            and self.child_steps == other.child_steps
+        )

rasa/shared/core/flows/flows_yaml_schema.json

@@ -244,6 +244,9 @@
                                         }
                                     }
                                 }
+                            },
+                            "silence_timeout": {
+                                "type": "number"
                             }
                         }
                     }