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

lfx/cli/commands.py

@@ -6,10 +6,12 @@ import json
 import os
 import sys
 import tempfile
+from functools import partial
 from pathlib import Path
 
 import typer
 import uvicorn
+from asyncer import syncify
 from dotenv import load_dotenv
 from rich.console import Console
 from rich.panel import Panel
@@ -32,7 +34,8 @@ console = Console()
 API_KEY_MASK_LENGTH = 8
 
 
-def serve_command(
+@partial(syncify, raise_sync_error=False)
+async def serve_command(
     script_path: str | None = typer.Argument(
         None,
         help=(
@@ -201,12 +204,12 @@ def serve_command(
             raise typer.Exit(1)
 
         if resolved_path.suffix == ".json":
-            graph = load_graph_from_path(resolved_path, resolved_path.suffix, verbose_print, verbose=verbose)
+            graph = await load_graph_from_path(resolved_path, resolved_path.suffix, verbose_print, verbose=verbose)
         elif resolved_path.suffix == ".py":
             verbose_print("Loading graph from Python script...")
             from lfx.cli.script_loader import load_graph_from_script
 
-            graph = load_graph_from_script(resolved_path)
+            graph = await load_graph_from_script(resolved_path)
             verbose_print("✓ Graph loaded from Python script")
         else:
             err_msg = "Error: Only JSON flow files (.json) or Python scripts (.py) are supported. "

lfx/cli/common.py

@@ -224,7 +224,7 @@ def validate_script_path(script_path: Path | str, verbose_print) -> tuple[str, P
     return file_extension, script_path
 
 
-def load_graph_from_path(script_path: Path, file_extension: str, verbose_print, *, verbose: bool = False):
+async def load_graph_from_path(script_path: Path, file_extension: str, verbose_print, *, verbose: bool = False):
     """Load a graph from a Python script or JSON file.
 
     Args:
@@ -259,7 +259,7 @@ def load_graph_from_path(script_path: Path, file_extension: str, verbose_print,
                 raise ValueError(error_msg)
 
             verbose_print("Loading graph...")
-            graph = load_graph_from_script(script_path)
+            graph = await load_graph_from_script(script_path)
         else:  # .json
             verbose_print("Loading JSON flow...")
             graph = load_flow_from_json(script_path, disable_logs=not verbose)

lfx/cli/run.py

@@ -227,7 +227,7 @@ async def run(
                 typer.echo(f"Type: {graph_info['type']}", file=sys.stderr)
                 typer.echo(f"Source: {graph_info['source_line']}", file=sys.stderr)
                 typer.echo("Loading and executing script...", file=sys.stderr)
-            graph = load_graph_from_script(script_path)
+            graph = await load_graph_from_script(script_path)
         elif file_extension == ".json":
             if verbosity > 0:
                 typer.echo("Valid JSON flow file detected", file=sys.stderr)

lfx/cli/script_loader.py

@@ -6,6 +6,7 @@ containing LFX graph variables.
 
 import ast
 import importlib.util
+import inspect
 import json
 import sys
 from contextlib import contextmanager
@@ -71,26 +72,39 @@ def _validate_graph_instance(graph_obj: Any) -> Graph:
     return graph_obj
 
 
-def load_graph_from_script(script_path: Path) -> Graph:
-    """Load and execute a Python script to extract the 'graph' variable.
+async def load_graph_from_script(script_path: Path) -> Graph:
+    """Load and execute a Python script to extract the 'graph' variable or call 'get_graph' function.
 
     Args:
         script_path (Path): Path to the Python script file
 
     Returns:
-        dict: Information about the loaded graph variable including the graph object itself
+        Graph: The loaded and validated graph instance
     """
     try:
         # Load the module
         module = _load_module_from_script(script_path)
 
-        # Check if 'graph' variable exists
-        if not hasattr(module, "graph"):
-            msg = "No 'graph' variable found in the executed script"
+        graph_obj = None
+
+        # First, try to get graph from 'get_graph' function (preferred for async code)
+        if hasattr(module, "get_graph") and callable(module.get_graph):
+            get_graph_func = module.get_graph
+
+            # Check if get_graph is async and handle accordingly
+            if inspect.iscoroutinefunction(get_graph_func):
+                graph_obj = await get_graph_func()
+            else:
+                graph_obj = get_graph_func()
+
+        # Fallback to 'graph' variable for backward compatibility
+        elif hasattr(module, "graph"):
+            graph_obj = module.graph
+
+        if graph_obj is None:
+            msg = "No 'graph' variable or 'get_graph()' function found in the executed script"
             raise ValueError(msg)
 
-        # Extract graph information
-        graph_obj = module.graph
         return _validate_graph_instance(graph_obj)
 
     except (
@@ -178,13 +192,13 @@ def extract_structured_result(results: list, *, extract_text: bool = True) -> di
 
 
 def find_graph_variable(script_path: Path) -> dict | None:
-    """Parse a Python script and find the 'graph' variable assignment.
+    """Parse a Python script and find the 'graph' variable assignment or 'get_graph' function.
 
     Args:
         script_path (Path): Path to the Python script file
 
     Returns:
-        dict | None: Information about the graph variable if found, None otherwise
+        dict | None: Information about the graph variable or get_graph function if found, None otherwise
     """
     try:
         with script_path.open(encoding="utf-8") as f:
@@ -193,8 +207,36 @@ def find_graph_variable(script_path: Path) -> dict | None:
         # Parse the script using AST
         tree = ast.parse(content)
 
-        # Look for assignments to 'graph' variable
+        # Look for 'get_graph' function definitions (preferred) or 'graph' variable assignments
         for node in ast.walk(tree):
+            # Check for get_graph function definition
+            if isinstance(node, ast.FunctionDef) and node.name == "get_graph":
+                line_number = node.lineno
+                is_async = isinstance(node, ast.AsyncFunctionDef)
+
+                return {
+                    "line_number": line_number,
+                    "type": "function_definition",
+                    "function": "get_graph",
+                    "is_async": is_async,
+                    "arg_count": len(node.args.args),
+                    "source_line": content.split("\n")[line_number - 1].strip(),
+                }
+
+            # Check for async get_graph function definition
+            if isinstance(node, ast.AsyncFunctionDef) and node.name == "get_graph":
+                line_number = node.lineno
+
+                return {
+                    "line_number": line_number,
+                    "type": "function_definition",
+                    "function": "get_graph",
+                    "is_async": True,
+                    "arg_count": len(node.args.args),
+                    "source_line": content.split("\n")[line_number - 1].strip(),
+                }
+
+            # Fallback: look for assignments to 'graph' variable
             if isinstance(node, ast.Assign):
                 # Check if any target is named 'graph'
                 for target in node.targets:

lfx/components/Notion/create_page.py

@@ -14,7 +14,7 @@ from lfx.schema.data import Data
 class NotionPageCreator(LCToolComponent):
     display_name: str = "Create Page "
     description: str = "A component for creating Notion pages."
-    documentation: str = "https://docs.langflow.org/integrations/notion/page-create"
+    documentation: str = "https://docs.langflow.org/bundles-notion"
     icon = "NotionDirectoryLoader"
 
     inputs = [

lfx/components/Notion/list_database_properties.py

@@ -12,7 +12,7 @@ from lfx.schema.data import Data
 class NotionDatabaseProperties(LCToolComponent):
     display_name: str = "List Database Properties "
     description: str = "Retrieve properties of a Notion database."
-    documentation: str = "https://docs.langflow.org/integrations/notion/list-database-properties"
+    documentation: str = "https://docs.langflow.org/bundles-notion"
     icon = "NotionDirectoryLoader"
 
     inputs = [

lfx/components/Notion/list_pages.py

@@ -21,7 +21,7 @@ class NotionListPages(LCToolComponent):
         '{"filter": {"property": "Status", "select": {"equals": "Done"}}, '
         '"sorts": [{"timestamp": "created_time", "direction": "descending"}]}'
     )
-    documentation: str = "https://docs.langflow.org/integrations/notion/list-pages"
+    documentation: str = "https://docs.langflow.org/bundles-notion"
     icon = "NotionDirectoryLoader"
 
     inputs = [

lfx/components/Notion/list_users.py

@@ -11,7 +11,7 @@ from lfx.schema.data import Data
 class NotionUserList(LCToolComponent):
     display_name = "List Users "
     description = "Retrieve users from Notion."
-    documentation = "https://docs.langflow.org/integrations/notion/list-users"
+    documentation = "https://docs.langflow.org/bundles-notion"
     icon = "NotionDirectoryLoader"
 
     inputs = [

lfx/components/Notion/page_content_viewer.py

@@ -12,7 +12,7 @@ from lfx.schema.data import Data
 class NotionPageContent(LCToolComponent):
     display_name = "Page Content Viewer "
     description = "Retrieve the content of a Notion page as plain text."
-    documentation = "https://docs.langflow.org/integrations/notion/page-content-viewer"
+    documentation = "https://docs.langflow.org/bundles-notion"
     icon = "NotionDirectoryLoader"
 
     inputs = [

lfx/components/Notion/search.py

@@ -13,7 +13,7 @@ from lfx.schema.data import Data
 class NotionSearch(LCToolComponent):
     display_name: str = "Search "
     description: str = "Searches all pages and databases that have been shared with an integration."
-    documentation: str = "https://docs.langflow.org/integrations/notion/search"
+    documentation: str = "https://docs.langflow.org/bundles-notion"
     icon = "NotionDirectoryLoader"
 
     inputs = [

lfx/components/Notion/update_page_property.py

@@ -15,7 +15,7 @@ from lfx.schema.data import Data
 class NotionPageUpdate(LCToolComponent):
     display_name: str = "Update Page Property "
     description: str = "Update the properties of a Notion page."
-    documentation: str = "https://docs.langflow.org/integrations/notion/page-update"
+    documentation: str = "https://docs.langflow.org/bundles-notion"
     icon = "NotionDirectoryLoader"
 
     inputs = [

lfx/components/__init__.py

@@ -10,8 +10,8 @@ if TYPE_CHECKING:
         FAISS,
         Notion,
         agentql,
-        agents,
         aiml,
+        altk,
         amazon,
         anthropic,
         apify,
@@ -31,6 +31,7 @@ if TYPE_CHECKING:
         confluence,
         couchbase,
         crewai,
+        cuga,
         custom_component,
         data,
         datastax,
@@ -64,6 +65,7 @@ if TYPE_CHECKING:
         milvus,
         mistral,
         models,
+        models_and_agents,
         mongodb,
         needle,
         notdiamond,
@@ -111,8 +113,8 @@ if TYPE_CHECKING:
 _dynamic_imports = {
     # Category modules (existing functionality)
     "agentql": "__module__",
-    "agents": "__module__",
     "aiml": "__module__",
+    "altk": "__module__",
     "amazon": "__module__",
     "anthropic": "__module__",
     "apify": "__module__",
@@ -132,6 +134,7 @@ _dynamic_imports = {
     "confluence": "__module__",
     "couchbase": "__module__",
     "crewai": "__module__",
+    "cuga": "__module__",
     "custom_component": "__module__",
     "data": "__module__",
     "datastax": "__module__",
@@ -166,6 +169,7 @@ _dynamic_imports = {
     "milvus": "__module__",
     "mistral": "__module__",
     "models": "__module__",
+    "models_and_agents": "__module__",
     "mongodb": "__module__",
     "needle": "__module__",
     "notdiamond": "__module__",
@@ -242,8 +246,8 @@ __all__ = [
     "FAISS",
     "Notion",
     "agentql",
-    "agents",
     "aiml",
+    "altk",
     "amazon",
     "anthropic",
     "apify",
@@ -263,6 +267,7 @@ __all__ = [
     "confluence",
     "couchbase",
     "crewai",
+    "cuga",
     "custom_component",
     "data",
     "datastax",
@@ -296,6 +301,7 @@ __all__ = [
     "milvus",
     "mistral",
     "models",
+    "models_and_agents",
     "mongodb",
     "needle",
     "notdiamond",
@@ -382,8 +388,16 @@ def __getattr__(attr_name: str) -> Any:
         elif "." in module_path:
             # This is a component import (e.g., components.AgentComponent -> agents.agent)
             module_name, component_file = module_path.split(".", 1)
-            # Import the specific component from its module
-            result = import_mod(attr_name, component_file, f"{__spec__.parent}.{module_name}")
+            # Check if this is an alias module (data, helpers, logic, models)
+            # These modules forward to other modules, so we need to import directly from the module
+            # instead of trying to import from a submodule that doesn't exist
+            if module_name in ("data", "helpers", "logic", "models"):
+                # For alias modules, import the module and get the component directly
+                alias_module = import_mod(module_name, "__module__", __spec__.parent)
+                result = getattr(alias_module, attr_name)
+            else:
+                # Import the specific component from its module
+                result = import_mod(attr_name, component_file, f"{__spec__.parent}.{module_name}")
         else:
             # Fallback to regular import
             result = import_mod(attr_name, module_path, __spec__.parent)

lfx/components/{agents → altk}/__init__.py

@@ -5,23 +5,19 @@ from typing import TYPE_CHECKING, Any
 from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from lfx.components.agents.agent import AgentComponent
-    from lfx.components.agents.altk_agent import ALTKAgentComponent
-    from lfx.components.agents.cuga_agent import CugaComponent
-    from lfx.components.agents.mcp_component import MCPToolsComponent
+    from .altk_agent import ALTKAgentComponent
 
 _dynamic_imports = {
-    "AgentComponent": "agent",
-    "CugaComponent": "cuga_agent",
-    "MCPToolsComponent": "mcp_component",
     "ALTKAgentComponent": "altk_agent",
 }
 
-__all__ = ["ALTKAgentComponent", "AgentComponent", "CugaComponent", "MCPToolsComponent"]
+__all__ = [
+    "ALTKAgentComponent",
+]
 
 
 def __getattr__(attr_name: str) -> Any:
-    """Lazily import agent components on attribute access."""
+    """Lazily import altk components on attribute access."""
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)

lfx/components/altk/altk_agent.py

@@ -0,0 +1,193 @@
+"""ALTK Agent Component that combines pre-tool validation and post-tool processing capabilities."""
+
+from lfx.base.agents.altk_base_agent import ALTKBaseAgentComponent
+from lfx.base.agents.altk_tool_wrappers import (
+    PostToolProcessingWrapper,
+    PreToolValidationWrapper,
+)
+from lfx.base.models.model_input_constants import MODEL_PROVIDERS_DICT, MODELS_METADATA
+from lfx.components.models_and_agents.memory import MemoryComponent
+from lfx.inputs.inputs import BoolInput
+from lfx.io import DropdownInput, IntInput, Output
+from lfx.log.logger import logger
+
+
+def set_advanced_true(component_input):
+    """Set the advanced flag to True for a component input."""
+    component_input.advanced = True
+    return component_input
+
+
+MODEL_PROVIDERS_LIST = ["Anthropic", "OpenAI"]
+INPUT_NAMES_TO_BE_OVERRIDDEN = ["agent_llm"]
+
+
+def get_parent_agent_inputs():
+    return [
+        input_field
+        for input_field in ALTKBaseAgentComponent.inputs
+        if input_field.name not in INPUT_NAMES_TO_BE_OVERRIDDEN
+    ]
+
+
+# === Combined ALTK Agent Component ===
+
+
+class ALTKAgentComponent(ALTKBaseAgentComponent):
+    """ALTK Agent with both pre-tool validation and post-tool processing capabilities.
+
+    This agent combines the functionality of both ALTKAgent and AgentReflection components,
+    implementing a modular pipeline for tool processing that can be extended with
+    additional capabilities in the future.
+    """
+
+    display_name: str = "ALTK Agent"
+    description: str = "Advanced agent with both pre-tool validation and post-tool processing capabilities."
+    documentation: str = "https://docs.langflow.org/bundles-altk"
+    icon = "zap"
+    beta = True
+    name = "ALTK Agent"
+
+    memory_inputs = [set_advanced_true(component_input) for component_input in MemoryComponent().inputs]
+
+    # Filter out json_mode from OpenAI inputs since we handle structured output differently
+    if "OpenAI" in MODEL_PROVIDERS_DICT:
+        openai_inputs_filtered = [
+            input_field
+            for input_field in MODEL_PROVIDERS_DICT["OpenAI"]["inputs"]
+            if not (hasattr(input_field, "name") and input_field.name == "json_mode")
+        ]
+    else:
+        openai_inputs_filtered = []
+
+    inputs = [
+        DropdownInput(
+            name="agent_llm",
+            display_name="Model Provider",
+            info="The provider of the language model that the agent will use to generate responses.",
+            options=[*MODEL_PROVIDERS_LIST],
+            value="OpenAI",
+            real_time_refresh=True,
+            refresh_button=False,
+            input_types=[],
+            options_metadata=[MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA],
+        ),
+        *get_parent_agent_inputs(),
+        BoolInput(
+            name="enable_tool_validation",
+            display_name="Tool Validation",
+            info="Validates tool calls using SPARC before execution.",
+            value=True,
+        ),
+        BoolInput(
+            name="enable_post_tool_reflection",
+            display_name="Post Tool JSON Processing",
+            info="Processes tool output through JSON analysis.",
+            value=True,
+        ),
+        IntInput(
+            name="response_processing_size_threshold",
+            display_name="Response Processing Size Threshold",
+            value=100,
+            info="Tool output is post-processed only if response exceeds this character threshold.",
+            advanced=True,
+        ),
+    ]
+    outputs = [
+        Output(name="response", display_name="Response", method="message_response"),
+    ]
+
+    def configure_tool_pipeline(self) -> None:
+        """Configure the tool pipeline with wrappers based on enabled features."""
+        wrappers = []
+
+        # Add post-tool processing first (innermost wrapper)
+        if self.enable_post_tool_reflection:
+            logger.info("Enabling Post-Tool Processing Wrapper!")
+            post_processor = PostToolProcessingWrapper(
+                response_processing_size_threshold=self.response_processing_size_threshold
+            )
+            wrappers.append(post_processor)
+
+        # Add pre-tool validation last (outermost wrapper)
+        if self.enable_tool_validation:
+            logger.info("Enabling Pre-Tool Validation Wrapper!")
+            pre_validator = PreToolValidationWrapper()
+            wrappers.append(pre_validator)
+
+        self.pipeline_manager.configure_wrappers(wrappers)
+
+    def update_runnable_instance(self, agent, runnable, tools):
+        """Override to add tool specs update for validation wrappers."""
+        # Get context info (copied from parent)
+        user_query = self.get_user_query()
+        conversation_context = self.build_conversation_context()
+
+        # Initialize pipeline (this ensures configure_tool_pipeline is called)
+        self._initialize_tool_pipeline()
+
+        # Update tool specs for validation wrappers BEFORE processing
+        for wrapper in self.pipeline_manager.wrappers:
+            if isinstance(wrapper, PreToolValidationWrapper) and tools:
+                wrapper.tool_specs = wrapper.convert_langchain_tools_to_sparc_tool_specs_format(tools)
+
+        # Process tools with updated specs
+        processed_tools = self.pipeline_manager.process_tools(
+            list(tools or []),
+            agent=agent,
+            user_query=user_query,
+            conversation_context=conversation_context,
+        )
+
+        runnable.tools = processed_tools
+        return runnable
+
+    def __init__(self, **kwargs):
+        """Initialize ALTK agent with input normalization for Data.to_lc_message() inconsistencies."""
+        super().__init__(**kwargs)
+
+        # If input_value uses Data.to_lc_message(), wrap it to provide consistent content
+        if hasattr(self.input_value, "to_lc_message") and callable(self.input_value.to_lc_message):
+            self.input_value = self._create_normalized_input_proxy(self.input_value)
+
+    def _create_normalized_input_proxy(self, original_input):
+        """Create a proxy that normalizes to_lc_message() content format."""
+
+        class NormalizedInputProxy:
+            def __init__(self, original):
+                self._original = original
+
+            def __getattr__(self, name):
+                if name == "to_lc_message":
+                    return self._normalized_to_lc_message
+                return getattr(self._original, name)
+
+            def _normalized_to_lc_message(self):
+                """Return a message with normalized string content."""
+                original_msg = self._original.to_lc_message()
+
+                # If content is in list format, normalize it to string
+                if hasattr(original_msg, "content") and isinstance(original_msg.content, list):
+                    from langchain_core.messages import AIMessage, HumanMessage
+
+                    from lfx.base.agents.altk_base_agent import (
+                        normalize_message_content,
+                    )
+
+                    normalized_content = normalize_message_content(original_msg)
+
+                    # Create new message with string content
+                    if isinstance(original_msg, HumanMessage):
+                        return HumanMessage(content=normalized_content)
+                    return AIMessage(content=normalized_content)
+
+                # Return original if already string format
+                return original_msg
+
+            def __str__(self):
+                return str(self._original)
+
+            def __repr__(self):
+                return f"NormalizedInputProxy({self._original!r})"
+
+        return NormalizedInputProxy(original_input)

lfx/components/apify/apify_actor.py

@@ -22,7 +22,7 @@ class ApifyActorsComponent(Component):
         "Use Apify Actors to extract data from hundreds of places fast. "
         "This component can be used in a flow to retrieve data or as a tool with an agent."
     )
-    documentation: str = "http://docs.langflow.org/integrations-apify"
+    documentation: str = "https://docs.langflow.org/bundles-apify"
     icon = "Apify"
     name = "ApifyActors"