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

lfx/components/flow_controls/run_flow.py

@@ -0,0 +1,108 @@
+from datetime import datetime
+from typing import Any
+
+from lfx.base.tools.run_flow import RunFlowBaseComponent
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+
+
+class RunFlowComponent(RunFlowBaseComponent):
+    display_name = "Run Flow"
+    description = (
+        "Executes another flow from within the same project. Can also be used as a tool for agents."
+        " \n **Select a Flow to use the tool mode**"
+    )
+    documentation: str = "https://docs.langflow.org/run-flow"
+    beta = True
+    name = "RunFlow"
+    icon = "Workflow"
+
+    inputs = RunFlowBaseComponent.get_base_inputs()
+    outputs = RunFlowBaseComponent.get_base_outputs()
+
+    async def update_build_config(
+        self,
+        build_config: dotdict,
+        field_value: Any,
+        field_name: str | None = None,
+    ):
+        missing_keys = [key for key in self.default_keys if key not in build_config]
+        for key in missing_keys:
+            if key == "flow_name_selected":
+                build_config[key] = {"options": [], "options_metadata": [], "value": None}
+            elif key == "flow_id_selected":
+                build_config[key] = {"value": None}
+            elif key == "cache_flow":
+                build_config[key] = {"value": False}
+            else:
+                build_config[key] = {}
+        if field_name == "flow_name_selected" and (build_config.get("is_refresh", False) or field_value is None):
+            # refresh button was clicked or componented was initialized, so list the flows
+            options: list[str] = await self.alist_flows_by_flow_folder()
+            build_config["flow_name_selected"]["options"] = [flow.data["name"] for flow in options]
+            build_config["flow_name_selected"]["options_metadata"] = []
+            for flow in options:
+                # populate options_metadata
+                build_config["flow_name_selected"]["options_metadata"].append(
+                    {"id": flow.data["id"], "updated_at": flow.data["updated_at"]}
+                )
+                # update selected flow if it is stale
+                if str(flow.data["id"]) == self.flow_id_selected:
+                    await self.check_and_update_stale_flow(flow, build_config)
+        elif field_name in {"flow_name_selected", "flow_id_selected"} and field_value is not None:
+            # flow was selected by name or id, so get the flow and update the bcfg
+            try:
+                # derive flow id if the field_name is flow_name_selected
+                build_config["flow_id_selected"]["value"] = (
+                    self.get_selected_flow_meta(build_config, "id") or build_config["flow_id_selected"]["value"]
+                )
+                updated_at = self.get_selected_flow_meta(build_config, "updated_at")
+                await self.load_graph_and_update_cfg(
+                    build_config, build_config["flow_id_selected"]["value"], updated_at
+                )
+            except Exception as e:
+                msg = f"Error building graph for flow {field_value}"
+                await logger.aexception(msg)
+                raise RuntimeError(msg) from e
+
+        return build_config
+
+    def get_selected_flow_meta(self, build_config: dotdict, field: str) -> dict:
+        """Get the selected flow's metadata from the build config."""
+        return build_config.get("flow_name_selected", {}).get("selected_metadata", {}).get(field)
+
+    async def load_graph_and_update_cfg(
+        self,
+        build_config: dotdict,
+        flow_id: str,
+        updated_at: str | datetime,
+    ) -> None:
+        """Load a flow's graph and update the build config."""
+        graph = await self.get_graph(
+            flow_id_selected=flow_id,
+            updated_at=self.get_str_isots(updated_at),
+        )
+        self.update_build_config_from_graph(build_config, graph)
+
+    def should_update_stale_flow(self, flow: Data, build_config: dotdict) -> bool:
+        """Check if the flow should be updated."""
+        return (
+            (updated_at := self.get_str_isots(flow.data["updated_at"]))  # true updated_at date just fetched from db
+            and (stale_at := self.get_selected_flow_meta(build_config, "updated_at"))  # outdated date in bcfg
+            and self._parse_timestamp(updated_at) > self._parse_timestamp(stale_at)  # stale flow condition
+        )
+
+    async def check_and_update_stale_flow(self, flow: Data, build_config: dotdict) -> None:
+        """Check if the flow should be updated and update it if necessary."""
+        # TODO: improve contract/return value
+        if self.should_update_stale_flow(flow, build_config):
+            await self.load_graph_and_update_cfg(
+                build_config,
+                flow.data["id"],
+                flow.data["updated_at"],
+            )
+
+    def get_str_isots(self, date: datetime | str) -> str:
+        """Get a string timestamp from a datetime or string."""
+        return date.isoformat() if hasattr(date, "isoformat") else date

lfx/components/glean/glean_search_api.py

@@ -101,7 +101,7 @@ class GleanAPIWrapper(BaseModel):
 class GleanSearchAPIComponent(LCToolComponent):
     display_name: str = "Glean Search API"
     description: str = "Search using Glean's API."
-    documentation: str = "https://docs.langflow.org/Components/components-tools#glean-search-api"
+    documentation: str = "https://docs.langflow.org/bundles-glean"
     icon: str = "Glean"
 
     outputs = [

lfx/components/groq/groq.py

@@ -1,7 +1,7 @@
-import requests
 from pydantic.v1 import SecretStr
 
-from lfx.base.models.groq_constants import GROQ_MODELS, TOOL_CALLING_UNSUPPORTED_GROQ_MODELS, UNSUPPORTED_GROQ_MODELS
+from lfx.base.models.groq_constants import GROQ_MODELS
+from lfx.base.models.groq_model_discovery import get_groq_models
 from lfx.base.models.model import LCModelComponent
 from lfx.field_typing import LanguageModel
 from lfx.field_typing.range_spec import RangeSpec
@@ -52,7 +52,7 @@ class GroqModel(LCModelComponent):
         DropdownInput(
             name="model_name",
             display_name="Model",
-            info="The name of the model to use.",
+            info="The name of the model to use. Add your Groq API key to access additional available models.",
             options=GROQ_MODELS,
             value=GROQ_MODELS[0],
             refresh_button=True,
@@ -71,35 +71,42 @@ class GroqModel(LCModelComponent):
     ]
 
     def get_models(self, *, tool_model_enabled: bool | None = None) -> list[str]:
+        """Get available Groq models using the dynamic discovery system.
+
+        This method uses the groq_model_discovery module which:
+        - Fetches models directly from Groq API
+        - Automatically tests tool calling support
+        - Caches results for 24 hours
+        - Falls back to hardcoded list if API fails
+
+        Args:
+            tool_model_enabled: If True, only return models that support tool calling
+
+        Returns:
+            List of available model IDs
+        """
         try:
-            url = f"{self.base_url}/openai/v1/models"
-            headers = {"Authorization": f"Bearer {self.api_key}", "Content-Type": "application/json"}
+            # Get models with metadata from dynamic discovery system
+            api_key = self.api_key if hasattr(self, "api_key") and self.api_key else None
+            models_metadata = get_groq_models(api_key=api_key)
 
-            response = requests.get(url, headers=headers, timeout=10)
-            response.raise_for_status()
-            model_list = response.json()
+            # Filter out non-LLM models (audio, TTS, guards)
             model_ids = [
-                model["id"] for model in model_list.get("data", []) if model["id"] not in UNSUPPORTED_GROQ_MODELS
+                model_id for model_id, metadata in models_metadata.items() if not metadata.get("not_supported", False)
             ]
-        except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+
+            # Filter by tool calling support if requested
+            if tool_model_enabled:
+                model_ids = [model_id for model_id in model_ids if models_metadata[model_id].get("tool_calling", False)]
+                logger.info(f"Loaded {len(model_ids)} Groq models with tool calling support")
+            else:
+                logger.info(f"Loaded {len(model_ids)} Groq models")
+        except (ValueError, KeyError, TypeError, ImportError) as e:
             logger.exception(f"Error getting model names: {e}")
-            model_ids = GROQ_MODELS
-        if tool_model_enabled:
-            try:
-                from langchain_groq import ChatGroq
-            except ImportError as e:
-                msg = "langchain_groq is not installed. Please install it with `pip install langchain_groq`."
-                raise ImportError(msg) from e
-            for model in model_ids:
-                model_with_tool = ChatGroq(
-                    model=model,
-                    api_key=self.api_key,
-                    base_url=self.base_url,
-                )
-                if not self.supports_tool_calling(model_with_tool) or model in TOOL_CALLING_UNSUPPORTED_GROQ_MODELS:
-                    model_ids.remove(model)
+            # Fallback to hardcoded list from groq_constants.py
+            return GROQ_MODELS
+        else:
             return model_ids
-        return model_ids
 
     def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
         if field_name in {"base_url", "model_name", "tool_model_enabled", "api_key"} and field_value:
@@ -107,13 +114,13 @@ class GroqModel(LCModelComponent):
                 if len(self.api_key) != 0:
                     try:
                         ids = self.get_models(tool_model_enabled=self.tool_model_enabled)
-                    except (ImportError, ValueError, requests.exceptions.RequestException) as e:
+                    except (ValueError, KeyError, TypeError, ImportError) as e:
                         logger.exception(f"Error getting model names: {e}")
                         ids = GROQ_MODELS
                     build_config.setdefault("model_name", {})
                     build_config["model_name"]["options"] = ids
                     build_config["model_name"].setdefault("value", ids[0])
-            except Exception as e:
+            except (ValueError, KeyError, TypeError, AttributeError) as e:
                 msg = f"Error getting model names: {e}"
                 raise ValueError(msg) from e
         return build_config

lfx/components/helpers/__init__.py

@@ -1,5 +1,8 @@
+"""Helpers module - backwards compatibility for moved components."""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
@@ -33,12 +36,111 @@ __all__ = [
     "OutputParserComponent",
 ]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.helpers.current_date
+_redirected_submodules = {
+    "lfx.components.helpers.current_date": "lfx.components.utilities.current_date",
+    "lfx.components.helpers.calculator_core": "lfx.components.utilities.calculator_core",
+    "lfx.components.helpers.id_generator": "lfx.components.utilities.id_generator",
+    "lfx.components.helpers.memory": "lfx.components.models_and_agents.memory",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
 
 def __getattr__(attr_name: str) -> Any:
     """Lazily import helper components on attribute access."""
+    # Handle submodule access for backwards compatibility
+    # e.g., lfx.components.helpers.id_generator -> lfx.components.utilities.id_generator
+    if attr_name == "id_generator":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.id_generator")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "calculator_core":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.calculator_core")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "current_date":
+        from importlib import import_module
+
+        result = import_module("lfx.components.utilities.current_date")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "memory":
+        from importlib import import_module
+
+        result = import_module("lfx.components.models_and_agents.memory")
+        globals()[attr_name] = result
+        return result
+
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)
+
+    # CurrentDateComponent, CalculatorComponent, and IDGeneratorComponent were moved to utilities
+    # Forward them to utilities for backwards compatibility
+    if attr_name in ("CurrentDateComponent", "CalculatorComponent", "IDGeneratorComponent"):
+        from lfx.components import utilities
+
+        result = getattr(utilities, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # MemoryComponent was moved to models_and_agents
+    # Forward it to models_and_agents for backwards compatibility
+    if attr_name == "MemoryComponent":
+        from lfx.components import models_and_agents
+
+        result = getattr(models_and_agents, attr_name)
+        globals()[attr_name] = result
+        return result
+
+    # CreateListComponent, MessageStoreComponent, and OutputParserComponent were moved to processing
+    # Forward them to processing for backwards compatibility
+    if attr_name == "CreateListComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, attr_name)
+        globals()[attr_name] = result
+        return result
+    if attr_name == "MessageStoreComponent":
+        from lfx.components import processing
+
+        result = processing.MessageStoreComponent
+        globals()[attr_name] = result
+        return result
+    if attr_name == "OutputParserComponent":
+        from lfx.components import processing
+
+        result = getattr(processing, attr_name)
+        globals()[attr_name] = result
+        return result
+
     try:
         result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:

lfx/components/ibm/watsonx.py

@@ -197,8 +197,14 @@ class WatsonxAIComponent(LCModelComponent):
             "logit_bias": logit_bias,
         }
 
+        # Pass API key as plain string to avoid SecretStr serialization issues
+        # when model is configured with with_config() or used in batch operations
+        api_key_value = self.api_key
+        if isinstance(api_key_value, SecretStr):
+            api_key_value = api_key_value.get_secret_value()
+
         return ChatWatsonx(
-            apikey=SecretStr(self.api_key).get_secret_value(),
+            apikey=api_key_value,
             url=self.base_url,
             project_id=self.project_id,
             model_id=self.model_name,

lfx/components/input_output/__init__.py

@@ -9,15 +9,17 @@ if TYPE_CHECKING:
     from lfx.components.input_output.chat_output import ChatOutput
     from lfx.components.input_output.text import TextInputComponent
     from lfx.components.input_output.text_output import TextOutputComponent
+    from lfx.components.input_output.webhook import WebhookComponent
 
 _dynamic_imports = {
     "ChatInput": "chat",
     "ChatOutput": "chat_output",
     "TextInputComponent": "text",
     "TextOutputComponent": "text_output",
+    "WebhookComponent": "webhook",
 }
 
-__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent"]
+__all__ = ["ChatInput", "ChatOutput", "TextInputComponent", "TextOutputComponent", "WebhookComponent"]
 
 
 def __getattr__(attr_name: str) -> Any:

lfx/components/input_output/chat.py

@@ -19,7 +19,7 @@ from lfx.utils.constants import (
 class ChatInput(ChatComponent):
     display_name = "Chat Input"
     description = "Get chat inputs from the Playground."
-    documentation: str = "https://docs.langflow.org/components-io#chat-input"
+    documentation: str = "https://docs.langflow.org/chat-input-and-output"
     icon = "MessagesSquare"
     name = "ChatInput"
     minimized = True
@@ -89,15 +89,16 @@ class ChatInput(ChatComponent):
         # Filter out None/empty values
         files = [f for f in files if f is not None and f != ""]
 
+        session_id = self.session_id or self.graph.session_id or ""
         message = await Message.create(
             text=self.input_value,
             sender=self.sender,
             sender_name=self.sender_name,
-            session_id=self.session_id,
+            session_id=session_id,
             context_id=self.context_id,
             files=files,
         )
-        if self.session_id and isinstance(message, Message) and self.should_store_message:
+        if session_id and isinstance(message, Message) and self.should_store_message:
             stored_message = await self.send_message(
                 message,
             )

lfx/components/input_output/chat_output.py

@@ -22,7 +22,7 @@ from lfx.utils.constants import (
 class ChatOutput(ChatComponent):
     display_name = "Chat Output"
     description = "Display a chat message in the Playground."
-    documentation: str = "https://docs.langflow.org/components-io#chat-output"
+    documentation: str = "https://docs.langflow.org/chat-input-and-output"
     icon = "MessagesSquare"
     name = "ChatOutput"
     minimized = True
@@ -117,23 +117,29 @@ class ChatOutput(ChatComponent):
         source, _, display_name, source_id = self.get_properties_from_source_component()
 
         # Create or use existing Message object
-        if isinstance(self.input_value, Message):
+        if isinstance(self.input_value, Message) and not self.is_connected_to_chat_input():
             message = self.input_value
             # Update message properties
             message.text = text
+            # Preserve existing session_id from the incoming message if it exists
+            existing_session_id = message.session_id
         else:
             message = Message(text=text)
+            existing_session_id = None
 
         # Set message properties
         message.sender = self.sender
         message.sender_name = self.sender_name
-        message.session_id = self.session_id
+        # Preserve session_id from incoming message, or use component/graph session_id
+        message.session_id = (
+            self.session_id or existing_session_id or (self.graph.session_id if hasattr(self, "graph") else None) or ""
+        )
         message.context_id = self.context_id
         message.flow_id = self.graph.flow_id if hasattr(self, "graph") else None
         message.properties.source = self._build_source(source_id, display_name, source)
 
         # Store message if needed
-        if self.session_id and self.should_store_message:
+        if message.session_id and self.should_store_message:
             stored_message = await self.send_message(message)
             self.message.value = stored_message
             message = stored_message

lfx/components/input_output/text.py

@@ -6,7 +6,7 @@ from lfx.schema.message import Message
 class TextInputComponent(TextComponent):
     display_name = "Text Input"
     description = "Get user text inputs."
-    documentation: str = "https://docs.langflow.org/components-io#text-input"
+    documentation: str = "https://docs.langflow.org/text-input-and-output"
     icon = "type"
     name = "TextInput"
 

lfx/components/input_output/text_output.py

@@ -6,7 +6,7 @@ from lfx.schema.message import Message
 class TextOutputComponent(TextComponent):
     display_name = "Text Output"
     description = "Sends text output via API."
-    documentation: str = "https://docs.langflow.org/components-io#text-output"
+    documentation: str = "https://docs.langflow.org/text-input-and-output"
     icon = "type"
     name = "TextOutput"
 

lfx/components/{data → input_output}/webhook.py

@@ -7,7 +7,7 @@ from lfx.schema.data import Data
 
 class WebhookComponent(Component):
     display_name = "Webhook"
-    documentation: str = "https://docs.langflow.org/components-data#webhook"
+    documentation: str = "https://docs.langflow.org/component-webhook"
     name = "Webhook"
     icon = "webhook"
 

lfx/components/knowledge_bases/__init__.py

@@ -1,12 +1,19 @@
+"""Knowledge bases module - backwards compatibility alias for files_and_knowledge.
+
+This module provides backwards compatibility by forwarding all imports
+to files_and_knowledge where the actual knowledge base components are located.
+"""
+
 from __future__ import annotations
 
+import sys
 from typing import TYPE_CHECKING, Any
 
 from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from lfx.components.knowledge_bases.ingestion import KnowledgeIngestionComponent
-    from lfx.components.knowledge_bases.retrieval import KnowledgeRetrievalComponent
+    from lfx.components.files_and_knowledge.ingestion import KnowledgeIngestionComponent
+    from lfx.components.files_and_knowledge.retrieval import KnowledgeRetrievalComponent
 
 _dynamic_imports = {
     "KnowledgeIngestionComponent": "ingestion",
@@ -15,14 +22,61 @@ _dynamic_imports = {
 
 __all__ = ["KnowledgeIngestionComponent", "KnowledgeRetrievalComponent"]
 
+# Register redirected submodules in sys.modules for direct importlib.import_module() calls
+# This allows imports like: import lfx.components.knowledge_bases.ingestion
+_redirected_submodules = {
+    "lfx.components.knowledge_bases.ingestion": "lfx.components.files_and_knowledge.ingestion",
+    "lfx.components.knowledge_bases.retrieval": "lfx.components.files_and_knowledge.retrieval",
+}
+
+for old_path, new_path in _redirected_submodules.items():
+    if old_path not in sys.modules:
+        # Use a lazy loader that imports the actual module when accessed
+        class _RedirectedModule:
+            def __init__(self, target_path: str, original_path: str):
+                self._target_path = target_path
+                self._original_path = original_path
+                self._module = None
+
+            def __getattr__(self, name: str) -> Any:
+                if self._module is None:
+                    from importlib import import_module
+
+                    self._module = import_module(self._target_path)
+                    # Also register under the original path for future imports
+                    sys.modules[self._original_path] = self._module
+                return getattr(self._module, name)
+
+            def __repr__(self) -> str:
+                return f"<redirected module '{self._original_path}' -> '{self._target_path}'>"
+
+        sys.modules[old_path] = _RedirectedModule(new_path, old_path)
+
 
 def __getattr__(attr_name: str) -> Any:
-    """Lazily import input/output components on attribute access."""
+    """Forward attribute access to files_and_knowledge components."""
+    # Handle submodule access for backwards compatibility
+    if attr_name == "ingestion":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.ingestion")
+        globals()[attr_name] = result
+        return result
+    if attr_name == "retrieval":
+        from importlib import import_module
+
+        result = import_module("lfx.components.files_and_knowledge.retrieval")
+        globals()[attr_name] = result
+        return result
+
     if attr_name not in _dynamic_imports:
         msg = f"module '{__name__}' has no attribute '{attr_name}'"
         raise AttributeError(msg)
+
+    # Import from files_and_knowledge using the correct package path
+    package = "lfx.components.files_and_knowledge"
     try:
-        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+        result = import_mod(attr_name, _dynamic_imports[attr_name], package)
     except (ModuleNotFoundError, ImportError, AttributeError) as e:
         msg = f"Could not import '{attr_name}' from '{__name__}': {e}"
         raise AttributeError(msg) from e
@@ -31,4 +85,5 @@ def __getattr__(attr_name: str) -> Any:
 
 
 def __dir__() -> list[str]:
+    """Return directory of available components."""
     return list(__all__)

lfx/components/langchain_utilities/character.py

@@ -10,7 +10,7 @@ from lfx.utils.util import unescape_string
 class CharacterTextSplitterComponent(LCTextSplitterComponent):
     display_name = "Character Text Splitter"
     description = "Split text by number of characters."
-    documentation = "https://docs.langflow.org/components/text-splitters#charactertextsplitter"
+    documentation = "https://docs.langflow.org/bundles-langchain"
     name = "CharacterTextSplitter"
     icon = "LangChain"