rasa-pro 3.9.18__py3-none-any.whl → 3.10.3__py3-none-any.whl

rasa/shared/core/flows/validation.py

@@ -1,11 +1,18 @@
 from __future__ import annotations
 
-from collections import defaultdict
 import re
-from typing import Optional, Set, Text, List
 import typing
-from rasa.shared.constants import RASA_DEFAULT_FLOW_PATTERN_PREFIX
+from collections import defaultdict
+from typing import Optional, Set, Text, List
 
+from rasa.shared.constants import (
+    RASA_DEFAULT_FLOW_PATTERN_PREFIX,
+    RASA_PATTERN_HUMAN_HANDOFF,
+)
+from rasa.shared.constants import (
+    RASA_PATTERN_INTERNAL_ERROR,
+)
+from rasa.shared.core.flows.flow import Flow
 from rasa.shared.core.flows.flow_step import (
     FlowStep,
 )
@@ -15,17 +22,15 @@ from rasa.shared.core.flows.flow_step_links import (
     ElseFlowStepLink,
 )
 from rasa.shared.core.flows.flow_step_sequence import FlowStepSequence
-from rasa.shared.core.flows.steps.constants import CONTINUE_STEP_PREFIX, DEFAULT_STEPS
 from rasa.shared.core.flows.steps.call import CallFlowStep
-from rasa.shared.core.flows.steps.link import LinkFlowStep
 from rasa.shared.core.flows.steps.collect import CollectInformationFlowStep
-from rasa.shared.core.flows.flow import Flow
+from rasa.shared.core.flows.steps.constants import CONTINUE_STEP_PREFIX, DEFAULT_STEPS
+from rasa.shared.core.flows.steps.link import LinkFlowStep
 from rasa.shared.exceptions import RasaException
 
 if typing.TYPE_CHECKING:
     from rasa.shared.core.flows.flows_list import FlowsList
 
-
 FLOW_ID_REGEX = r"""^[a-zA-Z0-9_][a-zA-Z0-9_-]*?$"""
 
 
@@ -132,36 +137,75 @@ class NoNextAllowedForLinkException(RasaException):
 class ReferenceToPatternException(RasaException):
     """Raised when a flow step is referencing a pattern, which is not allowed."""
 
-    def __init__(self, referenced_pattern: str, flow_id: str, step_id: str) -> None:
+    def __init__(
+        self, referenced_pattern: str, flow_id: str, step_id: str, call_step: bool
+    ) -> None:
         """Initializes the exception."""
         self.step_id = step_id
         self.flow_id = flow_id
         self.referenced_pattern = referenced_pattern
+        self.call_step = call_step
 
     def __str__(self) -> str:
         """Return a string representation of the exception."""
-        return (
-            f"Step '{self.step_id}' in flow '{self.flow_id}' is referencing a pattern "
-            f"'{self.referenced_pattern}', which is not allowed. "
-            f"Patterns can not be used as a target for a link or call step."
+        message = (
+            f"Step '{self.step_id}' in flow '{self.flow_id}' is referencing a "
+            f"pattern '{self.referenced_pattern}', which is not allowed. "
+        )
+        if self.call_step:
+            return message + "Patterns can not be used as a target for a call step."
+        else:
+            return message + (
+                "All patterns, except for 'pattern_human_handoff', can "
+                "not be used as a target for a link step."
+            )
+
+
+class PatternReferencedPatternException(RasaException):
+    """Raised when a pattern is referencing a pattern, which is not allowed."""
+
+    def __init__(self, flow_id: str, step_id: str, call_step: bool) -> None:
+        """Initializes the exception."""
+        self.step_id = step_id
+        self.flow_id = flow_id
+        self.call_step = call_step
+
+    def __str__(self) -> str:
+        """Return a string representation of the exception."""
+        message = (
+            f"Step '{self.step_id}' in pattern '{self.flow_id}' is referencing a "
+            f"pattern which is not allowed. "
         )
+        if self.call_step:
+            return message + "Patterns can not use call steps to other patterns."
+        else:
+            return message + (
+                "Patterns can not use link steps to other patterns. "
+                "Exception: patterns can link to 'pattern_human_handoff'."
+            )
 
 
 class PatternReferencedFlowException(RasaException):
     """Raised when a pattern is referencing a flow, which is not allowed."""
 
-    def __init__(self, flow_id: str, step_id: str) -> None:
+    def __init__(self, flow_id: str, step_id: str, call_step: bool) -> None:
         """Initializes the exception."""
         self.step_id = step_id
         self.flow_id = flow_id
+        self.call_step = call_step
 
     def __str__(self) -> str:
         """Return a string representation of the exception."""
-        return (
-            f"Step '{self.step_id}' in flow '{self.flow_id}' is referencing a flow "
+        message = (
+            f"Step '{self.step_id}' in pattern '{self.flow_id}' is referencing a flow "
             f"which is not allowed. "
-            f"Patterns can not use link or call steps."
         )
+        if self.call_step:
+            return message + "Patterns can not use call steps."
+        else:
+            return message + (
+                "'pattern_internal_error' can not use link steps to user flows."
+            )
 
 
 class NoLinkAllowedInCalledFlowException(RasaException):
@@ -459,35 +503,76 @@ def validate_linked_flows_exists(flows: "FlowsList") -> None:
             if not isinstance(step, LinkFlowStep):
                 continue
 
-            if flows.flow_by_id(step.link) is None:
+            # It might be that the flows do not contain the default rasa patterns, but
+            # only the user flows. Manually check for `pattern_human_handoff` as this
+            # pattern can be linked to and it is part of the default patterns of rasa.
+            if (
+                flows.flow_by_id(step.link) is None
+                and step.link != RASA_PATTERN_HUMAN_HANDOFF
+            ):
                 raise UnresolvedFlowException(step.link, flow.id, step.id)
 
 
 def validate_patterns_are_not_called_or_linked(flows: "FlowsList") -> None:
-    """Validates that patterns are never called or linked."""
+    """Validates that patterns are never called or linked.
+
+    Exception: pattern_human_handoff can be linked.
+    """
     for flow in flows.underlying_flows:
         for step in flow.steps:
-            if isinstance(step, LinkFlowStep) and step.link.startswith(
-                RASA_DEFAULT_FLOW_PATTERN_PREFIX
+            if (
+                isinstance(step, LinkFlowStep)
+                and step.link.startswith(RASA_DEFAULT_FLOW_PATTERN_PREFIX)
+                and step.link != RASA_PATTERN_HUMAN_HANDOFF
             ):
-                raise ReferenceToPatternException(step.link, flow.id, step.id)
+                raise ReferenceToPatternException(
+                    step.link, flow.id, step.id, call_step=False
+                )
 
             if isinstance(step, CallFlowStep) and step.call.startswith(
                 RASA_DEFAULT_FLOW_PATTERN_PREFIX
             ):
-                raise ReferenceToPatternException(step.call, flow.id, step.id)
+                raise ReferenceToPatternException(
+                    step.call, flow.id, step.id, call_step=True
+                )
 
 
 def validate_patterns_are_not_calling_or_linking_other_flows(
     flows: "FlowsList",
 ) -> None:
-    """Validates that patterns do not contain call or link steps."""
+    """Validates that patterns do not contain call or link steps.
+
+    Link steps to user flows are allowed for all patterns but 'pattern_internal_error'.
+    Link steps to other patterns, except for 'pattern_human_handoff', are forbidden.
+    """
     for flow in flows.underlying_flows:
         if not flow.is_rasa_default_flow:
             continue
         for step in flow.steps:
-            if isinstance(step, (LinkFlowStep, CallFlowStep)):
-                raise PatternReferencedFlowException(flow.id, step.id)
+            if isinstance(step, LinkFlowStep):
+                if step.link == RASA_PATTERN_HUMAN_HANDOFF:
+                    # links to 'pattern_human_handoff' are allowed
+                    continue
+                if step.link.startswith(RASA_DEFAULT_FLOW_PATTERN_PREFIX):
+                    # all other patterns are allowed to link to user flows, but not
+                    # to other patterns
+                    raise PatternReferencedPatternException(
+                        flow.id, step.id, call_step=False
+                    )
+                if flow.id == RASA_PATTERN_INTERNAL_ERROR:
+                    # 'pattern_internal_error' is not allowed to link at all
+                    raise PatternReferencedFlowException(
+                        flow.id, step.id, call_step=False
+                    )
+            if isinstance(step, CallFlowStep):
+                if step.call.startswith(RASA_DEFAULT_FLOW_PATTERN_PREFIX):
+                    raise PatternReferencedPatternException(
+                        flow.id, step.id, call_step=True
+                    )
+                else:
+                    raise PatternReferencedFlowException(
+                        flow.id, step.id, call_step=True
+                    )
 
 
 def validate_step_ids_are_unique(flows: "FlowsList") -> None:
@@ -517,8 +602,10 @@ def validate_flow_id(flow: Flow) -> None:
     """Validates if the flow id comply with a specified regex.
     Flow IDs can start with an alphanumeric character or an underscore.
     Followed by zero or more alphanumeric characters, hyphens, or underscores.
+
     Args:
         flow: The flow to validate.
+
     Raises:
         FlowIdNamingException: If the flow id does not comply with the regex.
     """

rasa/shared/core/flows/yaml_flows_io.py

@@ -1,17 +1,18 @@
 import textwrap
 from pathlib import Path
-from typing import Any, Dict, List, Text, Union
+from typing import Any, Dict, List, Text, Union, Optional
 
 import jsonschema
+import ruamel.yaml.nodes as yaml_nodes
+from ruamel import yaml as yaml
 
 import rasa.shared
 import rasa.shared.data
-from rasa.shared.importers.importer import FlowSyncImporter
 import rasa.shared.utils.io
-from rasa.shared.exceptions import RasaException, YamlException
-
 from rasa.shared.core.flows.flow import Flow
 from rasa.shared.core.flows.flows_list import FlowsList
+from rasa.shared.exceptions import RasaException, YamlException
+from rasa.shared.importers.importer import FlowSyncImporter
 from rasa.shared.utils.yaml import (
     validate_yaml_with_jsonschema,
     read_yaml,
@@ -27,11 +28,14 @@ class YAMLFlowsReader:
     """Class that reads flows information in YAML format."""
 
     @classmethod
-    def read_from_file(cls, filename: Union[Text, Path]) -> FlowsList:
+    def read_from_file(
+        cls, filename: Union[Text, Path], add_line_numbers: bool = True
+    ) -> FlowsList:
         """Read flows from file.
 
         Args:
             filename: Path to the flows file.
+            add_line_numbers: Flag whether to add line numbers to yaml
 
         Returns:
             `Flow`s read from `filename`.
@@ -41,6 +45,8 @@ class YAMLFlowsReader:
                 rasa.shared.utils.io.read_file(
                     filename, rasa.shared.utils.io.DEFAULT_ENCODING
                 ),
+                add_line_numbers=add_line_numbers,
+                file_path=filename,
             )
         except YamlException as e:
             e.filename = str(filename)
@@ -195,11 +201,19 @@ class YAMLFlowsReader:
         )
 
     @classmethod
-    def read_from_string(cls, string: Text) -> FlowsList:
+    def read_from_string(
+        cls,
+        string: Text,
+        add_line_numbers: bool = True,
+        file_path: Optional[Union[str, Path]] = None,
+    ) -> FlowsList:
         """Read flows from a string.
 
         Args:
             string: Unprocessed YAML file content.
+            add_line_numbers: If true, a custom constructor is added to add line
+                numbers to each node.
+            file_path: File path of the flow.
 
         Returns:
             `Flow`s read from `string`.
@@ -207,10 +221,14 @@ class YAMLFlowsReader:
         validate_yaml_with_jsonschema(
             string, FLOWS_SCHEMA_FILE, humanize_error=cls.humanize_flow_error
         )
+        if add_line_numbers:
+            yaml_content = read_yaml(string, custom_constructor=line_number_constructor)
+            yaml_content = process_yaml_content(yaml_content)
 
-        yaml_content = read_yaml(string)
+        else:
+            yaml_content = read_yaml(string)
 
-        return FlowsList.from_json(yaml_content.get(KEY_FLOWS, {}))
+        return FlowsList.from_json(yaml_content.get(KEY_FLOWS, {}), file_path=file_path)
 
 
 class YamlFlowsWriter:
@@ -246,14 +264,18 @@ class YamlFlowsWriter:
 
 def flows_from_str(yaml_str: str) -> FlowsList:
     """Reads flows from a YAML string."""
-    flows = YAMLFlowsReader.read_from_string(textwrap.dedent(yaml_str))
+    flows = YAMLFlowsReader.read_from_string(
+        textwrap.dedent(yaml_str), add_line_numbers=False
+    )
     flows.validate()
     return flows
 
 
 def flows_from_str_including_defaults(yaml_str: str) -> FlowsList:
     """Reads flows from a YAML string and combine them with default flows."""
-    flows = YAMLFlowsReader.read_from_string(textwrap.dedent(yaml_str))
+    flows = YAMLFlowsReader.read_from_string(
+        textwrap.dedent(yaml_str), add_line_numbers=False
+    )
     all_flows = FlowSyncImporter.merge_with_default_flows(flows)
     all_flows.validate()
     return all_flows
@@ -276,3 +298,120 @@ def is_flows_file(file_path: Union[Text, Path]) -> bool:
     return rasa.shared.data.is_likely_yaml_file(file_path) and is_key_in_yaml(
         file_path, KEY_FLOWS
     )
+
+
+def line_number_constructor(loader: yaml.Loader, node: yaml_nodes.Node) -> Any:
+    """A custom YAML constructor adding line numbers to nodes.
+
+    Args:
+        loader (yaml.Loader): The YAML loader.
+        node (yaml.nodes.Node): The YAML node.
+
+    Returns:
+        Any: The constructed Python object with added line numbers in metadata.
+    """
+    if isinstance(node, yaml_nodes.MappingNode):
+        mapping = loader.construct_mapping(node, deep=True)
+        if "metadata" not in mapping:
+            # We add the line information to the metadata of a flow step
+            # Lines are 0-based index; adding 1 to start from
+            # line 1 for human readability
+            mapping["metadata"] = {
+                "line_numbers": f"{node.start_mark.line + 1}-{node.end_mark.line}"
+            }
+        return mapping
+    elif isinstance(node, yaml_nodes.SequenceNode):
+        sequence = loader.construct_sequence(node, deep=True)
+        for item in node.value:
+            if isinstance(item, yaml_nodes.MappingNode):
+                start_line = item.start_mark.line + 1
+                end_line = item.end_mark.line
+                # Only add line numbers to dictionary items within the sequence
+                index = node.value.index(item)
+                if isinstance(sequence[index], dict):
+                    if "metadata" not in sequence[index]:
+                        sequence[index]["metadata"] = {}
+                    if "line_numbers" not in sequence[index]["metadata"]:
+                        sequence[index]["metadata"]["line_numbers"] = (
+                            f"{start_line}-{end_line}"
+                        )
+
+        return sequence
+    return loader.construct_object(node, deep=True)
+
+
+def _remove_keys_recursively(
+    data: Union[Dict, List], keys_to_delete: List[str]
+) -> None:
+    """Recursively removes all specified keys in the given data.
+
+    Special handling for 'metadata'.
+
+    Args:
+        data: The data structure (dictionary or list) to clean.
+        keys_to_delete: A list of keys to remove from the dictionaries.
+    """
+    if isinstance(data, dict):
+        keys = list(data.keys())
+        for key in keys:
+            if key in keys_to_delete:
+                # Special case for 'metadata': only delete if it
+                # only contains 'line_numbers'
+                if key == "metadata" and isinstance(data[key], dict):
+                    if len(data[key]) == 1 and "line_numbers" in data[key]:
+                        del data[key]
+                else:
+                    del data[key]
+            else:
+                _remove_keys_recursively(data[key], keys_to_delete)
+    elif isinstance(data, list):
+        for item in data:
+            _remove_keys_recursively(item, keys_to_delete)
+
+
+def _process_keys_recursively(
+    data: Union[Dict, List], keys_to_check: List[str]
+) -> None:
+    """Recursively iterates over YAML content and applies remove_keys_recursively."""
+    if isinstance(data, dict):
+        keys = list(
+            data.keys()
+        )  # Make a list of keys to avoid changing the dictionary size during iteration
+        for key in keys:
+            if key in keys_to_check:
+                _remove_keys_recursively(data[key], ["metadata"])
+            else:
+                _process_keys_recursively(data[key], keys_to_check)
+    elif isinstance(data, list):
+        for item in data:
+            _process_keys_recursively(item, keys_to_check)
+
+
+def process_yaml_content(yaml_content: Dict[str, Any]) -> Dict[str, Any]:
+    """Processes parsed YAML content to remove "metadata"."""
+    # Remove metadata on the top level
+    if "metadata" in yaml_content and (
+        len(yaml_content["metadata"]) == 1
+        and "line_numbers" in yaml_content["metadata"]
+    ):
+        del yaml_content["metadata"]
+
+    # We expect metadata only under "flows" key...
+    keys_to_delete_metadata = [key for key in yaml_content if key != "flows"]
+    for key in keys_to_delete_metadata:
+        _remove_keys_recursively(yaml_content[key], ["metadata"])
+
+    # ...but "metadata" is also not a key of "flows"
+    if "flows" in yaml_content and "metadata" in yaml_content["flows"]:
+        if (
+            len(yaml_content["flows"]["metadata"]) == 1
+            and "line_numbers" in yaml_content["flows"]["metadata"]
+        ):
+            del yaml_content["flows"]["metadata"]
+
+    # Under the "flows" key certain keys cannot have metadata
+    _process_keys_recursively(
+        yaml_content["flows"], ["nlu_trigger", "set_slots", "metadata"]
+    )
+
+    return yaml_content

rasa/shared/core/trackers.py

@@ -449,6 +449,12 @@ class DialogueStateTracker:
         current_context = self.stack.current_context()
         return current_context.get("flow_id")
 
+    @property
+    def current_step_id(self) -> Optional[str]:
+        """Returns the id of the current step id."""
+        current_context = self.stack.current_context()
+        return current_context.get("step_id")
+
     @property
     def has_coexistence_routing_slot(self) -> bool:
         """Returns whether the coexistence routing slot is present."""

rasa/shared/core/training_data/visualization.html

@@ -87,13 +87,13 @@
     // trigger a refresh by fetching an updated graph
     setInterval(function () {
       fetch(url).then(r => r.text()).then(dot => {
-        document.getElementById('errormsg').innerHTML = '';
+        document.getElementById('errormsg').innerText = '';
         if (oldInputGraphValue === dot) return;
 
         oldInputGraphValue = dot;
         drawGraph(dot);
       }).catch(err => {
-        document.getElementById('errormsg').innerHTML =
+        document.getElementById('errormsg').innerText=
           'Failed to update plot. (' + err.message + ')';
       });
     }, refreshInterval);

rasa/shared/exceptions.py

@@ -161,3 +161,7 @@ class ProviderClientAPIException(RasaException):
         if self.info:
             s += f"\nInfo: \n{self.info}\n"
         return s
+
+
+class ProviderClientValidationError(RasaException):
+    """Raised for errors that occur during validation of the API client."""

rasa/shared/importers/importer.py

@@ -1,28 +1,28 @@
+import logging
 from abc import ABC, abstractmethod
 from functools import reduce
-from typing import Text, Optional, List, Dict, Set, Any, Tuple, Type, Union, cast
-import logging
+from typing import Any, Dict, List, Optional, Set, Text, Tuple, Type, Union, cast
 
 import importlib_resources
 
 import rasa.shared.constants
-from rasa.shared.core.flows import FlowsList
-import rasa.shared.utils.common
 import rasa.shared.core.constants
+import rasa.shared.utils.common
 import rasa.shared.utils.io
 from rasa.shared.core.domain import (
-    Domain,
+    IS_RETRIEVAL_INTENT_KEY,
+    KEY_ACTIONS,
     KEY_E2E_ACTIONS,
     KEY_INTENTS,
     KEY_RESPONSES,
-    KEY_ACTIONS,
+    Domain,
 )
 from rasa.shared.core.events import ActionExecuted, UserUttered
+from rasa.shared.core.flows import FlowsList
 from rasa.shared.core.training_data.structures import StoryGraph
+from rasa.shared.nlu.constants import ACTION_NAME, ENTITIES
 from rasa.shared.nlu.training_data.message import Message
 from rasa.shared.nlu.training_data.training_data import TrainingData
-from rasa.shared.nlu.constants import ENTITIES, ACTION_NAME
-from rasa.shared.core.domain import IS_RETRIEVAL_INTENT_KEY
 from rasa.shared.utils.yaml import read_config_file
 
 logger = logging.getLogger(__name__)
@@ -165,7 +165,7 @@ class TrainingDataImporter(ABC):
         config_path: Optional[Text] = None,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
+        args: Optional[Dict[Text, Any]] = None,
     ) -> "TrainingDataImporter":
         """Loads a `TrainingDataImporter` instance from a dictionary."""
         from rasa.shared.importers.rasa import RasaFileImporter
@@ -194,16 +194,19 @@ class TrainingDataImporter(ABC):
         config_path: Text,
         domain_path: Optional[Text] = None,
         training_data_paths: Optional[List[Text]] = None,
-        args: Optional[Dict[Text, Any]] = {},
+        args: Optional[Dict[Text, Any]] = None,
     ) -> Optional["TrainingDataImporter"]:
         from rasa.shared.importers.multi_project import MultiProjectImporter
         from rasa.shared.importers.rasa import RasaFileImporter
+        from rasa.shared.importers.remote_importer import RemoteTrainingDataImporter
 
         module_path = importer_config.pop("name", None)
         if module_path == RasaFileImporter.__name__:
             importer_class: Type[TrainingDataImporter] = RasaFileImporter
         elif module_path == MultiProjectImporter.__name__:
             importer_class = MultiProjectImporter
+        elif module_path == RemoteTrainingDataImporter.__name__:
+            importer_class = RemoteTrainingDataImporter
         else:
             try:
                 importer_class = rasa.shared.utils.common.class_from_module_path(
@@ -216,7 +219,6 @@ class TrainingDataImporter(ABC):
         constructor_arguments = rasa.shared.utils.common.minimal_kwargs(
             {**importer_config, **(args or {})}, importer_class
         )
-
         return importer_class(
             config_path,
             domain_path,
@@ -232,6 +234,26 @@ class TrainingDataImporter(ABC):
         """Returns text representation of object."""
         return self.__class__.__name__
 
+    def get_user_flows(self) -> FlowsList:
+        """Retrieves the user-defined flows that should be used for training.
+
+        Implemented by FlowSyncImporter and E2EImporter only.
+
+        Returns:
+            `FlowsList` containing all loaded flows.
+        """
+        raise NotImplementedError
+
+    def get_user_domain(self) -> Domain:
+        """Retrieves the user-defined domain that should be used for training.
+
+        Implemented by FlowSyncImporter and E2EImporter only.
+
+        Returns:
+            `Domain`.
+        """
+        raise NotImplementedError
+
 
 class NluDataImporter(TrainingDataImporter):
     """Importer that skips any Core-related file reading."""
@@ -448,6 +470,10 @@ class FlowSyncImporter(PassThroughImporter):
 
         return self.merge_with_default_flows(flows)
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_flows(self) -> FlowsList:
+        return self._importer.get_flows()
+
     @rasa.shared.utils.common.cached_method
     def get_domain(self) -> Domain:
         """Merge existing domain with properties of flows."""
@@ -476,6 +502,11 @@ class FlowSyncImporter(PassThroughImporter):
         )
         return domain
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_domain(self) -> Domain:
+        """Retrieves only user defined domain."""
+        return self._importer.get_domain()
+
 
 class ResponsesSyncImporter(PassThroughImporter):
     """Importer that syncs `responses` between Domain and NLU training data.
@@ -602,6 +633,15 @@ class E2EImporter(PassThroughImporter):
     - adds potential end-to-end bot messages from stories as actions to the domain
     """
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_flows(self) -> FlowsList:
+        if not isinstance(self._importer, FlowSyncImporter):
+            raise NotImplementedError(
+                "Accessing user flows is only supported with FlowSyncImporter."
+            )
+
+        return self._importer.get_user_flows()
+
     @rasa.shared.utils.common.cached_method
     def get_domain(self) -> Domain:
         """Retrieves model domain (see parent class for full docstring)."""
@@ -610,6 +650,15 @@ class E2EImporter(PassThroughImporter):
 
         return original.merge(e2e_domain)
 
+    @rasa.shared.utils.common.cached_method
+    def get_user_domain(self) -> Domain:
+        """Retrieves only user defined domain."""
+        if not isinstance(self._importer, FlowSyncImporter):
+            raise NotImplementedError(
+                "Accessing user domain is only supported with FlowSyncImporter."
+            )
+        return self._importer.get_user_domain()
+
     def _get_domain_with_e2e_actions(self) -> Domain:
         stories = self.get_stories()