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

lfx/components/llm_operations/lambda_filter.py

@@ -2,20 +2,46 @@ from __future__ import annotations
 
 import json
 import re
-from typing import TYPE_CHECKING, Any
-
+from collections.abc import Callable  # noqa: TC003 - required at runtime for dynamic exec()
+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.custom_component.component import Component
-from lfx.io import DataInput, HandleInput, IntInput, MultilineInput, Output
+from lfx.io import DataInput, IntInput, ModelInput, MultilineInput, Output, SecretStrInput
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
-
-if TYPE_CHECKING:
-    from collections.abc import Callable
+from lfx.schema.message import Message
+from lfx.utils.constants import MESSAGE_SENDER_AI
+
+TEXT_TRANSFORM_PROMPT = (
+    "Given this text, create a Python lambda function that transforms it "
+    "according to the instruction.\n"
+    "The lambda should take a string parameter and return the transformed string.\n\n"
+    "Text Preview:\n{text_preview}\n\n"
+    "Instruction: {instruction}\n\n"
+    "Return ONLY the lambda function and nothing else. No need for ```python or whatever.\n"
+    "Just a string starting with lambda.\n"
+    "Example: lambda text: text.upper()"
+)
+
+DATA_TRANSFORM_PROMPT = (
+    "Given this data structure and examples, create a Python lambda function "
+    "that implements the following instruction:\n\n"
+    "Data Structure:\n{dump_structure}\n\n"
+    "Example Items:\n{data_sample}\n\n"
+    "Instruction: {instruction}\n\n"
+    "Return ONLY the lambda function and nothing else. No need for ```python or whatever.\n"
+    "Just a string starting with lambda."
+)
 
 
 class LambdaFilterComponent(Component):
     display_name = "Smart Transform"
-    description = "Uses an LLM to generate a function for filtering or transforming structured data."
+    description = "Uses an LLM to generate a function for filtering or transforming structured data and messages."
     documentation: str = "https://docs.langflow.org/smart-transform"
     icon = "square-function"
     name = "Smart Transform"
@@ -24,26 +50,34 @@ class LambdaFilterComponent(Component):
         DataInput(
             name="data",
             display_name="Data",
-            info="The structured data to filter or transform using a lambda function.",
-            input_types=["Data", "DataFrame"],
+            info="The structured data or text messages to filter or transform using a lambda function.",
+            input_types=["Data", "DataFrame", "Message"],
             is_list=True,
             required=True,
         ),
-        HandleInput(
-            name="llm",
+        ModelInput(
+            name="model",
             display_name="Language Model",
-            info="Connect the 'Language Model' output from your LLM component here.",
-            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="filter_instruction",
             display_name="Instructions",
             info=(
                 "Natural language instructions for how to filter or transform the data using a lambda function. "
-                "Example: Filter the data to only include items where the 'status' is 'active'."
+                "Examples: 'Filter the data to only include items where status is active', "
+                "'Convert the text to uppercase', 'Keep only first 100 characters'"
             ),
-            value="Filter the data to...",
+            value="Transform the data to...",
             required=True,
         ),
         IntInput(
@@ -73,8 +107,24 @@ class LambdaFilterComponent(Component):
             name="dataframe_output",
             method="process_as_dataframe",
         ),
+        Output(
+            display_name="Output",
+            name="message_output",
+            method="process_as_message",
+        ),
     ]
 
+    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 get_data_structure(self, data):
         """Extract the structure of data, replacing values with their types."""
         if isinstance(data, list):
@@ -92,127 +142,189 @@ class LambdaFilterComponent(Component):
         # Return False if the lambda function does not start with 'lambda' or does not contain a colon
         return lambda_text.strip().startswith("lambda") and ":" in lambda_text
 
-    async def _execute_lambda(self) -> Any:
-        self.log(str(self.data))
-
-        # Convert input to a unified format
-        if isinstance(self.data, list):
-            # Handle list of Data or DataFrame objects
-            combined_data = []
-            for item in self.data:
-                if isinstance(item, DataFrame):
-                    # DataFrame to list of dicts
-                    combined_data.extend(item.to_dict(orient="records"))
-                elif hasattr(item, "data"):
-                    # Data object
-                    if isinstance(item.data, dict):
-                        combined_data.append(item.data)
-                    elif isinstance(item.data, list):
-                        combined_data.extend(item.data)
-
-            # If we have a single dict, unwrap it so lambdas can access it directly
-            if len(combined_data) == 1 and isinstance(combined_data[0], dict):
-                data = combined_data[0]
-            elif len(combined_data) == 0:
-                data = {}
-            else:
-                data = combined_data  # type: ignore[assignment]
-        elif isinstance(self.data, DataFrame):
-            # Single DataFrame to list of dicts
-            data = self.data.to_dict(orient="records")
-        elif hasattr(self.data, "data"):
-            # Single Data object
-            data = self.data.data
+    def _get_input_type_name(self) -> str:
+        """Detect and return the input type name for error messages."""
+        if isinstance(self.data, Message):
+            return "Message"
+        if isinstance(self.data, DataFrame):
+            return "DataFrame"
+        if isinstance(self.data, Data):
+            return "Data"
+        if isinstance(self.data, list) and len(self.data) > 0:
+            first = self.data[0]
+            if isinstance(first, Message):
+                return "Message"
+            if isinstance(first, DataFrame):
+                return "DataFrame"
+            if isinstance(first, Data):
+                return "Data"
+        return "unknown"
+
+    def _extract_message_text(self) -> str:
+        """Extract text content from Message input(s)."""
+        if isinstance(self.data, Message):
+            return self.data.text or ""
+
+        texts = [msg.text or "" for msg in self.data if isinstance(msg, Message)]
+        return "\n\n".join(texts) if len(texts) > 1 else (texts[0] if texts else "")
+
+    def _extract_structured_data(self) -> dict | list:
+        """Extract structured data from Data or DataFrame input(s)."""
+        if isinstance(self.data, DataFrame):
+            return self.data.to_dict(orient="records")
+
+        if hasattr(self.data, "data"):
+            return self.data.data
+
+        if not isinstance(self.data, list):
+            return self.data
+
+        combined_data: list[dict] = []
+        for item in self.data:
+            if isinstance(item, DataFrame):
+                combined_data.extend(item.to_dict(orient="records"))
+            elif hasattr(item, "data"):
+                if isinstance(item.data, dict):
+                    combined_data.append(item.data)
+                elif isinstance(item.data, list):
+                    combined_data.extend(item.data)
+
+        if len(combined_data) == 1 and isinstance(combined_data[0], dict):
+            return combined_data[0]
+        if len(combined_data) == 0:
+            return {}
+        return combined_data
+
+    def _is_message_input(self) -> bool:
+        """Check if input is Message type."""
+        if isinstance(self.data, Message):
+            return True
+        return isinstance(self.data, list) and len(self.data) > 0 and isinstance(self.data[0], Message)
+
+    def _build_text_prompt(self, text: str) -> str:
+        """Build prompt for text/Message transformation."""
+        text_length = len(text)
+        if text_length > self.max_size:
+            text_preview = (
+                f"Text length: {text_length} characters\n\n"
+                f"First {self.sample_size} characters:\n{text[: self.sample_size]}\n\n"
+                f"Last {self.sample_size} characters:\n{text[-self.sample_size :]}"
+            )
         else:
-            data = self.data
+            text_preview = text
 
-        dump = json.dumps(data)
-        self.log(str(data))
+        return TEXT_TRANSFORM_PROMPT.format(text_preview=text_preview, instruction=self.filter_instruction)
 
-        llm = self.llm
-        instruction = self.filter_instruction
-        sample_size = self.sample_size
-
-        # Get data structure and samples
-        data_structure = self.get_data_structure(data)
-        dump_structure = json.dumps(data_structure)
-        self.log(dump_structure)
+    def _build_data_prompt(self, data: dict | list) -> str:
+        """Build prompt for structured data transformation."""
+        dump = json.dumps(data)
+        dump_structure = json.dumps(self.get_data_structure(data))
 
-        # For large datasets, sample from head and tail
         if len(dump) > self.max_size:
             data_sample = (
-                f"Data is too long to display... \n\n First lines (head): {dump[:sample_size]} \n\n"
-                f" Last lines (tail): {dump[-sample_size:]})"
+                f"Data is too long to display...\n\nFirst lines (head): {dump[: self.sample_size]}\n\n"
+                f"Last lines (tail): {dump[-self.sample_size :]}"
             )
         else:
             data_sample = dump
 
-        self.log(data_sample)
-
-        prompt = f"""Given this data structure and examples, create a Python lambda function that
-                    implements the following instruction:
-
-                    Data Structure:
-                    {dump_structure}
-
-                    Example Items:
-                    {data_sample}
-
-                    Instruction: {instruction}
-
-                    Return ONLY the lambda function and nothing else. No need for ```python or whatever.
-                    Just a string starting with lambda.
-                    """
-
-        response = await llm.ainvoke(prompt)
-        response_text = response.content if hasattr(response, "content") else str(response)
-        self.log(response_text)
+        return DATA_TRANSFORM_PROMPT.format(
+            dump_structure=dump_structure, data_sample=data_sample, instruction=self.filter_instruction
+        )
 
-        # Extract lambda using regex
+    def _parse_lambda_from_response(self, response_text: str) -> Callable[[Any], Any]:
+        """Extract and validate lambda function from LLM response."""
         lambda_match = re.search(r"lambda\s+\w+\s*:.*?(?=\n|$)", response_text)
         if not lambda_match:
             msg = f"Could not find lambda in response: {response_text}"
             raise ValueError(msg)
 
         lambda_text = lambda_match.group().strip()
-        self.log(lambda_text)
+        self.log(f"Generated lambda: {lambda_text}")
 
-        # Validation is commented out as requested
         if not self._validate_lambda(lambda_text):
             msg = f"Invalid lambda format: {lambda_text}"
             raise ValueError(msg)
 
-        # Create and apply the function
-        fn: Callable[[Any], Any] = eval(lambda_text)  # noqa: S307
+        return eval(lambda_text)  # noqa: S307
 
-        # Apply the lambda function to the data
-        return fn(data)
+    async def _execute_lambda(self) -> Any:
+        """Generate and execute a lambda function based on input type."""
+        if self._is_message_input():
+            data: Any = self._extract_message_text()
+            prompt = self._build_text_prompt(data)
+        else:
+            data = self._extract_structured_data()
+            prompt = self._build_data_prompt(data)
 
-    async def process_as_data(self) -> Data:
-        """Process the data and return as a Data object."""
-        result = await self._execute_lambda()
+        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
+        response = await llm.ainvoke(prompt)
+        response_text = response.content if hasattr(response, "content") else str(response)
+
+        fn = self._parse_lambda_from_response(response_text)
+        return fn(data)
 
-        # Convert result to Data based on type
+    def _handle_process_error(self, error: Exception, output_type: str) -> None:
+        """Handle errors from process methods with context-aware messages."""
+        input_type = self._get_input_type_name()
+        error_msg = (
+            f"Failed to convert result to {output_type} output. "
+            f"Error: {error}. "
+            f"Input type was {input_type}. "
+            f"Try using the same output type as the input."
+        )
+        raise ValueError(error_msg) from error
+
+    def _convert_result_to_data(self, result: Any) -> Data:
+        """Convert lambda result to Data object."""
         if isinstance(result, dict):
             return Data(data=result)
         if isinstance(result, list):
             return Data(data={"_results": result})
-        # For other types, convert to string
         return Data(data={"text": str(result)})
 
-    async def process_as_dataframe(self) -> DataFrame:
-        """Process the data and return as a DataFrame."""
-        result = await self._execute_lambda()
-
-        # Convert result to DataFrame based on type
+    def _convert_result_to_dataframe(self, result: Any) -> DataFrame:
+        """Convert lambda result to DataFrame object."""
         if isinstance(result, list):
-            # Check if it's a list of dicts
             if all(isinstance(item, dict) for item in result):
                 return DataFrame(result)
-            # List of non-dicts: wrap each value
             return DataFrame([{"value": item} for item in result])
         if isinstance(result, dict):
-            # Single dict becomes single-row DataFrame
             return DataFrame([result])
-        # Other types: convert to string and wrap
         return DataFrame([{"value": str(result)}])
+
+    def _convert_result_to_message(self, result: Any) -> Message:
+        """Convert lambda result to Message object."""
+        if isinstance(result, str):
+            return Message(text=result, sender=MESSAGE_SENDER_AI)
+        if isinstance(result, list):
+            text = "\n".join(str(item) for item in result)
+            return Message(text=text, sender=MESSAGE_SENDER_AI)
+        if isinstance(result, dict):
+            text = json.dumps(result, indent=2)
+            return Message(text=text, sender=MESSAGE_SENDER_AI)
+        return Message(text=str(result), sender=MESSAGE_SENDER_AI)
+
+    async def process_as_data(self) -> Data:
+        """Process the data and return as a Data object."""
+        try:
+            result = await self._execute_lambda()
+            return self._convert_result_to_data(result)
+        except Exception as e:  # noqa: BLE001 - dynamic lambda can raise any exception
+            self._handle_process_error(e, "Data")
+
+    async def process_as_dataframe(self) -> DataFrame:
+        """Process the data and return as a DataFrame."""
+        try:
+            result = await self._execute_lambda()
+            return self._convert_result_to_dataframe(result)
+        except Exception as e:  # noqa: BLE001 - dynamic lambda can raise any exception
+            self._handle_process_error(e, "DataFrame")
+
+    async def process_as_message(self) -> Message:
+        """Process the data and return as a Message."""
+        try:
+            result = await self._execute_lambda()
+            return self._convert_result_to_message(result)
+        except Exception as e:  # noqa: BLE001 - dynamic lambda can raise any exception
+            self._handle_process_error(e, "Message")

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,