lfx-nightly 0.2.1.dev7__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

lfx/components/llm_operations/lambda_filter.py

@@ -2,7 +2,8 @@ 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,
@@ -13,18 +14,34 @@ from lfx.custom.custom_component.component import Component
 from lfx.io import DataInput, IntInput, ModelInput, MultilineInput, Output, SecretStrInput
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
+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()"
+)
 
-if TYPE_CHECKING:
-    from collections.abc import Callable
-
-# # Compute model options once at module level
-# _MODEL_OPTIONS = get_language_model_options()
-# _PROVIDERS = [provider["provider"] for provider in _MODEL_OPTIONS]
+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"
@@ -33,8 +50,8 @@ 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,
         ),
@@ -57,9 +74,10 @@ class LambdaFilterComponent(Component):
             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(
@@ -89,6 +107,11 @@ 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):
@@ -119,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))
-
-        llm = get_llm(model=self.model, user_id=self.user_id, api_key=self.api_key)
-        instruction = self.filter_instruction
-        sample_size = self.sample_size
+        return TEXT_TRANSFORM_PROMPT.format(text_preview=text_preview, instruction=self.filter_instruction)
 
-        # 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
+    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)
+
+        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)
 
-    async def process_as_data(self) -> Data:
-        """Process the data and return as a Data object."""
-        result = await self._execute_lambda()
+    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
 
-        # Convert result to Data based on type
+    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/models_and_agents/mcp_component.py

@@ -15,7 +15,7 @@ from lfx.base.mcp.util import (
 )
 from lfx.custom.custom_component.component_with_cache import ComponentWithCache
 from lfx.inputs.inputs import InputTypes  # noqa: TC001
-from lfx.io import BoolInput, DropdownInput, McpInput, MessageTextInput, Output
+from lfx.io import BoolInput, DictInput, DropdownInput, McpInput, MessageTextInput, Output
 from lfx.io.schema import flatten_schema, schema_to_langflow_inputs
 from lfx.log.logger import logger
 from lfx.schema.dataframe import DataFrame
@@ -87,6 +87,7 @@ class MCPToolsComponent(ComponentWithCache):
         "tool",
         "use_cache",
         "verify_ssl",
+        "headers",
     ]
 
     display_name = "MCP Tools"
@@ -122,6 +123,17 @@ class MCPToolsComponent(ComponentWithCache):
             value=True,
             advanced=True,
         ),
+        DictInput(
+            name="headers",
+            display_name="Headers",
+            info=(
+                "HTTP headers to include with MCP server requests. "
+                "Useful for authentication (e.g., Authorization header). "
+                "These headers override any headers configured in the MCP server settings."
+            ),
+            advanced=True,
+            is_list=True,
+        ),
         DropdownInput(
             name="tool",
             display_name="Tool",
@@ -258,6 +270,31 @@ class MCPToolsComponent(ComponentWithCache):
                 verify_ssl = getattr(self, "verify_ssl", True)
                 server_config["verify_ssl"] = verify_ssl
 
+            # Merge headers from component input with server config headers
+            # Component headers take precedence over server config headers
+            component_headers = getattr(self, "headers", None) or []
+            if component_headers:
+                # Convert list of {"key": k, "value": v} to dict
+                component_headers_dict = {}
+                if isinstance(component_headers, list):
+                    for item in component_headers:
+                        if isinstance(item, dict) and "key" in item and "value" in item:
+                            component_headers_dict[item["key"]] = item["value"]
+                elif isinstance(component_headers, dict):
+                    component_headers_dict = component_headers
+
+                if component_headers_dict:
+                    existing_headers = server_config.get("headers", {}) or {}
+                    # Ensure existing_headers is a dict (convert from list if needed)
+                    if isinstance(existing_headers, list):
+                        existing_dict = {}
+                        for item in existing_headers:
+                            if isinstance(item, dict) and "key" in item and "value" in item:
+                                existing_dict[item["key"]] = item["value"]
+                        existing_headers = existing_dict
+                    merged_headers = {**existing_headers, **component_headers_dict}
+                    server_config["headers"] = merged_headers
+
             _, tool_list, tool_cache = await update_tools(
                 server_name=server_name,
                 server_config=server_config,

lfx/components/models_and_agents/prompt.py

@@ -1,22 +1,36 @@
+from typing import Any
+
 from lfx.base.prompts.api_utils import process_prompt_template
 from lfx.custom.custom_component.component import Component
+from lfx.inputs.input_mixin import FieldTypes
 from lfx.inputs.inputs import DefaultPromptField
-from lfx.io import MessageTextInput, Output, PromptInput
+from lfx.io import BoolInput, MessageTextInput, Output, PromptInput
+from lfx.log.logger import logger
+from lfx.schema.dotdict import dotdict
 from lfx.schema.message import Message
 from lfx.template.utils import update_template_values
+from lfx.utils.mustache_security import validate_mustache_template
 
 
 class PromptComponent(Component):
     display_name: str = "Prompt Template"
     description: str = "Create a prompt template with dynamic variables."
     documentation: str = "https://docs.langflow.org/components-prompts"
-    icon = "braces"
+    icon = "prompts"
     trace_type = "prompt"
     name = "Prompt Template"
     priority = 0  # Set priority to 0 to make it appear first
 
     inputs = [
         PromptInput(name="template", display_name="Template"),
+        BoolInput(
+            name="use_double_brackets",
+            display_name="Use Double Brackets",
+            value=False,
+            advanced=True,
+            info="Use {{variable}} syntax instead of {variable}.",
+            real_time_refresh=True,
+        ),
         MessageTextInput(
             name="tool_placeholder",
             display_name="Tool Placeholder",
@@ -30,34 +44,107 @@ class PromptComponent(Component):
         Output(display_name="Prompt", name="prompt", method="build_prompt"),
     ]
 
+    def update_build_config(self, build_config: dotdict, field_value: Any, field_name: str | None = None) -> dotdict:
+        """Update the template field type based on the selected mode."""
+        if field_name == "use_double_brackets":
+            # Change the template field type based on mode
+            is_mustache = field_value is True
+            if is_mustache:
+                build_config["template"]["type"] = FieldTypes.MUSTACHE_PROMPT.value
+            else:
+                build_config["template"]["type"] = FieldTypes.PROMPT.value
+
+            # Re-process the template to update variables when mode changes
+            template_value = build_config.get("template", {}).get("value", "")
+            if template_value:
+                # Ensure custom_fields is properly initialized
+                if "custom_fields" not in build_config:
+                    build_config["custom_fields"] = {}
+
+                # Clean up fields from the OLD mode before processing with NEW mode
+                # This ensures we don't keep fields with wrong syntax even if validation fails
+                old_custom_fields = build_config["custom_fields"].get("template", [])
+                for old_field in list(old_custom_fields):
+                    # Remove the field from custom_fields and template
+                    if old_field in old_custom_fields:
+                        old_custom_fields.remove(old_field)
+                    build_config.pop(old_field, None)
+
+                # Try to process template with new mode to add new variables
+                # If validation fails, at least we cleaned up old fields
+                try:
+                    # Validate mustache templates for security
+                    if is_mustache:
+                        validate_mustache_template(template_value)
+
+                    # Re-process template with new mode to add new variables
+                    _ = process_prompt_template(
+                        template=template_value,
+                        name="template",
+                        custom_fields=build_config["custom_fields"],
+                        frontend_node_template=build_config,
+                        is_mustache=is_mustache,
+                    )
+                except ValueError as e:
+                    # If validation fails, we still updated the mode and cleaned old fields
+                    # User will see error when they try to save
+                    logger.debug(f"Template validation failed during mode switch: {e}")
+        return build_config
+
     async def build_prompt(self) -> Message:
-        prompt = Message.from_template(**self._attributes)
+        use_double_brackets = self.use_double_brackets if hasattr(self, "use_double_brackets") else False
+        template_format = "mustache" if use_double_brackets else "f-string"
+        prompt = await Message.from_template_and_variables(template_format=template_format, **self._attributes)
         self.status = prompt.text
         return prompt
 
     def _update_template(self, frontend_node: dict):
         prompt_template = frontend_node["template"]["template"]["value"]
-        custom_fields = frontend_node["custom_fields"]
-        frontend_node_template = frontend_node["template"]
-        _ = process_prompt_template(
-            template=prompt_template,
-            name="template",
-            custom_fields=custom_fields,
-            frontend_node_template=frontend_node_template,
-        )
+        use_double_brackets = frontend_node["template"].get("use_double_brackets", {}).get("value", False)
+        is_mustache = use_double_brackets is True
+
+        try:
+            # Validate mustache templates for security
+            if is_mustache:
+                validate_mustache_template(prompt_template)
+
+            custom_fields = frontend_node["custom_fields"]
+            frontend_node_template = frontend_node["template"]
+            _ = process_prompt_template(
+                template=prompt_template,
+                name="template",
+                custom_fields=custom_fields,
+                frontend_node_template=frontend_node_template,
+                is_mustache=is_mustache,
+            )
+        except ValueError as e:
+            # If validation fails, don't add variables but allow component to be created
+            logger.debug(f"Template validation failed in _update_template: {e}")
         return frontend_node
 
     async def update_frontend_node(self, new_frontend_node: dict, current_frontend_node: dict):
         """This function is called after the code validation is done."""
         frontend_node = await super().update_frontend_node(new_frontend_node, current_frontend_node)
         template = frontend_node["template"]["template"]["value"]
-        # Kept it duplicated for backwards compatibility
-        _ = process_prompt_template(
-            template=template,
-            name="template",
-            custom_fields=frontend_node["custom_fields"],
-            frontend_node_template=frontend_node["template"],
-        )
+        use_double_brackets = frontend_node["template"].get("use_double_brackets", {}).get("value", False)
+        is_mustache = use_double_brackets is True
+
+        try:
+            # Validate mustache templates for security
+            if is_mustache:
+                validate_mustache_template(template)
+
+            # Kept it duplicated for backwards compatibility
+            _ = process_prompt_template(
+                template=template,
+                name="template",
+                custom_fields=frontend_node["custom_fields"],
+                frontend_node_template=frontend_node["template"],
+                is_mustache=is_mustache,
+            )
+        except ValueError as e:
+            # If validation fails, don't add variables but allow component to be updated
+            logger.debug(f"Template validation failed in update_frontend_node: {e}")
         # Now that template is updated, we need to grab any values that were set in the current_frontend_node
         # and update the frontend_node with those values
         update_template_values(new_template=frontend_node, previous_template=current_frontend_node["template"])