lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/custom/custom_component/component.py

@@ -36,6 +36,7 @@ from lfx.schema.data import Data
 from lfx.schema.log import Log
 from lfx.schema.message import ErrorMessage, Message
 from lfx.schema.properties import Source
+from lfx.serialization.serialization import serialize
 from lfx.template.field.base import UNDEFINED, Input, Output
 from lfx.template.frontend_node.custom_components import ComponentFrontendNode
 from lfx.utils.async_helpers import run_until_complete
@@ -93,6 +94,20 @@ class PlaceholderGraph(NamedTuple):
     context: dict
     flow_name: str | None
 
+    def get_vertex_neighbors(self, _vertex) -> dict:
+        """Returns an empty dictionary since PlaceholderGraph has no edges or neighbors.
+
+        This method exists for compatibility with real Graph objects, allowing components
+        to check graph connectivity even when running in isolation (e.g., in tests).
+
+        Args:
+            _vertex: The vertex to check neighbors for (ignored in placeholder context).
+
+        Returns:
+            An empty dictionary, indicating no neighbors exist.
+        """
+        return {}
+
 
 class Component(CustomComponent):
     inputs: list[InputTypes] = []
@@ -121,6 +136,7 @@ class Component(CustomComponent):
         self._components: list[Component] = []
         self._event_manager: EventManager | None = None
         self._state_model = None
+        self._telemetry_input_values: dict[str, Any] | None = None
 
         # Process input kwargs
         inputs = {}
@@ -154,7 +170,7 @@ class Component(CustomComponent):
             self.trace_type = "chain"
 
         # Setup inputs and outputs
-        self._reset_all_output_values()
+        self.reset_all_output_values()
         if self.inputs is not None:
             self.map_inputs(self.inputs)
         self.map_outputs()
@@ -330,7 +346,8 @@ class Component(CustomComponent):
     def set_event_manager(self, event_manager: EventManager | None = None) -> None:
         self._event_manager = event_manager
 
-    def _reset_all_output_values(self) -> None:
+    def reset_all_output_values(self) -> None:
+        """Reset all output values to UNDEFINED."""
         if isinstance(self._outputs_map, dict):
             for output in self._outputs_map.values():
                 output.value = UNDEFINED
@@ -527,6 +544,8 @@ class Component(CustomComponent):
             ValueError: If the input name is None.
 
         """
+        telemetry_values = {}
+
         for input_ in inputs:
             if input_.name is None:
                 msg = self.build_component_error_message("Input name cannot be None")
@@ -536,6 +555,28 @@ class Component(CustomComponent):
             except TypeError:
                 self._inputs[input_.name] = input_
 
+            # Build telemetry data during existing iteration (no performance impact)
+            if self._should_track_input(input_):
+                telemetry_values[input_.name] = serialize(input_.value)
+
+        # Cache for later O(1) retrieval
+        self._telemetry_input_values = telemetry_values if telemetry_values else None
+
+    def _should_track_input(self, input_obj: InputTypes) -> bool:
+        """Check if input should be tracked in telemetry."""
+        from lfx.inputs.input_mixin import SENSITIVE_FIELD_TYPES
+
+        # Respect opt-in flag (default: False for privacy)
+        if not getattr(input_obj, "track_in_telemetry", False):
+            return False
+        # Auto-exclude sensitive field types
+        return not (hasattr(input_obj, "field_type") and input_obj.field_type in SENSITIVE_FIELD_TYPES)
+
+    def get_telemetry_input_values(self) -> dict[str, Any] | None:
+        """Get cached telemetry input values. O(1) lookup, no iteration."""
+        # Return all values including descriptive strings and None
+        return self._telemetry_input_values if self._telemetry_input_values else None
+
     def validate(self, params: dict) -> None:
         """Validates the component parameters.
 
@@ -550,7 +591,10 @@ class Component(CustomComponent):
         self._validate_outputs()
 
     async def run_and_validate_update_outputs(self, frontend_node: dict, field_name: str, field_value: Any):
-        frontend_node = self.update_outputs(frontend_node, field_name, field_value)
+        if inspect.iscoroutinefunction(self.update_outputs):
+            frontend_node = await self.update_outputs(frontend_node, field_name, field_value)
+        else:
+            frontend_node = self.update_outputs(frontend_node, field_name, field_value)
         if field_name == "tool_mode" or frontend_node.get("tool_mode"):
             is_tool_mode = field_value or frontend_node.get("tool_mode")
             frontend_node["outputs"] = [self._build_tool_output()] if is_tool_mode else frontend_node["outputs"]
@@ -1512,6 +1556,14 @@ class Component(CustomComponent):
 
         return has_chat_output(self.graph.get_vertex_neighbors(self._vertex))
 
+    def is_connected_to_chat_input(self) -> bool:
+        # Lazy import to avoid circular dependency
+        from lfx.graph.utils import has_chat_input
+
+        if self.graph is None:
+            return False
+        return has_chat_input(self.graph.get_vertex_neighbors(self._vertex))
+
     def _should_skip_message(self, message: Message) -> bool:
         """Check if the message should be skipped based on vertex configuration and message type."""
         return (
@@ -1590,7 +1642,12 @@ class Component(CustomComponent):
                 ):
                     complete_message = await self._stream_message(message.text, stored_message)
                     stored_message.text = complete_message
+                    if complete_message:
+                        stored_message.properties.state = "complete"
                     stored_message = await self._update_stored_message(stored_message)
+                    # Note: We intentionally do NOT send a message event here with state="complete"
+                    # The frontend already has all the content from streaming tokens
+                    # Only the database is updated with the complete state
                 else:
                     # Only send message event for non-streaming messages
                     await self._send_message_event(stored_message, id_=id_)

lfx/custom/custom_component/custom_component.py

@@ -12,7 +12,14 @@ from pydantic import BaseModel
 
 from lfx.custom import validate
 from lfx.custom.custom_component.base_component import BaseComponent
-from lfx.helpers import list_flows, load_flow, run_flow
+from lfx.helpers import (
+    get_flow_by_id_or_name,
+    list_flows,
+    list_flows_by_flow_folder,
+    list_flows_by_folder_id,
+    load_flow,
+    run_flow,
+)
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.services.deps import get_storage_service, get_variable_service, session_scope
@@ -97,7 +104,6 @@ class CustomComponent(BaseComponent):
         self.cache: TTLCache = TTLCache(maxsize=1024, ttl=60)
         self._results: dict = {}
         self._artifacts: dict = {}
-
         # Call parent's init after setting up our attributes
         super().__init__(**data)
 
@@ -548,15 +554,51 @@ class CustomComponent(BaseComponent):
         return run_until_complete(self.alist_flows())
 
     async def alist_flows(self) -> list[Data]:
-        if not self.user_id:
-            msg = "Session is invalid"
-            raise ValueError(msg)
-        try:
+        """List all flows for the current user."""
+        try:  # user id is validated in the function
             return await list_flows(user_id=str(self.user_id))
         except Exception as e:
             msg = f"Error listing flows: {e}"
             raise ValueError(msg) from e
 
+    async def alist_flows_by_flow_folder(self) -> list[Data]:
+        """List all flows for the current user in the same folder as the current flow."""
+        flow_id = self._get_runtime_or_frontend_node_attr("flow_id")
+        if flow_id is not None:
+            try:  # user and flow ids are validated in the function
+                return await list_flows_by_flow_folder(user_id=str(self.user_id), flow_id=str(flow_id))
+            except Exception as e:
+                msg = f"Error listing flows: {e}"
+                raise ValueError(msg) from e
+        return []
+
+    async def alist_flows_by_folder_id(self) -> list[Data]:
+        """List all flows for the current user in the same folder as the current flow."""
+        folder_id = self._get_runtime_or_frontend_node_attr("folder_id")
+        if folder_id is not None:
+            try:  # user and flow ids are validated in the function
+                return await list_flows_by_folder_id(
+                    user_id=str(self.user_id),
+                    folder_id=str(folder_id),
+                )
+            except Exception as e:
+                msg = f"Error listing flows: {e}"
+                raise ValueError(msg) from e
+        return []
+
+    async def aget_flow_by_id_or_name(self) -> Data | None:
+        flow_id = self._get_runtime_or_frontend_node_attr("flow_id")
+        flow_name = self._get_runtime_or_frontend_node_attr("flow_name")
+        if flow_id or flow_name:
+            try:  # user and flow ids are validated in the function
+                return await get_flow_by_id_or_name(
+                    user_id=str(self.user_id), flow_id=str(flow_id) if flow_id else None, flow_name=flow_name
+                )
+            except Exception as e:
+                msg = f"Error listing flows: {e}"
+                raise ValueError(msg) from e
+        return None
+
     def build(self, *args: Any, **kwargs: Any) -> Any:
         """Builds the custom component.
 
@@ -586,3 +628,23 @@ class CustomComponent(BaseComponent):
         if self.tracing_service and hasattr(self.tracing_service, "get_langchain_callbacks"):
             return self.tracing_service.get_langchain_callbacks()
         return []
+
+    def _get_runtime_or_frontend_node_attr(self, attr_name: str) -> Any:
+        """Get attribute value from the attribute name.
+
+        Falls back to frontend node attribute version
+        if it was provided (expected when updating the component's
+        build config).
+
+        Args:
+            attr_name: The attribute name (e.g., "flow_id", "flow_name")
+
+        Returns:
+            The attribute value from runtime or frontend node attribute, or None if neither exists.
+        """
+        value = getattr(self, attr_name, None)
+        if value is None:
+            attr = f"_frontend_node_{attr_name}"
+            if hasattr(self, attr):
+                value = getattr(self, attr)
+        return value

lfx/field_typing/constants.py

@@ -209,6 +209,7 @@ from lfx.io import (
     TableInput,
 )
 from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
 """
 
 if importlib.util.find_spec("langchain") is not None:

lfx/graph/edge/base.py

@@ -63,8 +63,8 @@ class Edge:
             # target_param is documents
             if isinstance(self._target_handle, str):
                 self.target_param = self._target_handle.split("|")[1]
-                self.source_handle = None
-                self.target_handle = None
+                self.source_handle = None  # type: ignore[assignment]
+                self.target_handle = None  # type: ignore[assignment]
             else:
                 msg = "Target handle is not a string"
                 raise ValueError(msg)
@@ -149,32 +149,55 @@ class Edge:
         # .outputs is a list of Output objects as dictionaries
         # meaning: check for "types" key in each dictionary
         self.source_types = [output for output in source.outputs if output["name"] == self.source_handle.name]
-        self.target_reqs = target.required_inputs + target.optional_inputs
-        # Both lists contain strings and sometimes a string contains the value we are
-        # looking for e.g. comgin_out=["Chain"] and target_reqs=["LLMChain"]
-        # so we need to check if any of the strings in source_types is in target_reqs
-        self.valid = any(
-            any(output_type in target_req for output_type in output["types"])
-            for output in self.source_types
-            for target_req in self.target_reqs
-        )
-        # Get what type of input the target node is expecting
 
-        # Update the matched type to be the first found match
-        self.matched_type = next(
-            (
-                output_type
+        # Check if this is an loop input (loop target handle with output_types)
+        is_loop_input = hasattr(self.target_handle, "input_types") and self.target_handle.input_types
+        loop_input_types = []
+
+        if is_loop_input:
+            # For loop inputs, use the configured input_types
+            # (which already includes original type + loop_types from frontend)
+            loop_input_types = list(self.target_handle.input_types)
+            self.valid = any(
+                any(output_type in loop_input_types for output_type in output["types"]) for output in self.source_types
+            )
+            # Find the first matching type
+            self.matched_type = next(
+                (
+                    output_type
+                    for output in self.source_types
+                    for output_type in output["types"]
+                    if output_type in loop_input_types
+                ),
+                None,
+            )
+        else:
+            # Standard validation for regular inputs
+            self.target_reqs = target.required_inputs + target.optional_inputs
+            # Both lists contain strings and sometimes a string contains the value we are
+            # looking for e.g. comgin_out=["Chain"] and target_reqs=["LLMChain"]
+            # so we need to check if any of the strings in source_types is in target_reqs
+            self.valid = any(
+                any(output_type in target_req for output_type in output["types"])
                 for output in self.source_types
-                for output_type in output["types"]
                 for target_req in self.target_reqs
-                if output_type in target_req
-            ),
-            None,
-        )
+            )
+            # Update the matched type to be the first found match
+            self.matched_type = next(
+                (
+                    output_type
+                    for output in self.source_types
+                    for output_type in output["types"]
+                    for target_req in self.target_reqs
+                    if output_type in target_req
+                ),
+                None,
+            )
+
         no_matched_type = self.matched_type is None
         if no_matched_type:
             logger.debug(self.source_types)
-            logger.debug(self.target_reqs)
+            logger.debug(self.target_reqs if not is_loop_input else loop_input_types)
             msg = f"Edge between {source.vertex_type} and {target.vertex_type} has no matched type."
             raise ValueError(msg)
 

lfx/graph/graph/base.py

@@ -402,7 +402,7 @@ class Graph:
         for vertex in self.vertices:
             if vertex.custom_component is None:
                 continue
-            vertex.custom_component._reset_all_output_values()
+            vertex.custom_component.reset_all_output_values()
 
     def start(
         self,
@@ -1519,7 +1519,10 @@ class Graph:
         try:
             params = ""
             should_build = False
-            if not vertex.frozen:
+            # Loop components must always build, even when frozen,
+            # because they need to iterate through their data
+            is_loop_component = vertex.display_name == "Loop" or vertex.is_loop
+            if not vertex.frozen or is_loop_component:
                 should_build = True
             else:
                 # Check the cache for the vertex

lfx/graph/graph/schema.py

@@ -4,11 +4,12 @@ from typing import TYPE_CHECKING, NamedTuple, Protocol
 
 from typing_extensions import NotRequired, TypedDict
 
+from lfx.graph.edge.schema import EdgeData
+from lfx.graph.vertex.schema import NodeData
+
 if TYPE_CHECKING:
-    from lfx.graph.edge.schema import EdgeData
     from lfx.graph.schema import ResultData
     from lfx.graph.vertex.base import Vertex
-    from lfx.graph.vertex.schema import NodeData
     from lfx.schema.log import LoggableType
 
 

lfx/graph/state/model.py

@@ -1,7 +1,7 @@
 from collections.abc import Callable
 from typing import Any, get_type_hints
 
-from pydantic import ConfigDict, computed_field, create_model
+from pydantic import BaseModel, ConfigDict, computed_field, create_model
 from pydantic.fields import FieldInfo
 
 
@@ -199,6 +199,7 @@ def create_state_model(model_name: str = "State", *, validate: bool = True, **kw
           with a 'get_output_by_method' attribute when validate is True.
     """
     fields = {}
+    computed_fields_dict = {}
 
     for name, value in kwargs.items():
         # Extract the return type from the method's type annotations
@@ -214,7 +215,8 @@ def create_state_model(model_name: str = "State", *, validate: bool = True, **kw
                 if ("get_output_by_method" not in str(e) and "__self__" not in str(e)) or validate:
                     raise
                 property_method = value
-            fields[name] = computed_field(property_method)
+            # Store computed fields separately to add them to the base class
+            computed_fields_dict[name] = computed_field(property_method)
         elif isinstance(value, FieldInfo):
             field_tuple = (value.annotation or Any, value)
             fields[name] = field_tuple
@@ -234,4 +236,15 @@ def create_state_model(model_name: str = "State", *, validate: bool = True, **kw
 
     # Create the model dynamically
     config_dict = ConfigDict(arbitrary_types_allowed=True, validate_assignment=True)
+
+    # If we have computed fields, create a base class with them first
+    if computed_fields_dict:
+        # Create a base class with computed fields
+        base_class_attrs = computed_fields_dict.copy()
+        base_class_attrs["model_config"] = config_dict
+        base_state_model = type(f"{model_name}Base", (BaseModel,), base_class_attrs)
+
+        # Then create the final model with the base class
+        return create_model(model_name, __base__=base_state_model, __config__=config_dict, **fields)
+    # No computed fields, just create the model directly
     return create_model(model_name, __config__=config_dict, **fields)

lfx/graph/utils.py

@@ -198,3 +198,9 @@ def has_chat_output(vertices: dict[Vertex, int]):
     from lfx.graph.schema import InterfaceComponentTypes
 
     return any(InterfaceComponentTypes.ChatOutput in vertex.id for vertex in vertices)
+
+
+def has_chat_input(vertices: dict[Vertex, int]):
+    from lfx.graph.schema import InterfaceComponentTypes
+
+    return any(InterfaceComponentTypes.ChatInput in vertex.id for vertex in vertices)

lfx/graph/vertex/base.py

@@ -735,7 +735,10 @@ class Vertex:
                 self.build_inactive()
                 return None
 
-            if self.frozen and self.built:
+            # Loop components should always run, even when frozen,
+            # because they need to iterate through their data
+            is_loop_component = self.display_name == "Loop" or self.is_loop
+            if self.frozen and self.built and not is_loop_component:
                 return await self.get_requester_result(requester)
             if self.built and requester is not None:
                 # This means that the vertex has already been built

lfx/graph/vertex/param_handler.py

@@ -3,7 +3,6 @@
 from __future__ import annotations
 
 import ast
-import os
 from typing import TYPE_CHECKING, Any
 
 import pandas as pd
@@ -129,6 +128,8 @@ class ParameterHandler:
 
     def should_skip_field(self, field_name: str, field: dict, params: dict[str, Any]) -> bool:
         """Determine if field should be skipped."""
+        if field.get("override_skip"):
+            return False
         return (
             field.get("type") == "other"
             or field_name in params
@@ -137,7 +138,10 @@ class ParameterHandler:
         )
 
     def process_file_field(self, field_name: str, field: dict, params: dict[str, Any]) -> dict[str, Any]:
-        """Process file type fields."""
+        """Process file type fields.
+
+        Converts logical paths (flow_id/filename) to component-ready paths.
+        """
         if file_path := field.get("file_path"):
             try:
                 full_path: str | list[str] = ""
@@ -146,12 +150,11 @@ class ParameterHandler:
                     if isinstance(file_path, str):
                         file_path = [file_path]
                     for p in file_path:
-                        flow_id, file_name = os.path.split(p)
-                        path = self.storage_service.build_full_path(flow_id, file_name)
-                        full_path.append(path)
+                        resolved = self.storage_service.resolve_component_path(p)
+                        full_path.append(resolved)
                 else:
-                    flow_id, file_name = os.path.split(file_path)
-                    full_path = self.storage_service.build_full_path(flow_id, file_name)
+                    full_path = self.storage_service.resolve_component_path(file_path)
+
             except ValueError as e:
                 if "too many values to unpack" in str(e):
                     full_path = file_path

lfx/graph/vertex/vertex_types.py

@@ -65,7 +65,7 @@ class ComponentVertex(Vertex):
                 self.built_object, self.artifacts = result
             elif len(result) == 3:  # noqa: PLR2004
                 self.custom_component, self.built_object, self.artifacts = result
-                self.logs = self.custom_component._output_logs
+                self.logs = self.custom_component.get_output_logs()
                 for key in self.artifacts:
                     if self.artifacts_raw is None:
                         self.artifacts_raw = {}

lfx/helpers/__init__.py

@@ -36,8 +36,11 @@ if has_langflow_memory():
         from langflow.helpers.flow import (
             build_schema_from_inputs,
             get_arg_names,
+            get_flow_by_id_or_name,
             get_flow_inputs,
             list_flows,
+            list_flows_by_flow_folder,
+            list_flows_by_folder_id,
             load_flow,
             run_flow,
         )
@@ -69,8 +72,11 @@ if has_langflow_memory():
         from lfx.helpers.flow import (
             build_schema_from_inputs,
             get_arg_names,
+            get_flow_by_id_or_name,
             get_flow_inputs,
             list_flows,
+            list_flows_by_flow_folder,
+            list_flows_by_folder_id,
             load_flow,
             run_flow,
         )
@@ -102,8 +108,11 @@ else:
     from lfx.helpers.flow import (
         build_schema_from_inputs,
         get_arg_names,
+        get_flow_by_id_or_name,
         get_flow_inputs,
         list_flows,
+        list_flows_by_flow_folder,
+        list_flows_by_folder_id,
         load_flow,
         run_flow,
     )
@@ -121,8 +130,11 @@ __all__ = [
     "docs_to_data",
     "format_type",
     "get_arg_names",
+    "get_flow_by_id_or_name",
     "get_flow_inputs",
     "list_flows",
+    "list_flows_by_flow_folder",
+    "list_flows_by_folder_id",
     "load_flow",
     "run_flow",
     "safe_convert",

lfx/helpers/flow.py

@@ -85,6 +85,123 @@ async def list_flows(*, user_id: str | None = None) -> list[Data]:
     return []
 
 
+async def list_flows_by_flow_folder(
+    *,
+    user_id: str | None = None,
+    flow_id: str | None = None,
+    order_params: dict | None = {"column": "updated_at", "direction": "desc"},  # noqa: B006, ARG001
+) -> list[Data]:
+    """Lists flows for the given user and in the same folder as the specified flow.
+
+    Retrieves all flows belonging to the given user and identified by user_id
+    that belong to the same folder as the flow identified by flow_id if the flow belongs to the user.
+
+    Optionally accepts a dictionary of order parameters
+    to order the flows by the specified column and direction.
+    Default order column is "updated_at" and default order direction is "desc".
+
+    In lfx, this is a stub that returns an empty list since we don't have
+    a database backend by default.
+
+    Args:
+        user_id (str | None, optional): The user ID to list flows for. Defaults to None.
+        flow_id (str | None, optional): The flow ID to list flows in the same folder as. Defaults to None.
+        order_params (dict | None, optional): Parameters for ordering the flows.
+        Defaults to {"column": "updated_at", "direction": "desc"}.
+            - column: The column to order by. Defaults to "updated_at".
+            - direction: The direction to order by. Defaults to "desc".
+
+    Returns:
+        list[Data]: List of flows in the same folder as the flow identified by flow_id.
+
+    Raises:
+        ValueError: If user_id is not provided.
+        ValueError: If Flow ID is not provided.
+    """
+    if not user_id:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+    if not flow_id:
+        msg = "Flow ID is required"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    logger.warning("list_flows_by_flow_folder called but lfx doesn't have database backend by default")
+    return []
+
+
+async def list_flows_by_folder_id(
+    *,
+    user_id: str | None = None,
+    folder_id: str | None = None,
+) -> list[Data]:
+    """Lists flows for the given user and in the same folder as the specified folder.
+
+    Retrieves all flows belonging to the user identified by user_id
+    that belong to the same folder as the folder identified by folder_id
+    if the folder belongs to the user.
+
+    In lfx, this is a stub that returns an empty list since we don't have
+    a database backend by default.
+
+    Args:
+        user_id (str | None, optional): The user ID to list flows for. Defaults to None.
+        folder_id (str | None, optional): The folder ID to list flows in the same folder as. Defaults to None.
+
+    Returns:
+        list[Data]: List of flows in the same folder as the folder identified by folder_id.
+
+    Raises:
+        ValueError: If user_id is not provided.
+        ValueError: If Folder ID is not provided.
+    """
+    if not user_id:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+    if not folder_id:
+        msg = "Folder ID is required"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    logger.warning("list_flows_by_folder_id called but lfx doesn't have database backend by default")
+    return []
+
+
+async def get_flow_by_id_or_name(
+    user_id: str,
+    flow_id: str | None = None,
+    flow_name: str | None = None,
+) -> Data | None:
+    """Get a flow by ID or name.
+
+    Retrieves a flow by ID or name. If both are provided, flow_id is used.
+
+    In lfx, this is a stub that returns None since we don't have
+    a database backend by default.
+
+    Args:
+        user_id (str): The user ID to get the flow for.
+        flow_id (str | None, optional): The flow ID. Defaults to None.
+        flow_name (str | None, optional): The flow name. Defaults to None.
+
+    Returns:
+        Data | None: The flow data or None if not found.
+    """
+    if not user_id:
+        msg = "Session is invalid"
+        raise ValueError(msg)
+    if not (flow_id or flow_name):
+        msg = "Flow ID or Flow Name is required"
+        raise ValueError(msg)
+
+    # In lfx, we don't have a database backend by default
+    # This is a stub implementation
+    logger.warning("get_flow_by_id_or_name called but lfx doesn't have database backend by default")
+    return None
+
+
 async def load_flow(
     user_id: str,  # noqa: ARG001
     flow_id: str | None = None,