lfx-nightly 0.2.0.dev26__py3-none-any.whl → 0.2.1.dev7__py3-none-any.whl

lfx/components/llm_operations/llm_conditional_router.py

@@ -1,7 +1,21 @@
 from typing import Any
 
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_llm,
+    update_model_options_in_build_config,
+)
 from lfx.custom import Component
-from lfx.io import BoolInput, HandleInput, MessageInput, MessageTextInput, MultilineInput, Output, TableInput
+from lfx.io import (
+    BoolInput,
+    MessageInput,
+    MessageTextInput,
+    ModelInput,
+    MultilineInput,
+    Output,
+    SecretStrInput,
+    TableInput,
+)
 from lfx.schema.message import Message
 from lfx.schema.table import EditMode
 
@@ -17,13 +31,20 @@ class SmartRouterComponent(Component):
         self._matched_category = None
 
     inputs = [
-        HandleInput(
-            name="llm",
+        ModelInput(
+            name="model",
             display_name="Language Model",
-            info="LLM to use for categorization.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MessageTextInput(
             name="input_text",
             display_name="Input",
@@ -111,6 +132,17 @@ class SmartRouterComponent(Component):
 
     outputs: list[Output] = []
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def update_outputs(self, frontend_node: dict, field_name: str, field_value: Any) -> dict:
         """Create a dynamic output for each category in the categories table."""
         if field_name in {"routes", "enable_else_output"}:
@@ -153,7 +185,7 @@ class SmartRouterComponent(Component):
 
         # Find the matching category using LLM-based categorization
         matched_category = None
-        llm = getattr(self, "llm", None)
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
 
         if llm and categories:
             # Create prompt for categorization
@@ -315,7 +347,7 @@ class SmartRouterComponent(Component):
 
         # Check if any category matches using LLM categorization
         has_match = False
-        llm = getattr(self, "llm", None)
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
 
         if llm and categories:
             try:

lfx/components/llm_operations/structured_output.py

@@ -2,13 +2,19 @@ from pydantic import BaseModel, Field, create_model
 from trustcall import create_extractor
 
 from lfx.base.models.chat_result import get_chat_result
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_llm,
+    update_model_options_in_build_config,
+)
 from lfx.custom.custom_component.component import Component
 from lfx.helpers.base_model import build_model_from_schema
 from lfx.io import (
-    HandleInput,
     MessageTextInput,
+    ModelInput,
     MultilineInput,
     Output,
+    SecretStrInput,
     TableInput,
 )
 from lfx.log.logger import logger
@@ -25,13 +31,20 @@ class StructuredOutputComponent(Component):
     icon = "braces"
 
     inputs = [
-        HandleInput(
-            name="llm",
+        ModelInput(
+            name="model",
             display_name="Language Model",
-            info="The language model to use to generate the structured output.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MultilineInput(
             name="input_value",
             display_name="Input Message",
@@ -126,10 +139,23 @@ class StructuredOutputComponent(Component):
         ),
     ]
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def build_structured_output_base(self):
         schema_name = self.schema_name or "OutputModel"
 
-        if not hasattr(self.llm, "with_structured_output"):
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
+
+        if not hasattr(llm, "with_structured_output"):
             msg = "Language model does not support structured output."
             raise TypeError(msg)
         if not self.output_schema:
@@ -155,9 +181,9 @@ class StructuredOutputComponent(Component):
             "callbacks": self.get_langchain_callbacks(),
         }
         # Generate structured output using Trustcall first, then fallback to Langchain if it fails
-        result = self._extract_output_with_trustcall(output_model, config_dict)
+        result = self._extract_output_with_trustcall(llm, output_model, config_dict)
         if result is None:
-            result = self._extract_output_with_langchain(output_model, config_dict)
+            result = self._extract_output_with_langchain(llm, output_model, config_dict)
 
         # OPTIMIZATION NOTE: Simplified processing based on trustcall response structure
         # Handle non-dict responses (shouldn't happen with trustcall, but defensive)
@@ -204,9 +230,9 @@ class StructuredOutputComponent(Component):
             return DataFrame(output)
         return DataFrame()
 
-    def _extract_output_with_trustcall(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+    def _extract_output_with_trustcall(self, llm, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
         try:
-            llm_with_structured_output = create_extractor(self.llm, tools=[schema], tool_choice=schema.__name__)
+            llm_with_structured_output = create_extractor(llm, tools=[schema], tool_choice=schema.__name__)
             result = get_chat_result(
                 runnable=llm_with_structured_output,
                 system_message=self.system_prompt,
@@ -222,9 +248,9 @@ class StructuredOutputComponent(Component):
             return None
         return result or None  # langchain fallback is used if error occurs or the result is empty
 
-    def _extract_output_with_langchain(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+    def _extract_output_with_langchain(self, llm, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
         try:
-            llm_with_structured_output = self.llm.with_structured_output(schema)
+            llm_with_structured_output = llm.with_structured_output(schema)
             result = get_chat_result(
                 runnable=llm_with_structured_output,
                 system_message=self.system_prompt,

lfx/components/models/__init__.py

@@ -1,89 +1,31 @@
-"""Models module - backwards compatibility alias for models_and_agents.
+"""Compatibility layer for lfx.components.models.
 
-This module provides backwards compatibility by forwarding model-related imports
-to models_and_agents where the actual model components are located.
+This module redirects imports to lfx.components.models_and_agents for backward compatibility.
 """
 
 from __future__ import annotations
 
-import sys
 from typing import Any
 
-from lfx.components._importing import import_mod
-
-# Forward model components from models_and_agents
-_dynamic_imports = {
-    "LanguageModelComponent": "language_model",
-    "EmbeddingModelComponent": "embedding_model",
-}
-
-__all__ = [
-    "EmbeddingModelComponent",
-    "LanguageModelComponent",
-]
-
-# Register redirected submodules in sys.modules for direct importlib.import_module() calls
-# This allows imports like: import lfx.components.models.embedding_model
-_redirected_submodules = {
-    "lfx.components.models.embedding_model": "lfx.components.models_and_agents.embedding_model",
-    "lfx.components.models.language_model": "lfx.components.models_and_agents.language_model",
-}
-
-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)
+# Import everything from models_and_agents to maintain backward compatibility
+from lfx.components.models_and_agents import *  # noqa: F403
+from lfx.components.models_and_agents import __all__  # noqa: F401
 
 
+# Set up module-level __getattr__ to handle dynamic imports
 def __getattr__(attr_name: str) -> Any:
-    """Forward attribute access to models_and_agents components."""
-    # Handle submodule access for backwards compatibility
-    if attr_name == "embedding_model":
-        from importlib import import_module
-
-        result = import_module("lfx.components.models_and_agents.embedding_model")
-        globals()[attr_name] = result
-        return result
-    if attr_name == "language_model":
-        from importlib import import_module
+    """Redirect all attribute access to models_and_agents module."""
+    from lfx.components import models_and_agents
 
-        result = import_module("lfx.components.models_and_agents.language_model")
-        globals()[attr_name] = result
-        return result
+    if hasattr(models_and_agents, attr_name):
+        return getattr(models_and_agents, attr_name)
 
-    if attr_name not in _dynamic_imports:
-        msg = f"module '{__name__}' has no attribute '{attr_name}'"
-        raise AttributeError(msg)
-
-    # Import from models_and_agents using the correct package path
-    package = "lfx.components.models_and_agents"
-    try:
-        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
-    globals()[attr_name] = result
-    return result
+    msg = f"module '{__name__}' has no attribute '{attr_name}'"
+    raise AttributeError(msg)
 
 
 def __dir__() -> list[str]:
-    """Return directory of available components."""
-    return list(__all__)
+    """Return the directory of available attributes."""
+    from lfx.components import models_and_agents
+
+    return dir(models_and_agents)

lfx/components/models_and_agents/agent.py

@@ -1,27 +1,29 @@
+from __future__ import annotations
+
 import json
 import re
+from typing import TYPE_CHECKING
 
-from langchain_core.tools import StructuredTool, Tool
 from pydantic import ValidationError
 
+from lfx.components.models_and_agents.memory import MemoryComponent
+
+if TYPE_CHECKING:
+    from langchain_core.tools import Tool
+
 from lfx.base.agents.agent import LCToolsAgentComponent
 from lfx.base.agents.events import ExceptionWithMessageError
-from lfx.base.models.model_input_constants import (
-    ALL_PROVIDER_FIELDS,
-    MODEL_DYNAMIC_UPDATE_FIELDS,
-    MODEL_PROVIDERS_DICT,
-    MODEL_PROVIDERS_LIST,
-    MODELS_METADATA,
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_llm,
+    update_model_options_in_build_config,
 )
-from lfx.base.models.model_utils import get_model_name
 from lfx.components.helpers import CurrentDateComponent
 from lfx.components.langchain_utilities.tool_calling import ToolCallingAgentComponent
-from lfx.components.models_and_agents.memory import MemoryComponent
 from lfx.custom.custom_component.component import get_component_toolkit
-from lfx.custom.utils import update_component_build_config
 from lfx.helpers.base_model import build_model_from_schema
-from lfx.inputs.inputs import BoolInput, SecretStrInput, StrInput
-from lfx.io import DropdownInput, IntInput, MessageTextInput, MultilineInput, Output, TableInput
+from lfx.inputs.inputs import BoolInput, ModelInput
+from lfx.io import IntInput, MessageTextInput, MultilineInput, Output, SecretStrInput, TableInput
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dotdict import dotdict
@@ -44,66 +46,21 @@ class AgentComponent(ToolCallingAgentComponent):
 
     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",
+        ModelInput(
+            name="model",
+            display_name="Language Model",
+            info="Select your model provider",
             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],
-            external_options={
-                "fields": {
-                    "data": {
-                        "node": {
-                            "name": "connect_other_models",
-                            "display_name": "Connect other models",
-                            "icon": "CornerDownLeft",
-                        }
-                    }
-                },
-            },
+            required=True,
         ),
         SecretStrInput(
             name="api_key",
             display_name="API Key",
-            info="The API key to use for the model.",
-            required=True,
-        ),
-        StrInput(
-            name="base_url",
-            display_name="Base URL",
-            info="The base URL of the API.",
-            required=True,
-            show=False,
-        ),
-        StrInput(
-            name="project_id",
-            display_name="Project ID",
-            info="The project ID of the model.",
-            required=True,
-            show=False,
-        ),
-        IntInput(
-            name="max_output_tokens",
-            display_name="Max Output Tokens",
-            info="The maximum number of tokens to generate.",
-            show=False,
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
         ),
-        *openai_inputs_filtered,
         MultilineInput(
             name="system_prompt",
             display_name="Agent Instructions",
@@ -204,11 +161,16 @@ class AgentComponent(ToolCallingAgentComponent):
 
     async def get_agent_requirements(self):
         """Get the agent requirements for the agent."""
-        llm_model, display_name = await self.get_llm()
+        from langchain_core.tools import StructuredTool
+
+        llm_model = get_llm(
+            model=self.model,
+            user_id=self.user_id,
+            api_key=self.api_key,
+        )
         if llm_model is None:
             msg = "No language model selected. Please choose a model to proceed."
             raise ValueError(msg)
-        self.model_name = get_model_name(llm_model, display_name=display_name)
 
         # Get memory data
         self.chat_history = await self.get_memory_data()
@@ -456,55 +418,6 @@ class AgentComponent(ToolCallingAgentComponent):
             message for message in messages if getattr(message, "id", None) != getattr(self.input_value, "id", None)
         ]
 
-    async def get_llm(self):
-        if not isinstance(self.agent_llm, str):
-            return self.agent_llm, None
-
-        try:
-            provider_info = MODEL_PROVIDERS_DICT.get(self.agent_llm)
-            if not provider_info:
-                msg = f"Invalid model provider: {self.agent_llm}"
-                raise ValueError(msg)
-
-            component_class = provider_info.get("component_class")
-            display_name = component_class.display_name
-            inputs = provider_info.get("inputs")
-            prefix = provider_info.get("prefix", "")
-
-            return self._build_llm_model(component_class, inputs, prefix), display_name
-
-        except (AttributeError, ValueError, TypeError, RuntimeError) as e:
-            await logger.aerror(f"Error building {self.agent_llm} language model: {e!s}")
-            msg = f"Failed to initialize language model: {e!s}"
-            raise ValueError(msg) from e
-
-    def _build_llm_model(self, component, inputs, prefix=""):
-        model_kwargs = {}
-        for input_ in inputs:
-            if hasattr(self, f"{prefix}{input_.name}"):
-                model_kwargs[input_.name] = getattr(self, f"{prefix}{input_.name}")
-        return component.set(**model_kwargs).build_model()
-
-    def set_component_params(self, component):
-        provider_info = MODEL_PROVIDERS_DICT.get(self.agent_llm)
-        if provider_info:
-            inputs = provider_info.get("inputs")
-            prefix = provider_info.get("prefix")
-            # Filter out json_mode and only use attributes that exist on this component
-            model_kwargs = {}
-            for input_ in inputs:
-                if hasattr(self, f"{prefix}{input_.name}"):
-                    model_kwargs[input_.name] = getattr(self, f"{prefix}{input_.name}")
-
-            return component.set(**model_kwargs)
-        return component
-
-    def delete_fields(self, build_config: dotdict, fields: dict | list[str]) -> None:
-        """Delete specified fields from build_config."""
-        for field in fields:
-            if build_config is not None and field in build_config:
-                build_config.pop(field, None)
-
     def update_input_types(self, build_config: dotdict) -> dotdict:
         """Update input types for all fields in build_config."""
         for key, value in build_config.items():
@@ -516,74 +429,29 @@ class AgentComponent(ToolCallingAgentComponent):
         return build_config
 
     async def update_build_config(
-        self, build_config: dotdict, field_value: str, field_name: str | None = None
+        self,
+        build_config: dotdict,
+        field_value: list[dict],
+        field_name: str | None = None,
     ) -> dotdict:
-        # Iterate over all providers in the MODEL_PROVIDERS_DICT
-        # Existing logic for updating build_config
-        if field_name in ("agent_llm",):
-            build_config["agent_llm"]["value"] = field_value
-            provider_info = MODEL_PROVIDERS_DICT.get(field_value)
-            if provider_info:
-                component_class = provider_info.get("component_class")
-                if component_class and hasattr(component_class, "update_build_config"):
-                    # Call the component class's update_build_config method
-                    build_config = await update_component_build_config(
-                        component_class, build_config, field_value, "model_name"
-                    )
+        # Update model options with caching (for all field changes)
+        # Agents require tool calling, so filter for only tool-calling capable models
+        def get_tool_calling_model_options(user_id=None):
+            return get_language_model_options(user_id=user_id, tool_calling=True)
+
+        build_config = update_model_options_in_build_config(
+            component=self,
+            build_config=dict(build_config),
+            cache_key_prefix="language_model_options_tool_calling",
+            get_options_func=get_tool_calling_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+        build_config = dotdict(build_config)
 
-            provider_configs: dict[str, tuple[dict, list[dict]]] = {
-                provider: (
-                    MODEL_PROVIDERS_DICT[provider]["fields"],
-                    [
-                        MODEL_PROVIDERS_DICT[other_provider]["fields"]
-                        for other_provider in MODEL_PROVIDERS_DICT
-                        if other_provider != provider
-                    ],
-                )
-                for provider in MODEL_PROVIDERS_DICT
-            }
-            if field_value in provider_configs:
-                fields_to_add, fields_to_delete = provider_configs[field_value]
-
-                # Delete fields from other providers
-                for fields in fields_to_delete:
-                    self.delete_fields(build_config, fields)
-
-                # Add provider-specific fields
-                if field_value == "OpenAI" and not any(field in build_config for field in fields_to_add):
-                    build_config.update(fields_to_add)
-                else:
-                    build_config.update(fields_to_add)
-                # Reset input types for agent_llm
-                build_config["agent_llm"]["input_types"] = []
-                build_config["agent_llm"]["display_name"] = "Model Provider"
-            elif field_value == "connect_other_models":
-                # Delete all provider fields
-                self.delete_fields(build_config, ALL_PROVIDER_FIELDS)
-                # # Update with custom component
-                custom_component = DropdownInput(
-                    name="agent_llm",
-                    display_name="Language Model",
-                    info="The provider of the language model that the agent will use to generate responses.",
-                    options=[*MODEL_PROVIDERS_LIST],
-                    real_time_refresh=True,
-                    refresh_button=False,
-                    input_types=["LanguageModel"],
-                    placeholder="Awaiting model input.",
-                    options_metadata=[MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA],
-                    external_options={
-                        "fields": {
-                            "data": {
-                                "node": {
-                                    "name": "connect_other_models",
-                                    "display_name": "Connect other models",
-                                    "icon": "CornerDownLeft",
-                                },
-                            }
-                        },
-                    },
-                )
-                build_config.update({"agent_llm": custom_component.to_dict()})
+        # Iterate over all providers in the MODEL_PROVIDERS_DICT
+        if field_name == "model":
+            self.log(str(field_value))
             # Update input types for all fields
             build_config = self.update_input_types(build_config)
 
@@ -591,7 +459,7 @@ class AgentComponent(ToolCallingAgentComponent):
             default_keys = [
                 "code",
                 "_type",
-                "agent_llm",
+                "model",
                 "tools",
                 "input_value",
                 "add_current_date_tool",
@@ -605,24 +473,6 @@ class AgentComponent(ToolCallingAgentComponent):
             if missing_keys:
                 msg = f"Missing required keys in build_config: {missing_keys}"
                 raise ValueError(msg)
-        if (
-            isinstance(self.agent_llm, str)
-            and self.agent_llm in MODEL_PROVIDERS_DICT
-            and field_name in MODEL_DYNAMIC_UPDATE_FIELDS
-        ):
-            provider_info = MODEL_PROVIDERS_DICT.get(self.agent_llm)
-            if provider_info:
-                component_class = provider_info.get("component_class")
-                component_class = self.set_component_params(component_class)
-                prefix = provider_info.get("prefix")
-                if component_class and hasattr(component_class, "update_build_config"):
-                    # Call each component class's update_build_config method
-                    # remove the prefix from the field_name
-                    if isinstance(field_name, str) and isinstance(prefix, str):
-                        field_name = field_name.replace(prefix, "")
-                    build_config = await update_component_build_config(
-                        component_class, build_config, field_value, "model_name"
-                    )
         return dotdict({k: v.to_dict() if hasattr(v, "to_dict") else v for k, v in build_config.items()})
 
     async def _get_tools(self) -> list[Tool]: