rasa-pro 3.12.18.dev1__py3-none-any.whl → 3.12.20__py3-none-any.whl

rasa/dialogue_understanding/stack/frames/flow_stack_frame.py

@@ -53,7 +53,8 @@ class FlowStackFrameType(str, Enum):
             typ: The string to create the `FlowStackFrameType` from.
 
         Returns:
-            The created `FlowStackFrameType`."""
+        The created `FlowStackFrameType`.
+        """
         if typ is None:
             return FlowStackFrameType.REGULAR
         elif typ == FlowStackFrameType.INTERRUPT.value:
@@ -107,7 +108,8 @@ class BaseFlowStackFrame(DialogueStackFrame):
             all_flows: All flows in the assistant.
 
         Returns:
-            The current flow."""
+        The current flow.
+        """
         flow = all_flows.flow_by_id(self.flow_id)
         if not flow:
             # we shouldn't ever end up with a frame that belongs to a non
@@ -122,9 +124,20 @@ class BaseFlowStackFrame(DialogueStackFrame):
             all_flows: All flows in the assistant.
 
         Returns:
-            The current flow step."""
+            The current flow step.
+        """
         flow = self.flow(all_flows)
-        step = flow.step_by_id(self.step_id)
+
+        step_id = self.step_id
+        # in 3.11.4 we added the flow_id as a prefix to the step_id
+        # this causes issues when loading old dialogues as the prefix is missing
+        # (see https://rasahq.atlassian.net/jira/software/c/projects/ENG/boards/43?selectedIssue=ENG-1939)
+        # so we try to find the step by adding the flow prefix to old step_ids as well
+        # TODO: remove this in 4.0.0
+        alternative_step_id = f"{self.flow_id}_{self.step_id}"
+
+        step = flow.step_by_id(step_id) or flow.step_by_id(alternative_step_id)
+
         if not step:
             # we shouldn't ever end up with a frame that belongs to a non
             # existing step, but if we do, we should raise an error

rasa/dialogue_understanding/stack/utils.py

@@ -209,7 +209,9 @@ def get_collect_steps_excluding_ask_before_filling_for_active_flow(
         All collect steps that are part of the current active flow,
         excluding the collect steps that have to be asked before filling.
     """
-    active_frame = top_user_flow_frame(dialogue_stack)
+    active_frame = top_user_flow_frame(
+        dialogue_stack, ignore_call_and_link_frames=False
+    )
     if active_frame is None:
         return set()
     active_flow = active_frame.flow(all_flows)

rasa/dialogue_understanding/utils.py

@@ -1,7 +1,9 @@
 from contextlib import contextmanager
 from typing import Any, Dict, Generator, List, Optional, Text
 
-from rasa.dialogue_understanding.commands import Command
+import structlog
+
+from rasa.dialogue_understanding.commands import Command, NoopCommand, SetSlotCommand
 from rasa.dialogue_understanding.constants import (
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME,
 )
@@ -16,7 +18,6 @@ from rasa.shared.nlu.constants import (
     KEY_USER_PROMPT,
     PREDICTED_COMMANDS,
     PROMPTS,
-    SET_SLOT_COMMAND,
 )
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.providers.llm.llm_response import LLMResponse
@@ -26,6 +27,8 @@ record_commands_and_prompts = get_bool_env_variable(
     RASA_RECORD_COMMANDS_AND_PROMPTS_ENV_VAR_NAME, False
 )
 
+structlogger = structlog.get_logger()
+
 
 @contextmanager
 def set_record_commands_and_prompts() -> Generator:
@@ -144,21 +147,74 @@ def _handle_via_nlu_in_coexistence(
     if not tracker:
         return False
 
+    commands = message.get(COMMANDS, [])
+
+    # If coexistence routing slot is not active, this setup doesn't
+    # support dual routing -> default to CALM
     if not tracker.has_coexistence_routing_slot:
+        structlogger.debug(
+            "utils.handle_via_nlu_in_coexistence"
+            ".tracker_missing_route_session_to_calm_slot",
+            event_info=(
+                f"Tracker doesn't have the '{ROUTE_TO_CALM_SLOT}' slot."
+                f"Routing to CALM."
+            ),
+            route_session_to_calm=commands,
+        )
         return False
 
+    # Check if the routing decision is stored in the tracker slot
+    # If slot is true -> route to CALM
+    # If slot is false -> route to DM1
     value = tracker.get_slot(ROUTE_TO_CALM_SLOT)
     if value is not None:
+        structlogger.debug(
+            "utils.handle_via_nlu_in_coexistence"
+            ".tracker_route_session_to_calm_slot_value",
+            event_info=(
+                f"Tracker slot '{ROUTE_TO_CALM_SLOT}' set to '{value}'. "
+                f"Routing to "
+                f"{'CALM' if value else 'NLU system'}."
+            ),
+            route_session_to_calm_value_in_tracker=value,
+        )
         return not value
 
-    # routing slot has been reset so we need to check
-    # the command issued by the Router component
-    if message.get(COMMANDS):
-        for command in message.get(COMMANDS):
-            if (
-                command.get("command") == SET_SLOT_COMMAND
-                and command.get("name") == ROUTE_TO_CALM_SLOT
-            ):
-                return not command.get("value")
-
+    # Non-sticky routing to DM1 is only allowed if NoopCommand is the sole predicted
+    # command. In that case, route to DM1
+    if len(commands) == 1 and commands[0].get("command") == NoopCommand.command():
+        structlogger.debug(
+            "utils.handle_via_nlu_in_coexistence.noop_command_detected",
+            event_info="NoopCommand found. Routing to NLU system non-sticky.",
+            commands=commands,
+        )
+        return True
+
+    # If the slot was reset (e.g. new session), try to infer routing from
+    # attached commands. Look for a SetSlotCommand targeting the ROUTE_TO_CALM_SLOT
+    for command in message.get(COMMANDS, []):
+        # If slot is true -> route to CALM
+        # If slot is false -> route to DM1
+        if (
+            command.get("command") == SetSlotCommand.command()
+            and command.get("name") == ROUTE_TO_CALM_SLOT
+        ):
+            structlogger.debug(
+                "utils.handle_via_nlu_in_coexistence.set_slot_command_detected",
+                event_info=(
+                    f"SetSlotCommand setting the '{ROUTE_TO_CALM_SLOT}' to "
+                    f"'{command.get('value')}'. "
+                    f"Routing to "
+                    f"{'CALM' if command.get('value') else 'NLU system'}."
+                ),
+                commands=commands,
+            )
+            return not command.get("value")
+
+    # If no routing info is available -> default to CALM
+    structlogger.debug(
+        "utils.handle_via_nlu_in_coexistence.no_routing_info_available",
+        event_info="No routing info available. Routing to CALM.",
+        commands=commands,
+    )
     return False

rasa/dialogue_understanding_test/du_test_schema.yml

@@ -5,12 +5,12 @@ mapping:
     sequence:
       - type: map
         mapping:
-          regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+          regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
             type: "seq"
             sequence:
               - type: map
                 mapping:
-                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
                     type: any
 
   metadata:
@@ -129,7 +129,7 @@ mapping:
             type: "seq"
             sequence:
               - type: "str"
-                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
+                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_\-]*$
           metadata:
             type: "str"
             pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$

rasa/e2e_test/e2e_test_coverage_report.py

@@ -21,7 +21,7 @@ from rasa.shared.core.flows.flow_path import FlowPath, FlowPathsList, PathNode
 FLOW_NAME_COL_NAME = "Flow Name"
 NUM_STEPS_COL_NAME = "Num Steps"
 MISSING_STEPS_COL_NAME = "Missing Steps"
-LINE_NUMBERS_COL_NAME = "Line Numbers"
+LINE_NUMBERS_COL_NAME = "Line Numbers for Missing Steps"
 COVERAGE_COL_NAME = "Coverage"
 
 FLOWS_KEY = "flows"

rasa/e2e_test/e2e_test_schema.yml

@@ -5,12 +5,12 @@ mapping:
     sequence:
       - type: map
         mapping:
-          regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+          regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
             type: "seq"
             sequence:
               - type: map
                 mapping:
-                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_]*$):
+                  regex;(^[a-zA-Z_]+[a-zA-Z0-9_\-]*$):
                     type: any
 
   metadata:
@@ -129,7 +129,7 @@ mapping:
             type: "seq"
             sequence:
               - type: "str"
-                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$
+                pattern: ^[a-zA-Z_]+[a-zA-Z0-9_\-]*$
           metadata:
             type: "str"
             pattern: ^[a-zA-Z_]+[a-zA-Z0-9_]*$

rasa/hooks.py

@@ -1,20 +1,8 @@
 import argparse
 import logging
-import os
 from typing import TYPE_CHECKING, List, Optional, Text, Union
 
-import litellm
 import pluggy
-import structlog
-
-from rasa.shared.providers.constants import (
-    LANGFUSE_CALLBACK_NAME,
-    LANGFUSE_HOST_ENV_VAR,
-    LANGFUSE_PROJECT_ID_ENV_VAR,
-    LANGFUSE_PUBLIC_KEY_ENV_VAR,
-    LANGFUSE_SECRET_KEY_ENV_VAR,
-    RASA_LANGFUSE_INTEGRATION_ENABLED_ENV_VAR,
-)
 
 # IMPORTANT: do not import anything from rasa here - use scoped imports
 #  this avoids circular imports, as the hooks are used in different places
@@ -30,7 +18,6 @@ if TYPE_CHECKING:
 
 hookimpl = pluggy.HookimplMarker("rasa")
 logger = logging.getLogger(__name__)
-structlogger = structlog.get_logger()
 
 
 @hookimpl  # type: ignore[misc]
@@ -70,8 +57,6 @@ def configure_commandline(cmdline_arguments: argparse.Namespace) -> Optional[Tex
         config.configure_tracing(tracer_provider)
         config.configure_metrics(endpoints_file)
 
-    _init_langfuse_integration()
-
     return endpoints_file
 
 
@@ -130,43 +115,3 @@ def after_server_stop() -> None:
 
     if anon_pipeline is not None:
         anon_pipeline.stop()
-
-
-def _is_langfuse_integration_enabled() -> bool:
-    return (
-        os.environ.get(RASA_LANGFUSE_INTEGRATION_ENABLED_ENV_VAR, "false").lower()
-        == "true"
-    )
-
-
-def _init_langfuse_integration() -> None:
-    if not _is_langfuse_integration_enabled():
-        structlogger.info(
-            "hooks._init_langfuse_integration.disabled",
-            event_info="Langfuse integration is disabled.",
-        )
-        return
-
-    if (
-        not os.environ.get(LANGFUSE_HOST_ENV_VAR)
-        or not os.environ.get(LANGFUSE_PROJECT_ID_ENV_VAR)
-        or not os.environ.get(LANGFUSE_PUBLIC_KEY_ENV_VAR)
-        or not os.environ.get(LANGFUSE_SECRET_KEY_ENV_VAR)
-    ):
-        structlogger.warning(
-            "hooks._init_langfuse_integration.missing_langfuse_keys",
-            event_info=(
-                "Langfuse integration is enabled, but some environment variables "
-                "are missing. Please set LANGFUSE_HOST, LANGFUSE_PROJECT_ID, "
-                "LANGFUSE_PUBLIC_KEY and LANGFUSE_SECRET_KEY environment "
-                "variables to use Langfuse integration."
-            ),
-        )
-        return
-
-    litellm.success_callback = [LANGFUSE_CALLBACK_NAME]
-    litellm.failure_callback = [LANGFUSE_CALLBACK_NAME]
-    structlogger.info(
-        "hooks.langfuse_callbacks_initialized",
-        event_info="Langfuse integration initialized.",
-    )

rasa/llm_fine_tuning/utils.py

@@ -1,6 +1,6 @@
 from contextlib import contextmanager
 from datetime import datetime
-from typing import Any, Callable, Dict, Generator, List, Optional, Union
+from typing import Callable, Generator, List, Union
 
 import structlog
 
@@ -24,9 +24,7 @@ def make_mock_invoke_llm(commands: str) -> Callable:
     """
 
     async def _mock_invoke_llm(
-        self: LLMBasedCommandGenerator,
-        prompt: Union[List[dict], List[str], str],
-        metadata: Optional[Dict[str, Any]] = None,
+        self: LLMBasedCommandGenerator, prompt: Union[List[dict], List[str], str]
     ) -> LLMResponse:
         structlogger.debug(
             f"LLM call intercepted, response mocked. "

rasa/shared/constants.py

@@ -342,8 +342,3 @@ ROLE_SYSTEM = "system"
 # Used for key values in ValidateSlotPatternFlowStackFrame
 REFILL_UTTER = "refill_utter"
 REJECTIONS = "rejections"
-
-LANGFUSE_METADATA_USER_ID = "trace_user_id"
-LANGFUSE_METADATA_SESSION_ID = "session_id"
-LANGFUSE_CUSTOM_METADATA_DICT = "trace_metadata"
-LANGFUSE_TAGS = "tags"

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 (
@@ -61,6 +64,8 @@ class FlowLanguageTranslation(BaseModel):
     """The human-readable name of the flow."""
 
     class Config:
+        """Configuration for the FlowLanguageTranslation model."""
+
         extra = "ignore"
 
 
@@ -232,9 +237,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.
@@ -488,6 +493,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.
 
@@ -496,19 +504,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.
@@ -520,10 +534,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
@@ -531,6 +580,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(
@@ -538,12 +643,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()
 
@@ -553,6 +661,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.
 
@@ -561,6 +672,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
@@ -575,6 +688,7 @@ class Flow:
                     current_path,
                     all_paths,
                     visited_step_ids,
+                    call_stack,
                 )
                 return
         # IfFlowStepLink and ElseFlowStepLink are conditional links.
@@ -588,6 +702,7 @@ class Flow:
                         current_path,
                         all_paths,
                         visited_step_ids,
+                        call_stack,
                     )
                 return
             else:
@@ -598,6 +713,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/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.