lfx-nightly 0.2.0.dev41__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

lfx/graph/graph/base.py

@@ -15,6 +15,9 @@ from functools import partial
 from itertools import chain
 from typing import TYPE_CHECKING, Any, cast
 
+from ag_ui.core import RunFinishedEvent, RunStartedEvent
+
+from lfx.events.observability.lifecycle_events import observable
 from lfx.exceptions.component import ComponentBuildError
 from lfx.graph.edge.base import CycleEdge, Edge
 from lfx.graph.graph.constants import Finish, lazy_load_vertex_dict
@@ -728,6 +731,7 @@ class Graph:
                 raise ValueError(msg)
             vertex.update_raw_params(inputs, overwrite=True)
 
+    @observable
     async def _run(
         self,
         *,
@@ -1519,7 +1523,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
@@ -1546,8 +1553,10 @@ class Graph:
                                 vertex.result.used_frozen_result = True
                         except Exception:  # noqa: BLE001
                             logger.debug("Error finalizing build", exc_info=True)
+                            vertex.built = False
                             should_build = True
                     except KeyError:
+                        vertex.built = False
                         should_build = True
 
             if should_build:
@@ -2129,6 +2138,17 @@ class Graph:
         """Get all vertex IDs in the graph."""
         return [vertex.id for vertex in self.vertices]
 
+    def get_terminal_nodes(self) -> list[str]:
+        """Returns vertex IDs that are terminal nodes (not source of any edge).
+
+        Terminal nodes are vertices that have no outgoing edges - they are not
+        listed as source_id in any of the graph's edges.
+
+        Returns:
+            list[str]: List of vertex IDs that are terminal nodes.
+        """
+        return [vertex.id for vertex in self.vertices if not self.successor_map.get(vertex.id, [])]
+
     def sort_vertices(
         self,
         stop_component_id: str | None = None,
@@ -2293,3 +2313,22 @@ class Graph:
             predecessors = [i.id for i in self.get_predecessors(vertex)]
             result |= {vertex_id: {"successors": sucessors, "predecessors": predecessors}}
         return result
+
+    def raw_event_metrics(self, optional_fields: dict | None = None) -> dict:
+        if optional_fields is None:
+            optional_fields = {}
+        import time
+
+        return {"timestamp": time.time(), **optional_fields}
+
+    def before_callback_event(self, *args, **kwargs) -> RunStartedEvent:  # noqa: ARG002
+        metrics = {}
+        if hasattr(self, "raw_event_metrics"):
+            metrics = self.raw_event_metrics({"total_components": len(self.vertices)})
+        return RunStartedEvent(run_id=self._run_id, thread_id=self.flow_id, raw_event=metrics)
+
+    def after_callback_event(self, result: Any = None, *args, **kwargs) -> RunFinishedEvent:  # noqa: ARG002
+        metrics = {}
+        if hasattr(self, "raw_event_metrics"):
+            metrics = self.raw_event_metrics({"total_components": len(self.vertices)})
+        return RunFinishedEvent(run_id=self._run_id, thread_id=self.flow_id, result=None, raw_event=metrics)

lfx/graph/utils.py

@@ -11,7 +11,7 @@ from lfx.schema.data import Data
 from lfx.schema.message import Message
 
 # Database imports removed - lfx should be lightweight
-from lfx.services.deps import get_db_service, get_settings_service
+from lfx.services.deps import get_settings_service
 
 if TYPE_CHECKING:
     from lfx.graph.vertex.base import Vertex
@@ -108,32 +108,65 @@ def _vertex_to_primitive_dict(target: Vertex) -> dict:
 async def log_transaction(
     flow_id: str | UUID,
     source: Vertex,
-    status,
-    target: Vertex | None = None,  # noqa: ARG001
-    error=None,  # noqa: ARG001
+    status: str,
+    target: Vertex | None = None,
+    error: str | Exception | None = None,
+    outputs: dict[str, Any] | None = None,
 ) -> None:
     """Asynchronously logs a transaction record for a vertex in a flow if transaction storage is enabled.
 
-    This is a lightweight implementation that only logs if database service is available.
+    Uses the pluggable TransactionService to log transactions. When running within langflow,
+    the concrete TransactionService implementation persists to the database.
+    When running standalone (lfx only), transactions are not persisted.
+
+    Args:
+        flow_id: The flow ID
+        source: The source vertex (component being executed)
+        status: Transaction status (success/error)
+        target: Optional target vertex (for data transfer logging)
+        error: Optional error information
+        outputs: Optional explicit outputs dict (component execution results)
     """
     try:
-        settings_service = get_settings_service()
-        if not settings_service or not getattr(settings_service.settings, "transactions_storage_enabled", False):
+        # Guard against null source
+        if source is None:
             return
 
-        db_service = get_db_service()
-        if db_service is None:
-            logger.debug("Database service not available, skipping transaction logging")
+        # Get the transaction service via dependency injection
+        from lfx.services.deps import get_transaction_service
+
+        transaction_service = get_transaction_service()
+
+        # If no transaction service is available or it's disabled, skip logging
+        if transaction_service is None or not transaction_service.is_enabled():
             return
 
+        # Resolve flow_id
         if not flow_id:
             if source.graph.flow_id:
                 flow_id = source.graph.flow_id
             else:
                 return
 
-        # Log basic transaction info - concrete implementation should be in langflow
-        logger.debug(f"Transaction logged: vertex={source.id}, flow={flow_id}, status={status}")
+        # Convert UUID to string for the service interface
+        flow_id_str = str(flow_id) if isinstance(flow_id, UUID) else flow_id
+
+        # Prepare inputs and outputs
+        inputs = _vertex_to_primitive_dict(source) if source else None
+        target_outputs = _vertex_to_primitive_dict(target) if target else None
+        transaction_outputs = outputs if outputs is not None else target_outputs
+
+        # Log transaction via the service
+        await transaction_service.log_transaction(
+            flow_id=flow_id_str,
+            vertex_id=source.id,
+            inputs=inputs,
+            outputs=transaction_outputs,
+            status=status,
+            target_id=target.id if target else None,
+            error=str(error) if error else None,
+        )
+
     except Exception as exc:  # noqa: BLE001
         logger.debug(f"Error logging transaction: {exc!s}")
 
@@ -143,35 +176,81 @@ async def log_vertex_build(
     flow_id: str | UUID,
     vertex_id: str,
     valid: bool,
-    params: Any,  # noqa: ARG001
-    data: dict | Any,  # noqa: ARG001
-    artifacts: dict | None = None,  # noqa: ARG001
+    params: Any,
+    data: dict | Any,
+    artifacts: dict | None = None,
 ) -> None:
     """Asynchronously logs a vertex build record if vertex build storage is enabled.
 
     This is a lightweight implementation that only logs if database service is available.
+    When running within langflow, it will use langflow's database service to persist the build.
+    When running standalone (lfx only), it will only log debug messages.
     """
     try:
-        settings_service = get_settings_service()
-        if not settings_service or not getattr(settings_service.settings, "vertex_builds_storage_enabled", False):
-            return
+        # Try to use langflow's services if available (when running within langflow)
+        try:
+            from langflow.services.deps import get_db_service as langflow_get_db_service
+            from langflow.services.deps import get_settings_service as langflow_get_settings_service
 
-        db_service = get_db_service()
-        if db_service is None:
-            logger.debug("Database service not available, skipping vertex build logging")
-            return
+            settings_service = langflow_get_settings_service()
+            if not settings_service:
+                return
+            if not getattr(settings_service.settings, "vertex_builds_storage_enabled", False):
+                return
 
-        try:
             if isinstance(flow_id, str):
                 flow_id = UUID(flow_id)
-        except ValueError:
-            logger.debug(f"Invalid flow_id passed to log_vertex_build: {flow_id!r}")
-            return
 
-        # Log basic vertex build info - concrete implementation should be in langflow
-        logger.debug(f"Vertex build logged: vertex={vertex_id}, flow={flow_id}, valid={valid}")
-    except Exception:  # noqa: BLE001
-        logger.debug("Error logging vertex build")
+            from langflow.services.database.models.vertex_builds.crud import (
+                log_vertex_build as crud_log_vertex_build,
+            )
+            from langflow.services.database.models.vertex_builds.model import VertexBuildBase
+
+            # Convert data to dict if it's a pydantic model
+            data_dict = data
+            if hasattr(data, "model_dump"):
+                data_dict = data.model_dump()
+            elif hasattr(data, "dict"):
+                data_dict = data.dict()
+
+            # Convert artifacts to dict if it's a pydantic model
+            artifacts_dict = artifacts
+            if artifacts is not None:
+                if hasattr(artifacts, "model_dump"):
+                    artifacts_dict = artifacts.model_dump()
+                elif hasattr(artifacts, "dict"):
+                    artifacts_dict = artifacts.dict()
+
+            vertex_build = VertexBuildBase(
+                flow_id=flow_id,
+                id=vertex_id,
+                valid=valid,
+                params=str(params) if params else None,
+                data=data_dict,
+                artifacts=artifacts_dict,
+            )
+
+            db_service = langflow_get_db_service()
+            if db_service is None:
+                return
+
+            async with db_service._with_session() as session:  # noqa: SLF001
+                await crud_log_vertex_build(session, vertex_build)
+
+        except ImportError:
+            # Fallback for standalone lfx usage (without langflow)
+            settings_service = get_settings_service()
+            if not settings_service or not getattr(settings_service.settings, "vertex_builds_storage_enabled", False):
+                return
+
+            if isinstance(flow_id, str):
+                flow_id = UUID(flow_id)
+
+            # Log basic vertex build info - concrete implementation is in langflow
+            logger.debug(f"Vertex build logged: vertex={vertex_id}, flow={flow_id}, valid={valid}")
+
+    except Exception as exc:  # noqa: BLE001
+        logger.warning(f"Error logging vertex build: {exc}")
 
 
 def rewrite_file_path(file_path: str):

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
 
@@ -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
@@ -769,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):
@@ -821,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/__init__.py

@@ -17,6 +17,7 @@ from .inputs import (
     McpInput,
     MessageInput,
     MessageTextInput,
+    ModelInput,
     MultilineInput,
     MultilineSecretInput,
     MultiselectInput,
@@ -52,6 +53,7 @@ __all__ = [
     "McpInput",
     "MessageInput",
     "MessageTextInput",
+    "ModelInput",
     "MultilineInput",
     "MultilineSecretInput",
     "MultiselectInput",

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"
@@ -37,6 +38,7 @@ class FieldTypes(str, Enum):
     QUERY = "query"
     TOOLS = "tools"
     MCP = "mcp"
+    MODEL = "model"
 
 
 SerializableFieldTypes = Annotated[FieldTypes, PlainSerializer(lambda v: v.value, return_type=str)]
@@ -136,6 +138,59 @@ class BaseInputMixin(CrossModuleModel, validate_assignment=True):  # type: ignor
         return dump
 
 
+class ModelInputMixin(BaseModel):
+    model_config = ConfigDict(populate_by_name=True)
+    """Mixin for model input fields."""
+    model_name: str | None = None
+    """Name of the model to be used in the input."""
+    model_type: str | None = "language"
+    """Type of model: 'language' or 'embedding'. Defaults to 'language'."""
+    model_options: list[dict[str, Any]] | None = Field(
+        default=None,
+        validation_alias="options",
+        serialization_alias="options",
+    )
+    """List of model options with name, icon, category, provider, and metadata."""
+    temperature: float | None = None
+    """Temperature parameter for model generation."""
+    max_tokens: int | None = None
+    """Maximum tokens for model generation."""
+    limit: int | None = None
+    """Limit for the number of options to display."""
+    external_options: dict[str, Any] | None = None
+    """Dictionary of external options to display below the dropdown options (e.g., 'Connect other models')."""
+
+    @field_validator("model_options", mode="before")
+    @classmethod
+    def normalize_model_options(cls, v):
+        """Convert simple list of model names to list of dicts format.
+
+        Allows passing ['gpt-4o', 'gpt-4o-mini'] which gets converted to:
+        [{'name': 'gpt-4o', ...}, {'name': 'gpt-4o-mini', ...}]
+        """
+        if v is None or not isinstance(v, list):
+            return v
+
+        # If already in dict format, return as-is
+        if all(isinstance(item, dict) for item in v):
+            return v
+
+        # If it's a list of strings, convert to dict format
+        if all(isinstance(item, str) for item in v):
+            # Avoid circular import by importing the module directly (not through package __init__)
+            try:
+                from lfx.base.models.unified_models import normalize_model_names_to_dicts
+
+                return normalize_model_names_to_dicts(v)
+            except Exception:  # noqa: BLE001
+                # Fallback if import or normalization fails
+                # This can happen during module initialization or in test environments
+                return [{"name": item} for item in v]
+
+        # Mixed list or unexpected format, return as-is
+        return v
+
+
 class ToolModeMixin(BaseModel):
     tool_mode: bool = False