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

lfx/components/models/__init__.py

@@ -1,28 +1,82 @@
+"""Models module - backwards compatibility alias for models_and_agents.
+
+This module provides backwards compatibility by forwarding model-related imports
+to models_and_agents where the actual model components are located.
+"""
+
 from __future__ import annotations
 
-from typing import TYPE_CHECKING, Any
+import sys
+from typing import Any
 
 from lfx.components._importing import import_mod
 
-if TYPE_CHECKING:
-    from lfx.components.models.embedding_model import EmbeddingModelComponent
-    from lfx.components.models.language_model import LanguageModelComponent
-
+# Forward model components from models_and_agents
 _dynamic_imports = {
-    "EmbeddingModelComponent": "embedding_model",
     "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",
 }
 
-__all__ = ["EmbeddingModelComponent", "LanguageModelComponent"]
+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 model components on attribute access."""
+    """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
+
+        result = import_module("lfx.components.models_and_agents.language_model")
+        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 models_and_agents using the correct package path
+    package = "lfx.components.models_and_agents"
     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/models_and_agents/__init__.py

@@ -0,0 +1,49 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+from lfx.components._importing import import_mod
+
+if TYPE_CHECKING:
+    from lfx.components.models_and_agents.agent import AgentComponent
+    from lfx.components.models_and_agents.embedding_model import EmbeddingModelComponent
+    from lfx.components.models_and_agents.language_model import LanguageModelComponent
+    from lfx.components.models_and_agents.mcp_component import MCPToolsComponent
+    from lfx.components.models_and_agents.memory import MemoryComponent
+    from lfx.components.models_and_agents.prompt import PromptComponent
+
+_dynamic_imports = {
+    "AgentComponent": "agent",
+    "EmbeddingModelComponent": "embedding_model",
+    "LanguageModelComponent": "language_model",
+    "MCPToolsComponent": "mcp_component",
+    "MemoryComponent": "memory",
+    "PromptComponent": "prompt",
+}
+
+__all__ = [
+    "AgentComponent",
+    "EmbeddingModelComponent",
+    "LanguageModelComponent",
+    "MCPToolsComponent",
+    "MemoryComponent",
+    "PromptComponent",
+]
+
+
+def __getattr__(attr_name: str) -> Any:
+    """Lazily import model and agent components on attribute access."""
+    if attr_name not in _dynamic_imports:
+        msg = f"module '{__name__}' has no attribute '{attr_name}'"
+        raise AttributeError(msg)
+    try:
+        result = import_mod(attr_name, _dynamic_imports[attr_name], __spec__.parent)
+    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
+
+
+def __dir__() -> list[str]:
+    return list(__all__)

lfx/components/{agents → models_and_agents}/agent.py

@@ -14,14 +14,14 @@ from lfx.base.models.model_input_constants import (
     MODELS_METADATA,
 )
 from lfx.base.models.model_utils import get_model_name
-from lfx.components.helpers.current_date import CurrentDateComponent
-from lfx.components.helpers.memory import MemoryComponent
+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
-from lfx.io import DropdownInput, IntInput, MultilineInput, Output, TableInput
+from lfx.inputs.inputs import BoolInput, SecretStrInput, StrInput
+from lfx.io import DropdownInput, IntInput, MessageTextInput, MultilineInput, Output, TableInput
 from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dotdict import dotdict
@@ -77,6 +77,32 @@ class AgentComponent(ToolCallingAgentComponent):
                 },
             },
         ),
+        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,
+        ),
         *openai_inputs_filtered,
         MultilineInput(
             name="system_prompt",
@@ -85,6 +111,13 @@ class AgentComponent(ToolCallingAgentComponent):
             value="You are a helpful assistant that can use tools to answer questions and perform tasks.",
             advanced=False,
         ),
+        MessageTextInput(
+            name="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            advanced=True,
+        ),
         IntInput(
             name="n_messages",
             display_name="Number of Chat History Messages",
@@ -154,7 +187,7 @@ class AgentComponent(ToolCallingAgentComponent):
                 },
             ],
         ),
-        *LCToolsAgentComponent._base_inputs,
+        *LCToolsAgentComponent.get_base_inputs(),
         # removed memory inputs from agent component
         # *memory_inputs,
         BoolInput(
@@ -188,10 +221,15 @@ class AgentComponent(ToolCallingAgentComponent):
             if not isinstance(self.tools, list):  # type: ignore[has-type]
                 self.tools = []
             current_date_tool = (await CurrentDateComponent(**self.get_base_args()).to_toolkit()).pop(0)
+
             if not isinstance(current_date_tool, StructuredTool):
                 msg = "CurrentDateComponent must be converted to a StructuredTool"
                 raise TypeError(msg)
             self.tools.append(current_date_tool)
+
+        # Set shared callbacks for tracing the tools used by the agent
+        self.set_tools_callbacks(self.tools, self._get_shared_callbacks())
+
         return llm_model, self.chat_history, self.tools
 
     async def message_response(self) -> Message:
@@ -408,6 +446,7 @@ class AgentComponent(ToolCallingAgentComponent):
             await MemoryComponent(**self.get_base_args())
             .set(
                 session_id=self.graph.session_id,
+                context_id=self.context_id,
                 order="Ascending",
                 n_messages=self.n_messages,
             )
@@ -463,7 +502,8 @@ class AgentComponent(ToolCallingAgentComponent):
     def delete_fields(self, build_config: dotdict, fields: dict | list[str]) -> None:
         """Delete specified fields from build_config."""
         for field in fields:
-            build_config.pop(field, None)
+            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."""
@@ -591,11 +631,14 @@ class AgentComponent(ToolCallingAgentComponent):
         agent_description = self.get_tool_description()
         # TODO: Agent Description Depreciated Feature to be removed
         description = f"{agent_description}{tools_names}"
+
         tools = component_toolkit(component=self).get_tools(
             tool_name="Call_Agent",
             tool_description=description,
+            # here we do not use the shared callbacks as we are exposing the agent as a tool
             callbacks=self.get_langchain_callbacks(),
         )
         if hasattr(self, "tools_metadata"):
             tools = component_toolkit(component=self, metadata=self.tools_metadata).update_tools_metadata(tools=tools)
+
         return tools