lfx-nightly 0.1.11.dev0__py3-none-any.whl

lfx/base/models/model_metadata.py

@@ -0,0 +1,41 @@
+from typing import TypedDict
+
+
+class ModelMetadata(TypedDict, total=False):
+    """Simple model metadata structure."""
+
+    provider: str  # Provider name (e.g., "anthropic", "groq", "openai")
+    name: str  # Model name/ID
+    icon: str  # Icon name for UI
+    tool_calling: bool  # Whether model supports tool calling (defaults to False)
+    reasoning: bool  # Reasoning models (defaults to False)
+    search: bool  # Search models (defaults to False)
+    preview: bool  # Whether model is in preview/beta (defaults to False)
+    not_supported: bool  # Whether model is not supported or deprecated (defaults to False)
+    deprecated: bool  # Whether model is deprecated (defaults to False)
+
+
+def create_model_metadata(
+    provider: str,
+    name: str,
+    icon: str,
+    *,
+    tool_calling: bool = False,
+    reasoning: bool = False,
+    search: bool = False,
+    preview: bool = False,
+    not_supported: bool = False,
+    deprecated: bool = False,
+) -> ModelMetadata:
+    """Helper function to create ModelMetadata with explicit defaults."""
+    return ModelMetadata(
+        provider=provider,
+        name=name,
+        icon=icon,
+        tool_calling=tool_calling,
+        reasoning=reasoning,
+        search=search,
+        preview=preview,
+        not_supported=not_supported,
+        deprecated=deprecated,
+    )

lfx/base/models/model_utils.py

@@ -0,0 +1,8 @@
+def get_model_name(llm, display_name: str | None = "Custom"):
+    attributes_to_check = ["model_name", "model", "model_id", "deployment_name"]
+
+    # Use a generator expression with next() to find the first matching attribute
+    model_name = next((getattr(llm, attr) for attr in attributes_to_check if hasattr(llm, attr)), None)
+
+    # If no matching attribute is found, return the class name as a fallback
+    return model_name if model_name is not None else display_name

lfx/base/models/novita_constants.py

@@ -0,0 +1,35 @@
+NOVITA_MODELS = [
+    "deepseek/deepseek-r1",
+    "deepseek/deepseek_v3",
+    "meta-llama/llama-3.3-70b-instruct",
+    "meta-llama/llama-3.1-8b-instruct",
+    "meta-llama/llama-3.1-70b-instruct",
+    "mistralai/mistral-nemo",
+    "Sao10K/L3-8B-Stheno-v3.2",
+    "gryphe/mythomax-l2-13b",
+    "qwen/qwen-2.5-72b-instruct",
+    "meta-llama/llama-3-8b-instruct",
+    "microsoft/wizardlm-2-8x22b",
+    "google/gemma-2-9b-it",
+    "mistralai/mistral-7b-instruct",
+    "meta-llama/llama-3-70b-instruct",
+    "openchat/openchat-7b",
+    "nousresearch/hermes-2-pro-llama-3-8b",
+    "sao10k/l3-70b-euryale-v2.1",
+    "cognitivecomputations/dolphin-mixtral-8x22b",
+    "jondurbin/airoboros-l2-70b",
+    "nousresearch/nous-hermes-llama2-13b",
+    "teknium/openhermes-2.5-mistral-7b",
+    "sophosympatheia/midnight-rose-70b",
+    "meta-llama/llama-3.1-8b-instruct-max",
+    "sao10k/l3-8b-lunaris",
+    "qwen/qwen-2-vl-72b-instruct",
+    "meta-llama/llama-3.2-1b-instruct",
+    "meta-llama/llama-3.2-11b-vision-instruct",
+    "meta-llama/llama-3.2-3b-instruct",
+    "meta-llama/llama-3.1-8b-instruct-bf16",
+    "sao10k/l31-70b-euryale-v2.2",
+    "qwen/qwen-2-7b-instruct",
+    "qwen/qwen-2-72b-instruct",
+]
+MODEL_NAMES = NOVITA_MODELS  # reverse compatibility

lfx/base/models/ollama_constants.py

@@ -0,0 +1,49 @@
+# https://ollama.com/search?c=embedding
+OLLAMA_EMBEDDING_MODELS = [
+    "nomic-embed-text",
+    "mxbai-embed-large",
+    "snowflake-arctic-embed",
+    "all-minilm",
+    "bge-m3",
+    "bge-large",
+    "paraphrase-multilingual",
+    "granite-embedding",
+    "jina-embeddings-v2-base-en",
+]
+# https://ollama.com/search?c=tools
+OLLAMA_TOOL_MODELS_BASE = [
+    "llama3.3",
+    "qwq",
+    "llama3.2",
+    "llama3.1",
+    "mistral",
+    "qwen2",
+    "qwen2.5",
+    "qwen2.5-coder",
+    "mistral-nemo",
+    "mixtral",
+    "command-r",
+    "command-r-plus",
+    "mistral-large",
+    "smollm2",
+    "hermes3",
+    "athene-v2",
+    "mistral-small",
+    "nemotron-mini",
+    "nemotron",
+    "llama3-groq-tool-use",
+    "granite3-dense",
+    "granite3.1-dense",
+    "aya-expanse",
+    "granite3-moe",
+    "firefunction-v2",
+    "cogito",
+]
+
+
+URL_LIST = [
+    "http://localhost:11434",
+    "http://host.docker.internal:11434",
+    "http://127.0.0.1:11434",
+    "http://0.0.0.0:11434",
+]

lfx/base/models/openai_constants.py

@@ -0,0 +1,122 @@
+from .model_metadata import create_model_metadata
+
+# Unified model metadata - single source of truth
+OPENAI_MODELS_DETAILED = [
+    # GPT-5 Series
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5",
+        icon="OpenAI",
+        tool_calling=True,
+        reasoning=True,
+    ),
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5-mini",
+        icon="OpenAI",
+        tool_calling=True,
+        reasoning=True,
+    ),
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5-nano",
+        icon="OpenAI",
+        tool_calling=True,
+        reasoning=True,
+    ),
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-5-chat-latest",
+        icon="OpenAI",
+        tool_calling=False,
+        reasoning=True,
+    ),
+    # Regular OpenAI Models
+    create_model_metadata(provider="OpenAI", name="gpt-4o-mini", icon="OpenAI", tool_calling=True),
+    create_model_metadata(provider="OpenAI", name="gpt-4o", icon="OpenAI", tool_calling=True),
+    create_model_metadata(provider="OpenAI", name="gpt-4.1", icon="OpenAI", tool_calling=True),
+    create_model_metadata(provider="OpenAI", name="gpt-4.1-mini", icon="OpenAI", tool_calling=True),
+    create_model_metadata(provider="OpenAI", name="gpt-4.1-nano", icon="OpenAI", tool_calling=True),
+    create_model_metadata(
+        provider="OpenAI", name="gpt-4.5-preview", icon="OpenAI", tool_calling=True, preview=True, not_supported=True
+    ),
+    create_model_metadata(provider="OpenAI", name="gpt-4-turbo", icon="OpenAI", tool_calling=True),
+    create_model_metadata(
+        provider="OpenAI", name="gpt-4-turbo-preview", icon="OpenAI", tool_calling=True, preview=True
+    ),
+    create_model_metadata(provider="OpenAI", name="gpt-4", icon="OpenAI", tool_calling=True),
+    create_model_metadata(provider="OpenAI", name="gpt-3.5-turbo", icon="OpenAI", tool_calling=True),
+    # Reasoning Models
+    create_model_metadata(provider="OpenAI", name="o1", icon="OpenAI", reasoning=True),
+    create_model_metadata(provider="OpenAI", name="o1-mini", icon="OpenAI", reasoning=True, not_supported=True),
+    create_model_metadata(provider="OpenAI", name="o1-pro", icon="OpenAI", reasoning=True, not_supported=True),
+    create_model_metadata(provider="OpenAI", name="o3-mini", icon="OpenAI", reasoning=True),
+    create_model_metadata(provider="OpenAI", name="o3", icon="OpenAI", reasoning=True),
+    create_model_metadata(provider="OpenAI", name="o3-pro", icon="OpenAI", reasoning=True),
+    create_model_metadata(provider="OpenAI", name="o4-mini", icon="OpenAI", reasoning=True),
+    create_model_metadata(provider="OpenAI", name="o4-mini-high", icon="OpenAI", reasoning=True),
+    # Search Models
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-4o-mini-search-preview",
+        icon="OpenAI",
+        tool_calling=True,
+        search=True,
+        preview=True,
+    ),
+    create_model_metadata(
+        provider="OpenAI",
+        name="gpt-4o-search-preview",
+        icon="OpenAI",
+        tool_calling=True,
+        search=True,
+        preview=True,
+    ),
+    # Not Supported Models
+    create_model_metadata(
+        provider="OpenAI", name="computer-use-preview", icon="OpenAI", not_supported=True, preview=True
+    ),
+    create_model_metadata(
+        provider="OpenAI", name="gpt-4o-audio-preview", icon="OpenAI", not_supported=True, preview=True
+    ),
+    create_model_metadata(
+        provider="OpenAI", name="gpt-4o-realtime-preview", icon="OpenAI", not_supported=True, preview=True
+    ),
+    create_model_metadata(
+        provider="OpenAI", name="gpt-4o-mini-audio-preview", icon="OpenAI", not_supported=True, preview=True
+    ),
+    create_model_metadata(
+        provider="OpenAI", name="gpt-4o-mini-realtime-preview", icon="OpenAI", not_supported=True, preview=True
+    ),
+]
+OPENAI_CHAT_MODEL_NAMES = [
+    metadata["name"]
+    for metadata in OPENAI_MODELS_DETAILED
+    if not metadata.get("not_supported", False)
+    and not metadata.get("reasoning", False)
+    and not metadata.get("search", False)
+]
+
+OPENAI_REASONING_MODEL_NAMES = [
+    metadata["name"]
+    for metadata in OPENAI_MODELS_DETAILED
+    if metadata.get("reasoning", False) and not metadata.get("not_supported", False)
+]
+
+OPENAI_SEARCH_MODEL_NAMES = [
+    metadata["name"]
+    for metadata in OPENAI_MODELS_DETAILED
+    if metadata.get("search", False) and not metadata.get("not_supported", False)
+]
+
+NOT_SUPPORTED_MODELS = [metadata["name"] for metadata in OPENAI_MODELS_DETAILED if metadata.get("not_supported", False)]
+
+OPENAI_EMBEDDING_MODEL_NAMES = [
+    "text-embedding-3-small",
+    "text-embedding-3-large",
+    "text-embedding-ada-002",
+]
+
+# Backwards compatibility
+MODEL_NAMES = OPENAI_CHAT_MODEL_NAMES
+OPENAI_MODEL_NAMES = OPENAI_CHAT_MODEL_NAMES

lfx/base/models/sambanova_constants.py

@@ -0,0 +1,18 @@
+SAMBANOVA_MODEL_NAMES = [
+    "Meta-Llama-3.3-70B-Instruct",
+    "Meta-Llama-3.1-8B-Instruct",
+    "Meta-Llama-3.1-70B-Instruct",
+    "Meta-Llama-3.1-405B-Instruct",
+    "DeepSeek-R1-Distill-Llama-70B",
+    "DeepSeek-R1",
+    "Meta-Llama-3.2-1B-Instruct",
+    "Meta-Llama-3.2-3B-Instruct",
+    "Llama-3.2-11B-Vision-Instruct",
+    "Llama-3.2-90B-Vision-Instruct",
+    "Qwen2.5-Coder-32B-Instruct",
+    "Qwen2.5-72B-Instruct",
+    "QwQ-32B-Preview",
+    "Qwen2-Audio-7B-Instruct",
+]
+
+MODEL_NAMES = SAMBANOVA_MODEL_NAMES

lfx/base/prompts/api_utils.py

@@ -0,0 +1,224 @@
+from collections import defaultdict
+from typing import Any
+
+from fastapi import HTTPException
+from langchain_core.prompts import PromptTemplate
+
+from lfx.inputs.inputs import DefaultPromptField
+from lfx.interface.utils import extract_input_variables_from_prompt
+from lfx.log.logger import logger
+
+_INVALID_CHARACTERS = {
+    " ",
+    ",",
+    ".",
+    ":",
+    ";",
+    "!",
+    "?",
+    "/",
+    "\\",
+    "(",
+    ")",
+    "[",
+    "]",
+}
+
+_INVALID_NAMES = {
+    "code",
+    "input_variables",
+    "output_parser",
+    "partial_variables",
+    "template",
+    "template_format",
+    "validate_template",
+}
+
+
+def _is_json_like(var):
+    if var.startswith("{{") and var.endswith("}}"):
+        # If it is a double brance variable
+        # we don't want to validate any of its content
+        return True
+    # the above doesn't work on all cases because the json string can be multiline
+    # or indented which can add \n or spaces at the start or end of the string
+    # test_case_3 new_var == '\n{{\n    "test": "hello",\n    "text": "world"\n}}\n'
+    # what we can do is to remove the \n and spaces from the start and end of the string
+    # and then check if the string starts with {{ and ends with }}
+    var = var.strip()
+    var = var.replace("\n", "")
+    var = var.replace(" ", "")
+    # Now it should be a valid json string
+    return var.startswith("{{") and var.endswith("}}")
+
+
+def _fix_variable(var, invalid_chars, wrong_variables):
+    if not var:
+        return var, invalid_chars, wrong_variables
+    new_var = var
+
+    # Handle variables starting with a number
+    if var[0].isdigit():
+        invalid_chars.append(var[0])
+        new_var, invalid_chars, wrong_variables = _fix_variable(var[1:], invalid_chars, wrong_variables)
+
+    # Temporarily replace {{ and }} to avoid treating them as invalid
+    new_var = new_var.replace("{{", "ᴛᴇᴍᴘᴏᴘᴇɴ").replace("}}", "ᴛᴇᴍᴘᴄʟᴏsᴇ")  # noqa: RUF001
+
+    # Remove invalid characters
+    for char in new_var:
+        if char in _INVALID_CHARACTERS:
+            invalid_chars.append(char)
+            new_var = new_var.replace(char, "")
+            if var not in wrong_variables:  # Avoid duplicating entries
+                wrong_variables.append(var)
+
+    # Restore {{ and }}
+    new_var = new_var.replace("ᴛᴇᴍᴘᴏᴘᴇɴ", "{{").replace("ᴛᴇᴍᴘᴄʟᴏsᴇ", "}}")  # noqa: RUF001
+
+    return new_var, invalid_chars, wrong_variables
+
+
+def _check_variable(var, invalid_chars, wrong_variables, empty_variables):
+    if any(char in invalid_chars for char in var):
+        wrong_variables.append(var)
+    elif var == "":
+        empty_variables.append(var)
+    return wrong_variables, empty_variables
+
+
+def _check_for_errors(input_variables, fixed_variables, wrong_variables, empty_variables) -> None:
+    if any(var for var in input_variables if var not in fixed_variables):
+        error_message = (
+            f"Error: Input variables contain invalid characters or formats. \n"
+            f"Invalid variables: {', '.join(wrong_variables)}.\n"
+            f"Empty variables: {', '.join(empty_variables)}. \n"
+            f"Fixed variables: {', '.join(fixed_variables)}."
+        )
+        raise ValueError(error_message)
+
+
+def _check_input_variables(input_variables):
+    invalid_chars = []
+    fixed_variables = []
+    wrong_variables = []
+    empty_variables = []
+    variables_to_check = []
+
+    for var in input_variables:
+        # First, let's check if the variable is a JSON string
+        # because if it is, it won't be considered a variable
+        # and we don't need to validate it
+        if _is_json_like(var):
+            continue
+
+        new_var, wrong_variables, empty_variables = _fix_variable(var, invalid_chars, wrong_variables)
+        wrong_variables, empty_variables = _check_variable(var, _INVALID_CHARACTERS, wrong_variables, empty_variables)
+        fixed_variables.append(new_var)
+        variables_to_check.append(var)
+
+    _check_for_errors(variables_to_check, fixed_variables, wrong_variables, empty_variables)
+
+    return fixed_variables
+
+
+def validate_prompt(prompt_template: str, *, silent_errors: bool = False) -> list[str]:
+    input_variables = extract_input_variables_from_prompt(prompt_template)
+
+    # Check if there are invalid characters in the input_variables
+    input_variables = _check_input_variables(input_variables)
+    if any(var in _INVALID_NAMES for var in input_variables):
+        msg = f"Invalid input variables. None of the variables can be named {', '.join(input_variables)}. "
+        raise ValueError(msg)
+
+    try:
+        PromptTemplate(template=prompt_template, input_variables=input_variables)
+    except Exception as exc:
+        msg = f"Invalid prompt: {exc}"
+        logger.exception(msg)
+        if not silent_errors:
+            raise ValueError(msg) from exc
+
+    return input_variables
+
+
+def get_old_custom_fields(custom_fields, name):
+    try:
+        if len(custom_fields) == 1 and name == "":
+            # If there is only one custom field and the name is empty string
+            # then we are dealing with the first prompt request after the node was created
+            name = next(iter(custom_fields.keys()))
+
+        old_custom_fields = custom_fields[name]
+        if not old_custom_fields:
+            old_custom_fields = []
+
+        old_custom_fields = old_custom_fields.copy()
+    except KeyError:
+        old_custom_fields = []
+    custom_fields[name] = []
+    return old_custom_fields
+
+
+def add_new_variables_to_template(input_variables, custom_fields, template, name) -> None:
+    for variable in input_variables:
+        try:
+            template_field = DefaultPromptField(name=variable, display_name=variable)
+            if variable in template:
+                # Set the new field with the old value
+                template_field.value = template[variable]["value"]
+
+            template[variable] = template_field.to_dict()
+
+            # Check if variable is not already in the list before appending
+            if variable not in custom_fields[name]:
+                custom_fields[name].append(variable)
+
+        except Exception as exc:
+            raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
+def remove_old_variables_from_template(old_custom_fields, input_variables, custom_fields, template, name) -> None:
+    for variable in old_custom_fields:
+        if variable not in input_variables:
+            try:
+                # Remove the variable from custom_fields associated with the given name
+                if variable in custom_fields[name]:
+                    custom_fields[name].remove(variable)
+
+                # Remove the variable from the template
+                template.pop(variable, None)
+
+            except Exception as exc:
+                raise HTTPException(status_code=500, detail=str(exc)) from exc
+
+
+def update_input_variables_field(input_variables, template) -> None:
+    if "input_variables" in template:
+        template["input_variables"]["value"] = input_variables
+
+
+def process_prompt_template(
+    template: str, name: str, custom_fields: dict[str, list[str]] | None, frontend_node_template: dict[str, Any]
+):
+    """Process and validate prompt template, update template and custom fields."""
+    # Validate the prompt template and extract input variables
+    input_variables = validate_prompt(template)
+
+    # Initialize custom_fields if None
+    if custom_fields is None:
+        custom_fields = defaultdict(list)
+
+    # Retrieve old custom fields
+    old_custom_fields = get_old_custom_fields(custom_fields, name)
+
+    # Add new variables to the template
+    add_new_variables_to_template(input_variables, custom_fields, frontend_node_template, name)
+
+    # Remove old variables from the template
+    remove_old_variables_from_template(old_custom_fields, input_variables, custom_fields, frontend_node_template, name)
+
+    # Update the input variables field in the template
+    update_input_variables_field(input_variables, frontend_node_template)
+
+    return input_variables

lfx/base/prompts/utils.py

@@ -0,0 +1,61 @@
+from copy import deepcopy
+
+from langchain_core.documents import Document
+
+from lfx.schema.data import Data
+
+
+def data_to_string(record: Data) -> str:
+    """Convert a record to a string.
+
+    Args:
+        record (Data): The record to convert.
+
+    Returns:
+        str: The record as a string.
+    """
+    return record.get_text()
+
+
+def dict_values_to_string(d: dict) -> dict:
+    """Converts the values of a dictionary to strings.
+
+    Args:
+        d (dict): The dictionary whose values need to be converted.
+
+    Returns:
+        dict: The dictionary with values converted to strings.
+    """
+    from lfx.schema.message import Message
+
+    # Do something similar to the above
+    d_copy = deepcopy(d)
+    for key, value in d_copy.items():
+        # it could be a list of data or documents or strings
+        if isinstance(value, list):
+            for i, item in enumerate(value):
+                if isinstance(item, Message):
+                    d_copy[key][i] = item.text
+                elif isinstance(item, Data):
+                    d_copy[key][i] = data_to_string(item)
+                elif isinstance(item, Document):
+                    d_copy[key][i] = document_to_string(item)
+        elif isinstance(value, Message):
+            d_copy[key] = value.text
+        elif isinstance(value, Data):
+            d_copy[key] = data_to_string(value)
+        elif isinstance(value, Document):
+            d_copy[key] = document_to_string(value)
+    return d_copy
+
+
+def document_to_string(document: Document) -> str:
+    """Convert a document to a string.
+
+    Args:
+        document (Document): The document to convert.
+
+    Returns:
+        str: The document as a string.
+    """
+    return document.page_content

lfx/base/textsplitters/model.py

@@ -0,0 +1,28 @@
+from abc import abstractmethod
+
+from langchain_core.documents import BaseDocumentTransformer
+from langchain_text_splitters import TextSplitter
+
+from lfx.base.document_transformers.model import LCDocumentTransformerComponent
+
+
+class LCTextSplitterComponent(LCDocumentTransformerComponent):
+    trace_type = "text_splitter"
+
+    def _validate_outputs(self) -> None:
+        required_output_methods = ["text_splitter"]
+        output_names = [output.name for output in self.outputs]
+        for method_name in required_output_methods:
+            if method_name not in output_names:
+                msg = f"Output with name '{method_name}' must be defined."
+                raise ValueError(msg)
+            if not hasattr(self, method_name):
+                msg = f"Method '{method_name}' must be defined."
+                raise ValueError(msg)
+
+    def build_document_transformer(self) -> BaseDocumentTransformer:
+        return self.build_text_splitter()
+
+    @abstractmethod
+    def build_text_splitter(self) -> TextSplitter:
+        """Build the text splitter."""

lfx/base/tools/base.py

@@ -0,0 +1,26 @@
+from lfx.field_typing import Tool
+
+
+def build_status_from_tool(tool: Tool):
+    """Builds a status string representation of a tool.
+
+    Args:
+        tool (Tool): The tool object to build the status for.
+
+    Returns:
+        str: The status string representation of the tool, including its name, description, arguments (if any),
+            and args_schema (if any).
+    """
+    description_repr = repr(tool.description).strip("'")
+    args_str = "\n".join(
+        [
+            f"- {arg_name}: {arg_data['description']}"
+            for arg_name, arg_data in tool.args.items()
+            if "description" in arg_data
+        ]
+    )
+    # Include args_schema information
+    args_schema_str = repr(tool.args_schema) if tool.args_schema else "None"
+    status = f"Name: {tool.name}\nDescription: {description_repr}"
+    status += f"\nArgs Schema: {args_schema_str}"
+    return status + (f"\nArguments:\n{args_str}" if args_str else "")