rasa-pro 3.13.0.dev20250612__py3-none-any.whl → 3.13.0rc1__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,
 )
@@ -306,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)

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,
@@ -124,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
 
@@ -453,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.
 
@@ -467,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
@@ -500,7 +502,11 @@ class UserUttered(Event):
         if parse_data:
             self.parse_data.update(**parse_data)
 
-        self._anonymized_at: Optional[datetime] = None
+        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]:
@@ -525,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,
@@ -535,6 +542,7 @@ class UserUttered(Event):
             input_channel,
             message_id,
             metadata,
+            anonymized_at,
         )
 
     def __hash__(self) -> int:
@@ -633,7 +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,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return _dict
@@ -693,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:
@@ -920,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.
 
@@ -928,10 +940,15 @@ 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] = None
+        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
@@ -1040,7 +1057,9 @@ class BotUttered(SkipEventInMDStoryMixin):
                 "text": self.text,
                 "data": self.data,
                 "metadata": self.metadata,
-                "anonymized_at": self.anonymized_at,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return d
@@ -1053,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}")
@@ -1077,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.
 
@@ -1089,7 +1110,11 @@ class SlotSet(Event):
         self.key = key
         self.value = value
         self._filled_by = filled_by
-        self._anonymized_at: Optional[datetime] = None
+        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
@@ -1156,7 +1181,9 @@ class SlotSet(Event):
                 "name": self.key,
                 "value": self.value,
                 "filled_by": self.filled_by,
-                "anonymized_at": self.anonymized_at,
+                "anonymized_at": self.anonymized_at.timestamp()
+                if self.anonymized_at
+                else None,
             }
         )
         return d
@@ -1170,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/constants.py

@@ -9,3 +9,5 @@ KEY_FILE_PATH = "file_path"
 KEY_PERSISTED_SLOTS = "persisted_slots"
 KEY_RUN_PATTERN_COMPLETED = "run_pattern_completed"
 KEY_TRANSLATION = "translation"
+KEY_CALLED_FLOW = "called_flow"
+KEY_LINKED_FLOW = "linked_flow"

rasa/shared/core/flows/flow.py

@@ -4,7 +4,7 @@ import copy
 from dataclasses import dataclass, field
 from functools import cached_property
 from pathlib import Path
-from typing import Any, Dict, List, Optional, Set, Text, Union
+from typing import Any, Dict, List, Optional, Set, Text, Tuple, Union
 
 import structlog
 from pydantic import BaseModel
@@ -15,10 +15,12 @@ from rasa.engine.language import Language
 from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
 from rasa.shared.core.flows.constants import (
     KEY_ALWAYS_INCLUDE_IN_PROMPT,
+    KEY_CALLED_FLOW,
     KEY_DESCRIPTION,
     KEY_FILE_PATH,
     KEY_ID,
     KEY_IF,
+    KEY_LINKED_FLOW,
     KEY_NAME,
     KEY_NLU_TRIGGER,
     KEY_PERSISTED_SLOTS,
@@ -41,6 +43,7 @@ from rasa.shared.core.flows.steps import (
     CallFlowStep,
     CollectInformationFlowStep,
     EndFlowStep,
+    LinkFlowStep,
     StartFlowStep,
 )
 from rasa.shared.core.flows.steps.constants import (
@@ -63,7 +66,7 @@ class FlowLanguageTranslation(BaseModel):
     """The human-readable name of the flow."""
 
     class Config:
-        """Config for the FlowLanguageTranslation class."""
+        """Configuration for the FlowLanguageTranslation model."""
 
         extra = "ignore"
 
@@ -262,7 +265,7 @@ class Flow:
     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.
+        Otherwise, falls back to the flow's name, and finally the flow's ID.
 
         Args:
             language: Preferred language code.
@@ -406,8 +409,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
@@ -516,6 +518,9 @@ class Flow:
         current_path: FlowPath,
         all_paths: FlowPathsList,
         visited_step_ids: Set[str],
+        call_stack: Optional[
+            List[Tuple[Optional[FlowStep], Optional[Flow], str]]
+        ] = None,
     ) -> None:
         """Processes the flow steps recursively.
 
@@ -524,19 +529,25 @@ class Flow:
             current_path: The current path being constructed.
             all_paths: The list where completed paths are added.
             visited_step_ids: A set of steps that have been visited to avoid cycles.
+            call_stack: Tuple list of (flow, path, flow_type) to track path when \
+                calling flows through call and link steps.
 
         Returns:
             None: This function modifies all_paths in place by appending new paths
             as they are found.
         """
+        if call_stack is None:
+            call_stack = []
+
         # Check if the step is relevant for testable_paths extraction.
-        # We only create new path nodes for ActionFlowStep, CallFlowStep and
-        # CollectInformationFlowStep because these are externally visible
-        # changes in the assistant's behaviour (trackable in the e2e tests).
+        # We only create new path nodes for CollectInformationFlowStep,
+        # ActionFlowStep, CallFlowStep and LinkFlowStep,
+        # because these are externally visible changes
+        # in the assistant's behaviour (trackable in the e2e tests).
         # For other flow steps, we only follow their links.
-        # We decided to ignore calls to other flows in our coverage analysis.
         should_add_node = isinstance(
-            current_step, (CollectInformationFlowStep, ActionFlowStep, CallFlowStep)
+            current_step,
+            (CollectInformationFlowStep, ActionFlowStep, CallFlowStep, LinkFlowStep),
         )
         if should_add_node:
             # Add current step to the current path that is being constructed.
@@ -548,10 +559,45 @@ class Flow:
                 )
             )
 
+        # Check if the current step has already been visited or
+        # if the end of the path has been reached.
+        # If so, and we’re not within a called flow, we terminate the current path.
+        # This also applies for when we're inside a linked flow and reach its end.
+        # If we're inside a called flow and reach its end,
+        # continue with the next steps in its parent flow.
         if current_step.id in visited_step_ids or self.is_end_of_path(current_step):
-            # Found a cycle, or reached an end step, do not proceed further.
-            all_paths.paths.append(copy.deepcopy(current_path))
-            # Remove the last node from the path if it was added.
+            # Shallow copy is sufficient, since we only pop from the list and
+            # don't mutate the objects inside the tuples.
+            # The state of FlowStep and Flow does not change during the traversal.
+            call_stack_copy = call_stack.copy()
+            # parent_flow_type could be any of: None, i.e. main flow,
+            # KEY_CALLED_FLOW(=called_flow) or KEY_LINKED_FLOW(=linked_flow)
+            parent_step, parent_flow, parent_flow_type = (
+                call_stack_copy.pop() if call_stack_copy else (None, None, None)
+            )
+
+            # Check if within a called flow.
+            # If within linked flow, stop the traversal as this takes precedence.
+            if parent_step and parent_flow_type == KEY_CALLED_FLOW:
+                # As we have reached the END step of a called flow, we need to
+                # continue with the next links of the parent step.
+                if parent_flow is not None:
+                    for link in parent_step.next.links:
+                        parent_flow._handle_link(
+                            current_path,
+                            all_paths,
+                            visited_step_ids,
+                            link,
+                            call_stack_copy,
+                        )
+
+            else:
+                # Found a cycle, or reached an end step, do not proceed further.
+                all_paths.paths.append(copy.deepcopy(current_path))
+
+            # Backtrack: remove the last node after reaching a terminal step.
+            # Ensures the path is correctly backtracked, after a path ends or
+            # a cycle is detected.
             if should_add_node:
                 current_path.nodes.pop()
             return
@@ -559,6 +605,62 @@ class Flow:
         # Mark current step as visited in this path.
         visited_step_ids.add(current_step.id)
 
+        # If the current step is a call step, we need to resolve the call
+        # and continue with the steps of the called flow.
+        if isinstance(current_step, CallFlowStep):
+            # Get the steps of the called flow and continue with them.
+            called_flow = current_step.called_flow_reference
+            if called_flow and (
+                start_step_in_called_flow := called_flow.first_step_in_flow()
+            ):
+                call_stack.append((current_step, self, KEY_CALLED_FLOW))
+                called_flow._go_over_steps(
+                    start_step_in_called_flow,
+                    current_path,
+                    all_paths,
+                    visited_step_ids,
+                    call_stack,
+                )
+
+                # After processing the steps of the called (child) flow,
+                # remove them from the visited steps
+                # to allow the calling (parent) flow to revisit them later.
+                visited_step_ids.remove(current_step.id)
+                call_stack.pop()
+
+                # Backtrack: remove the last node
+                # after returning from a called (child) flow.
+                # Ensures the parent flow can continue exploring other branches.
+                if should_add_node:
+                    current_path.nodes.pop()
+            return
+
+        # If the current step is a LinkFlowStep, step into the linked flow,
+        # process its links, and do not return from that flow anymore.
+        if isinstance(current_step, LinkFlowStep):
+            # Get the steps of the linked flow and continue with them.
+            linked_flow = current_step.linked_flow_reference
+            if linked_flow and (
+                start_step_in_linked_flow := linked_flow.first_step_in_flow()
+            ):
+                call_stack.append((current_step, self, KEY_LINKED_FLOW))
+                linked_flow._go_over_steps(
+                    start_step_in_linked_flow,
+                    current_path,
+                    all_paths,
+                    visited_step_ids,
+                    call_stack,
+                )
+                visited_step_ids.remove(current_step.id)
+                call_stack.pop()
+
+                # Backtrack: remove the last node
+                # after returning from a linked (child) flow.
+                # Ensures the parent can continue after the linked flow is processed.
+                if should_add_node:
+                    current_path.nodes.pop()
+            return
+
         # Iterate over all links of the current step.
         for link in current_step.next.links:
             self._handle_link(
@@ -566,12 +668,15 @@ class Flow:
                 all_paths,
                 visited_step_ids,
                 link,
+                call_stack,
             )
 
         # Backtrack the current step and remove it from the path.
         visited_step_ids.remove(current_step.id)
 
-        # Remove the last node from the path if it was added.
+        # Backtrack: remove the last node
+        # after processing all links of the current step.
+        # Ensures the next recursion can start once all links are explored.
         if should_add_node:
             current_path.nodes.pop()
 
@@ -581,6 +686,9 @@ class Flow:
         all_paths: FlowPathsList,
         visited_step_ids: Set[str],
         link: FlowStepLink,
+        call_stack: Optional[
+            List[Tuple[Optional[FlowStep], Optional[Flow], str]]
+        ] = None,
     ) -> None:
         """Handles the next step in a flow.
 
@@ -589,6 +697,8 @@ class Flow:
             all_paths: The list where completed paths are added.
             visited_step_ids: A set of steps that have been visited to avoid cycles.
             link: The link to be followed.
+            call_stack: Tuple list of (flow, path, flow_type) to track path when \
+                calling flows through call and link steps..
 
         Returns:
             None: This function modifies all_paths in place by appending new paths
@@ -603,6 +713,7 @@ class Flow:
                     current_path,
                     all_paths,
                     visited_step_ids,
+                    call_stack,
                 )
                 return
         # IfFlowStepLink and ElseFlowStepLink are conditional links.
@@ -616,6 +727,7 @@ class Flow:
                         current_path,
                         all_paths,
                         visited_step_ids,
+                        call_stack,
                     )
                 return
             else:
@@ -626,6 +738,7 @@ class Flow:
                         current_path,
                         all_paths,
                         visited_step_ids,
+                        call_stack,
                     )
                     return
 

rasa/shared/core/flows/flows_list.py

@@ -36,6 +36,7 @@ class FlowsList:
     def __post_init__(self) -> None:
         """Initializes the FlowsList object."""
         self._resolve_called_flows()
+        self._resolve_linked_flows()
 
     def __iter__(self) -> Generator[Flow, None, None]:
         """Iterates over the flows."""
@@ -103,7 +104,10 @@ class FlowsList:
         )
 
     def _resolve_called_flows(self) -> None:
-        """Resolves the called flows."""
+        """Resolves the called flows.
+
+        `Resolving` here means connecting the step to the actual `Flow` object.
+        """
         from rasa.shared.core.flows.steps import CallFlowStep
 
         for flow in self.underlying_flows:
@@ -112,6 +116,19 @@ class FlowsList:
                     # only resolve the reference, if it isn't already resolved
                     step.called_flow_reference = self.flow_by_id(step.call)
 
+    def _resolve_linked_flows(self) -> None:
+        """Resolves the linked flows.
+
+        `Resolving` here means connecting the step to the actual `Flow` object.
+        """
+        from rasa.shared.core.flows.steps import LinkFlowStep
+
+        for flow in self.underlying_flows:
+            for step in flow.steps:
+                if isinstance(step, LinkFlowStep) and not step.linked_flow_reference:
+                    # only resolve the reference, if it isn't already resolved
+                    step.linked_flow_reference = self.flow_by_id(step.link)
+
     def as_json_list(self) -> List[Dict[Text, Any]]:
         """Serialize the FlowsList object to list format and not to the original dict.
 

rasa/shared/core/flows/flows_yaml_schema.json

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

rasa/shared/core/flows/steps/collect.py

@@ -1,16 +1,23 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, List, Set, Text
+from typing import Any, Dict, List, Optional, Set, Text, Union
+
+import structlog
 
 from rasa.shared.constants import ACTION_ASK_PREFIX, UTTER_ASK_PREFIX
 from rasa.shared.core.flows.flow_step import FlowStep
 from rasa.shared.core.slots import SlotRejection
+from rasa.shared.exceptions import RasaException
 
 DEFAULT_ASK_BEFORE_FILLING = False
 DEFAULT_RESET_AFTER_FLOW_ENDS = True
 DEFAULT_FORCE_SLOT_FILLING = False
 
+logger = structlog.get_logger(__name__)
+
+SilenceTimeoutInstructionType = Union[int, float, Dict[str, Any]]
+
 
 @dataclass
 class CollectInformationFlowStep(FlowStep):
@@ -30,6 +37,8 @@ class CollectInformationFlowStep(FlowStep):
     """Whether to reset the slot value at the end of the flow."""
     force_slot_filling: bool = False
     """Whether to keep only the SetSlot command for the collected slot."""
+    silence_timeout: Optional[float] = None
+    """The silence timeout for the collect information step."""
 
     @classmethod
     def from_json(
@@ -44,6 +53,11 @@ class CollectInformationFlowStep(FlowStep):
         Returns:
             A CollectInformationFlowStep object
         """
+
+        silence_timeout = cls._deserialise_silence_timeout(
+            data.get("silence_timeout", None)
+        )
+
         base = super().from_json(flow_id, data)
         return CollectInformationFlowStep(
             collect=data["collect"],
@@ -58,14 +72,40 @@ class CollectInformationFlowStep(FlowStep):
                 for rejection in data.get("rejections", [])
             ],
             force_slot_filling=data.get("force_slot_filling", False),
+            silence_timeout=silence_timeout,
             **base.__dict__,
         )
 
+    @staticmethod
+    def _deserialise_silence_timeout(
+        silence_timeout_json: Optional[SilenceTimeoutInstructionType],
+    ) -> Optional[float]:
+        """Deserialize silence timeout from JSON."""
+        if not silence_timeout_json:
+            return None
+
+        if not isinstance(silence_timeout_json, (int, float)):
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout_json}. "
+                "If defined at collect step, silence timeout must be a number."
+            )
+
+        silence_timeout = silence_timeout_json
+
+        if silence_timeout and silence_timeout < 0:
+            raise RasaException(
+                f"Invalid silence timeout value: {silence_timeout}. "
+                "Silence timeout must be a non-negative number."
+            )
+        return silence_timeout
+
     @staticmethod
     def _default_utter(collect: str) -> str:
         return f"{UTTER_ASK_PREFIX}{collect}"
 
-    def as_json(self) -> Dict[str, Any]:  # type: ignore[override]
+    def as_json(
+        self, step_properties: Optional[Dict[Text, Any]] = None
+    ) -> Dict[str, Any]:
         """Serialize the CollectInformationFlowStep object.
 
         Returns:
@@ -78,6 +118,9 @@ class CollectInformationFlowStep(FlowStep):
         data["reset_after_flow_ends"] = self.reset_after_flow_ends
         data["rejections"] = [rejection.as_dict() for rejection in self.rejections]
         data["force_slot_filling"] = self.force_slot_filling
+        if self.silence_timeout:
+            data["silence_timeout"] = self.silence_timeout
+
         return super().as_json(step_properties=data)
 
     @property
@@ -100,6 +143,7 @@ class CollectInformationFlowStep(FlowStep):
                 and self.ask_before_filling == other.ask_before_filling
                 and self.reset_after_flow_ends == other.reset_after_flow_ends
                 and self.force_slot_filling == other.force_slot_filling
+                and self.silence_timeout == other.silence_timeout
                 and super().__eq__(other)
             )
         return False

rasa/shared/core/flows/steps/link.py

@@ -1,9 +1,12 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Any, Dict, Text
+from typing import TYPE_CHECKING, Any, Dict, Text
 
-from rasa.shared.core.flows.flow_step import FlowStep
+from rasa.shared.core.flows.flow_step import FlowStep, Optional
+
+if TYPE_CHECKING:
+    from rasa.shared.core.flows.flow import Flow
 
 
 @dataclass
@@ -12,6 +15,8 @@ class LinkFlowStep(FlowStep):
 
     link: Text
     """The id of the flow that should be started subsequently."""
+    linked_flow_reference: Optional["Flow"] = None
+    """The flow that is linked to by this step."""
 
     def does_allow_for_next_step(self) -> bool:
         """Returns whether this step allows for following steps.