lfx-nightly 0.2.1.dev7__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

lfx/graph/vertex/base.py

@@ -8,6 +8,9 @@ from collections.abc import AsyncIterator, Callable, Iterator, Mapping
 from enum import Enum
 from typing import TYPE_CHECKING, Any
 
+from ag_ui.core import StepFinishedEvent, StepStartedEvent
+
+from lfx.events.observability.lifecycle_events import observable
 from lfx.exceptions.component import ComponentBuildError
 from lfx.graph.schema import INPUT_COMPONENTS, OUTPUT_COMPONENTS, InterfaceComponentTypes, ResultData
 from lfx.graph.utils import UnbuiltObject, UnbuiltResult, log_transaction
@@ -105,7 +108,6 @@ class Vertex:
         self.use_result = False
         self.build_times: list[float] = []
         self.state = VertexStates.ACTIVE
-        self.log_transaction_tasks: set[asyncio.Task] = set()
         self.output_names: list[str] = [
             output["name"] for output in self.outputs if isinstance(output, dict) and "name" in output
         ]
@@ -180,6 +182,7 @@ class Vertex:
 
         if isinstance(self.built_result, UnbuiltResult):
             return {}
+
         return self.built_result if isinstance(self.built_result, dict) else {"result": self.built_result}
 
     def set_artifacts(self) -> None:
@@ -381,6 +384,7 @@ class Vertex:
                 vertex=self,
             )
 
+    @observable
     async def _build(
         self,
         fallback_to_env_vars,
@@ -390,7 +394,6 @@ class Vertex:
         """Initiate the build process."""
         await logger.adebug(f"Building {self.display_name}")
         await self._build_each_vertex_in_params_dict()
-
         if self.base_type is None:
             msg = f"Base type for vertex {self.display_name} not found"
             raise ValueError(msg)
@@ -531,11 +534,12 @@ class Vertex:
         self,
         flow_id: str | UUID,
         source: Vertex,
-        status,
+        status: str,
         target: Vertex | None = None,
-        error=None,
+        error: str | Exception | None = None,
+        outputs: dict[str, Any] | None = None,
     ) -> None:
-        """Log a transaction asynchronously with proper task handling and cancellation.
+        """Log a transaction asynchronously.
 
         Args:
             flow_id: The ID of the flow
@@ -543,20 +547,16 @@ class Vertex:
             status: Transaction status
             target: Optional target vertex
             error: Optional error information
+            outputs: Optional explicit outputs dict (component execution results)
         """
-        if self.log_transaction_tasks:
-            # Safely await and remove completed tasks
-            task = self.log_transaction_tasks.pop()
-            await task
-
-            # Create and track new task
-        task = asyncio.create_task(log_transaction(flow_id, source, status, target, error))
-        self.log_transaction_tasks.add(task)
-        task.add_done_callback(self.log_transaction_tasks.discard)
+        try:
+            await log_transaction(flow_id, source, status, target, error, outputs)
+        except Exception as exc:  # noqa: BLE001
+            logger.debug(f"Error logging transaction: {exc!s}")
 
     async def _get_result(
         self,
-        requester: Vertex,
+        requester: Vertex,  # noqa: ARG002
         target_handle_name: str | None = None,  # noqa: ARG002
     ) -> Any:
         """Retrieves the result of the built component.
@@ -566,17 +566,11 @@ class Vertex:
         Returns:
             The built result if use_result is True, else the built object.
         """
-        flow_id = self.graph.flow_id
         if not self.built:
-            if flow_id:
-                await self._log_transaction_async(str(flow_id), source=self, target=requester, status="error")
             msg = f"Component {self.display_name} has not been built yet"
             raise ValueError(msg)
 
-        result = self.built_result if self.use_result else self.built_object
-        if flow_id:
-            await self._log_transaction_async(str(flow_id), source=self, target=requester, status="success")
-        return result
+        return self.built_result if self.use_result else self.built_object
 
     async def _build_vertex_and_update_params(self, key, vertex: Vertex) -> None:
         """Builds a given vertex and updates the params dictionary accordingly."""
@@ -657,6 +651,12 @@ class Vertex:
         except Exception as exc:
             tb = traceback.format_exc()
             await logger.aexception(exc)
+            # Log transaction error
+            flow_id = self.graph.flow_id
+            if flow_id:
+                await self._log_transaction_async(
+                    str(flow_id), source=self, target=None, status="error", error=str(exc)
+                )
             msg = f"Error building Component {self.display_name}: \n\n{exc}"
             raise ComponentBuildError(msg, tb) from exc
 
@@ -772,6 +772,19 @@ class Vertex:
 
             self.finalize_build()
 
+            # Log transaction after successful build
+            flow_id = self.graph.flow_id
+            if flow_id:
+                # Extract outputs from outputs_logs for transaction logging
+                outputs_dict = None
+                if self.outputs_logs:
+                    outputs_dict = {
+                        k: v.model_dump() if hasattr(v, "model_dump") else v for k, v in self.outputs_logs.items()
+                    }
+                await self._log_transaction_async(
+                    str(flow_id), source=self, target=None, status="success", outputs=outputs_dict
+                )
+
         return await self.get_requester_result(requester)
 
     async def get_requester_result(self, requester: Vertex | None):
@@ -824,3 +837,39 @@ class Vertex:
             return
         # Apply the function to each output
         [func(output) for output in self.custom_component.get_outputs_map().values()]
+
+    # AGUI/AG UI Event Streaming Callbacks/Methods - (Optional, see Observable decorator)
+    def raw_event_metrics(self, optional_fields: dict | None) -> dict:
+        """This method is used to get the metrics of the vertex by the Observable decorator.
+
+        If the vertex has a get_metrics method, it will be called, and the metrics will be captured
+        to stream back to the user in an AGUI compliant format.
+        Additional fields/metrics to be captured can be modified in this method, or in the callback methods,
+        which are before_callback_event and after_callback_event before returning the AGUI event.
+        """
+        if optional_fields is None:
+            optional_fields = {}
+        import time
+
+        return {"timestamp": time.time(), **optional_fields}
+
+    def before_callback_event(self, *args, **kwargs) -> StepStartedEvent:  # noqa: ARG002
+        """Should be a AGUI compatible event.
+
+        VERTEX class generates a StepStartedEvent event.
+        """
+        metrics = {}
+        if hasattr(self, "raw_event_metrics"):
+            metrics = self.raw_event_metrics({"component_id": self.id})
+
+        return StepStartedEvent(step_name=self.display_name, raw_event={"langflow": metrics})
+
+    def after_callback_event(self, result, *args, **kwargs) -> StepFinishedEvent:  # noqa: ARG002
+        """Should be a AGUI compatible event.
+
+        VERTEX class generates a StepFinishedEvent event.
+        """
+        metrics = {}
+        if hasattr(self, "raw_event_metrics"):
+            metrics = self.raw_event_metrics({"component_id": self.id})
+        return StepFinishedEvent(step_name=self.display_name, raw_event={"langflow": metrics})

lfx/graph/vertex/vertex_types.py

@@ -98,7 +98,6 @@ class ComponentVertex(Vertex):
         Returns:
             The built result if use_result is True, else the built object.
         """
-        flow_id = self.graph.flow_id
         if not self.built:
             default_value: Any = UNDEFINED
             for edge in self.get_edge_with_target(requester.id):
@@ -109,8 +108,6 @@ class ComponentVertex(Vertex):
                     else:
                         default_value = requester.get_value_from_template_dict(edge.target_param)
 
-            if flow_id:
-                await self._log_transaction_async(source=self, target=requester, flow_id=str(flow_id), status="error")
             if default_value is not UNDEFINED:
                 return default_value
             msg = f"Component {self.display_name} has not been built yet"
@@ -148,8 +145,6 @@ class ComponentVertex(Vertex):
                 raise ValueError(msg)
             msg = f"Result not found for {edge.source_handle.name} in {edge}"
             raise ValueError(msg)
-        if flow_id:
-            await self._log_transaction_async(source=self, target=requester, flow_id=str(flow_id), status="success")
         return result
 
     def extract_messages_from_artifacts(self, artifacts: dict[str, Any]) -> list[dict]:

lfx/inputs/input_mixin.py

@@ -28,6 +28,7 @@ class FieldTypes(str, Enum):
     AUTH = "auth"
     FILE = "file"
     PROMPT = "prompt"
+    MUSTACHE_PROMPT = "mustache"
     CODE = "code"
     OTHER = "other"
     TABLE = "table"

lfx/inputs/inputs.py

@@ -120,6 +120,10 @@ class PromptInput(BaseInputMixin, ListableInputMixin, InputTraceMixin, ToolModeM
     field_type: SerializableFieldTypes = FieldTypes.PROMPT
 
 
+class MustachePromptInput(PromptInput):
+    field_type: SerializableFieldTypes = FieldTypes.MUSTACHE_PROMPT
+
+
 class CodeInput(BaseInputMixin, ListableInputMixin, InputTraceMixin, ToolModeMixin):
     field_type: SerializableFieldTypes = FieldTypes.CODE
 
@@ -807,6 +811,7 @@ InputTypes: TypeAlias = (
     | NestedDictInput
     | ToolsInput
     | PromptInput
+    | MustachePromptInput
     | CodeInput
     | SecretStrInput
     | StrInput

lfx/interface/components.py

@@ -14,11 +14,16 @@ import orjson
 from lfx.constants import BASE_COMPONENTS_PATH
 from lfx.custom.utils import abuild_custom_components, create_component_template
 from lfx.log.logger import logger
+from lfx.utils.validate_cloud import (
+    filter_disabled_components_from_dict,
+    is_component_disabled_in_astra_cloud,
+)
 
 if TYPE_CHECKING:
     from lfx.services.settings.service import SettingsService
 
 MIN_MODULE_PARTS = 2
+MIN_MODULE_PARTS_WITH_FILENAME = 4  # Minimum parts needed to have a module filename (lfx.components.type.filename)
 EXPECTED_RESULT_LENGTH = 2  # Expected length of the tuple returned by _process_single_module
 
 
@@ -284,6 +289,8 @@ async def _load_from_index_or_cache(
             if top_level not in modules_dict:
                 modules_dict[top_level] = {}
             modules_dict[top_level].update(components)
+        # Filter disabled components for Astra cloud
+        modules_dict = filter_disabled_components_from_dict(modules_dict)
         await logger.adebug(f"Loaded {len(modules_dict)} component categories from index")
         return modules_dict, "builtin"
 
@@ -303,6 +310,8 @@ async def _load_from_index_or_cache(
                     if top_level not in modules_dict:
                         modules_dict[top_level] = {}
                     modules_dict[top_level].update(components)
+                # Filter disabled components for Astra cloud
+                modules_dict = filter_disabled_components_from_dict(modules_dict)
                 await logger.adebug(f"Loaded {len(modules_dict)} component categories from cache")
                 return modules_dict, "cache"
 
@@ -335,11 +344,19 @@ async def _load_components_dynamically(
         if "deactivated" in modname:
             continue
 
-        # If specific modules requested, filter by top-level module name
-        if target_modules:
-            # Extract top-level: "lfx.components.mistral.xyz" -> "mistral"
-            parts = modname.split(".")
-            if len(parts) > MIN_MODULE_PARTS and parts[2].lower() not in target_modules:
+        # Parse module name once for all checks
+        parts = modname.split(".")
+        if len(parts) > MIN_MODULE_PARTS:
+            component_type = parts[2]
+
+            # Skip disabled components when ASTRA_CLOUD_DISABLE_COMPONENT is true
+            if len(parts) >= MIN_MODULE_PARTS_WITH_FILENAME:
+                module_filename = parts[3]
+                if is_component_disabled_in_astra_cloud(component_type.lower(), module_filename):
+                    continue
+
+            # If specific modules requested, filter by top-level module name
+            if target_modules and component_type.lower() not in target_modules:
                 continue
 
         module_names.append(modname)
@@ -549,7 +566,7 @@ def _process_single_module(modname: str) -> tuple[str, dict] | None:
     return (top_level, module_components)
 
 
-async def _determine_loading_strategy(settings_service: "SettingsService") -> dict:
+async def _determine_loading_strategy(settings_service: "SettingsService") -> dict[str, Any]:
     """Determines and executes the appropriate component loading strategy.
 
     Args:
@@ -577,7 +594,7 @@ async def _determine_loading_strategy(settings_service: "SettingsService") -> di
             f"Built {component_count} custom components from {settings_service.settings.components_path}"
         )
 
-    return component_cache.all_types_dict
+    return component_cache.all_types_dict or {}
 
 
 async def get_and_cache_all_types_dict(

lfx/run/base.py

@@ -3,7 +3,6 @@
 import json
 import re
 import sys
-import tempfile
 import time
 from io import StringIO
 from pathlib import Path
@@ -125,21 +124,16 @@ async def run_flow(
         output_error(error_msg, verbose=verbose)
         raise RunError(error_msg, None)
 
-    temp_file_to_cleanup = None
+    # Store parsed JSON dict for direct loading (avoids temp file round-trip)
+    flow_dict: dict | None = None
 
     if flow_json is not None:
         if verbosity > 0:
             sys.stderr.write("Processing inline JSON content...\n")
         try:
-            json_data = json.loads(flow_json)
+            flow_dict = json.loads(flow_json)
             if verbosity > 0:
                 sys.stderr.write("JSON content is valid\n")
-            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
-                json.dump(json_data, temp_file, indent=2)
-                temp_file_to_cleanup = temp_file.name
-            script_path = Path(temp_file_to_cleanup)
-            if verbosity > 0:
-                sys.stderr.write(f"Created temporary file: {script_path}\n")
         except json.JSONDecodeError as e:
             error_msg = f"Invalid JSON content: {e}"
             output_error(error_msg, verbose=verbose)
@@ -157,15 +151,9 @@ async def run_flow(
                 error_msg = "No content received from stdin"
                 output_error(error_msg, verbose=verbose)
                 raise RunError(error_msg, None)
-            json_data = json.loads(stdin_content)
+            flow_dict = json.loads(stdin_content)
             if verbosity > 0:
                 sys.stderr.write("JSON content from stdin is valid\n")
-            with tempfile.NamedTemporaryFile(mode="w", suffix=".json", delete=False) as temp_file:
-                json.dump(json_data, temp_file, indent=2)
-                temp_file_to_cleanup = temp_file.name
-            script_path = Path(temp_file_to_cleanup)
-            if verbosity > 0:
-                sys.stderr.write(f"Created temporary file from stdin: {script_path}\n")
         except json.JSONDecodeError as e:
             error_msg = f"Invalid JSON content from stdin: {e}"
             output_error(error_msg, verbose=verbose)
@@ -176,39 +164,52 @@ async def run_flow(
             raise RunError(error_msg, e) from e
 
     try:
-        if not script_path or not script_path.exists():
-            error_msg = f"File '{script_path}' does not exist."
-            raise ValueError(error_msg)
-        if not script_path.is_file():
-            error_msg = f"'{script_path}' is not a file."
-            raise ValueError(error_msg)
-        file_extension = script_path.suffix.lower()
-        if file_extension not in [".py", ".json"]:
-            error_msg = f"'{script_path}' must be a .py or .json file."
-            raise ValueError(error_msg)
-        file_type = "Python script" if file_extension == ".py" else "JSON flow"
-        if verbosity > 0:
-            sys.stderr.write(f"Analyzing {file_type}: {script_path}\n")
-        if file_extension == ".py":
-            graph_info = find_graph_variable(script_path)
-            if not graph_info:
-                error_msg = (
-                    "No 'graph' variable found in the script. Expected to find an assignment like: graph = Graph(...)"
-                )
-                raise ValueError(error_msg)
-            if verbosity > 0:
-                sys.stderr.write(f"Found 'graph' variable at line {graph_info['line_number']}\n")
-                sys.stderr.write(f"Type: {graph_info['type']}\n")
-                sys.stderr.write(f"Source: {graph_info['source_line']}\n")
-                sys.stderr.write("Loading and executing script...\n")
-            graph = await load_graph_from_script(script_path)
-        elif file_extension == ".json":
+        # Handle direct JSON dict (from stdin or --flow-json)
+        if flow_dict is not None:
             if verbosity > 0:
-                sys.stderr.write("Valid JSON flow file detected\n")
-                sys.stderr.write("Loading and executing JSON flow\n")
+                sys.stderr.write("Loading graph from JSON content...\n")
             from lfx.load import aload_flow_from_json
 
-            graph = await aload_flow_from_json(script_path, disable_logs=not verbose)
+            graph = await aload_flow_from_json(flow_dict, disable_logs=not verbose)
+        # Handle file path
+        elif script_path is not None:
+            if not script_path.exists():
+                error_msg = f"File '{script_path}' does not exist."
+                raise ValueError(error_msg)
+            if not script_path.is_file():
+                error_msg = f"'{script_path}' is not a file."
+                raise ValueError(error_msg)
+            file_extension = script_path.suffix.lower()
+            if file_extension not in [".py", ".json"]:
+                error_msg = f"'{script_path}' must be a .py or .json file."
+                raise ValueError(error_msg)
+            file_type = "Python script" if file_extension == ".py" else "JSON flow"
+            if verbosity > 0:
+                sys.stderr.write(f"Analyzing {file_type}: {script_path}\n")
+            if file_extension == ".py":
+                graph_info = find_graph_variable(script_path)
+                if not graph_info:
+                    error_msg = (
+                        "No 'graph' variable found in the script. "
+                        "Expected to find an assignment like: graph = Graph(...)"
+                    )
+                    raise ValueError(error_msg)
+                if verbosity > 0:
+                    sys.stderr.write(f"Found 'graph' variable at line {graph_info['line_number']}\n")
+                    sys.stderr.write(f"Type: {graph_info['type']}\n")
+                    sys.stderr.write(f"Source: {graph_info['source_line']}\n")
+                    sys.stderr.write("Loading and executing script...\n")
+                graph = await load_graph_from_script(script_path)
+            else:  # .json file
+                if verbosity > 0:
+                    sys.stderr.write("Valid JSON flow file detected\n")
+                    sys.stderr.write("Loading and executing JSON flow\n")
+                from lfx.load import aload_flow_from_json
+
+                graph = await aload_flow_from_json(script_path, disable_logs=not verbose)
+        else:
+            error_msg = "No input source provided"
+            raise ValueError(error_msg)
 
         # Inject global variables into graph context
         if global_variables:
@@ -244,12 +245,6 @@ async def run_flow(
 
         error_msg = f"Failed to load graph. {e}"
         output_error(error_msg, verbose=verbose, exception=e)
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
         raise RunError(error_msg, e) from e
 
     inputs = InputValueRequest(input_value=final_input_value) if final_input_value else None
@@ -285,13 +280,6 @@ async def run_flow(
                 for error in validation_errors:
                     logger.debug(f"Validation error: {error}")
                 output_error(error_details, verbose=verbose)
-            if temp_file_to_cleanup:
-                try:
-                    Path(temp_file_to_cleanup).unlink()
-                    logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-                except OSError:
-                    pass
-            if validation_errors:
                 raise RunError(error_details, None)
             logger.info("Global variable validation passed")
         else:
@@ -308,12 +296,6 @@ async def run_flow(
 
         error_msg = f"Failed to prepare graph: {e}"
         output_error(error_msg, verbose=verbose, exception=e)
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
         raise RunError(error_msg, e) from e
 
     logger.info("Executing graph...")
@@ -426,12 +408,6 @@ async def run_flow(
 
             logger.exception("Failed to execute graph - full traceback:")
 
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
         sys.stdout = original_stdout
         sys.stderr = original_stderr
         error_msg = f"Failed to execute graph: {e}"
@@ -440,12 +416,6 @@ async def run_flow(
     finally:
         sys.stdout = original_stdout
         sys.stderr = original_stderr
-        if temp_file_to_cleanup:
-            try:
-                Path(temp_file_to_cleanup).unlink()
-                logger.info(f"Cleaned up temporary file: {temp_file_to_cleanup}")
-            except OSError:
-                pass
 
     execution_end_time = time.time() if timing else None
 

lfx/schema/__init__.py

@@ -1,9 +1,12 @@
 """Schema modules for lfx package."""
 
 __all__ = [
+    "ComponentOutput",
     "Data",
     "DataFrame",
+    "ErrorDetail",
     "InputValue",
+    "JobStatus",
     "Message",
     "OpenAIErrorResponse",
     "OpenAIResponsesRequest",
@@ -11,6 +14,13 @@ __all__ = [
     "OpenAIResponsesStreamChunk",
     "Tweaks",
     "UUIDstr",
+    "WorkflowExecutionRequest",
+    "WorkflowExecutionResponse",
+    "WorkflowJobResponse",
+    "WorkflowStatusResponse",
+    "WorkflowStopRequest",
+    "WorkflowStopResponse",
+    "WorkflowStreamEvent",
     "dotdict",
 ]
 
@@ -61,6 +71,46 @@ def __getattr__(name: str):
         from .openai_responses_schemas import OpenAIErrorResponse
 
         return OpenAIErrorResponse
+    if name == "WorkflowExecutionRequest":
+        from .workflow import WorkflowExecutionRequest
+
+        return WorkflowExecutionRequest
+    if name == "WorkflowExecutionResponse":
+        from .workflow import WorkflowExecutionResponse
+
+        return WorkflowExecutionResponse
+    if name == "WorkflowJobResponse":
+        from .workflow import WorkflowJobResponse
+
+        return WorkflowJobResponse
+    if name == "WorkflowStreamEvent":
+        from .workflow import WorkflowStreamEvent
+
+        return WorkflowStreamEvent
+    if name == "WorkflowStatusResponse":
+        from .workflow import WorkflowStatusResponse
+
+        return WorkflowStatusResponse
+    if name == "WorkflowStopRequest":
+        from .workflow import WorkflowStopRequest
+
+        return WorkflowStopRequest
+    if name == "WorkflowStopResponse":
+        from .workflow import WorkflowStopResponse
+
+        return WorkflowStopResponse
+    if name == "JobStatus":
+        from .workflow import JobStatus
+
+        return JobStatus
+    if name == "ErrorDetail":
+        from .workflow import ErrorDetail
+
+        return ErrorDetail
+    if name == "ComponentOutput":
+        from .workflow import ComponentOutput
+
+        return ComponentOutput
 
     msg = f"module '{__name__}' has no attribute '{name}'"
     raise AttributeError(msg)