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

lfx/base/agents/agent.py

@@ -185,8 +185,10 @@ class LCAgentComponent(Component):
         if "input" not in input_dict:
             input_dict = {"input": self.input_value}
 
-        if hasattr(self, "system_prompt") and self.system_prompt and self.system_prompt.strip():
-            input_dict["system_prompt"] = self.system_prompt
+        # Use enhanced prompt if available (set by IBM Granite handler), otherwise use original
+        system_prompt_to_use = getattr(self, "_effective_system_prompt", None) or self.system_prompt
+        if system_prompt_to_use and system_prompt_to_use.strip():
+            input_dict["system_prompt"] = system_prompt_to_use
 
         if hasattr(self, "chat_history") and self.chat_history:
             if isinstance(self.chat_history, Data):
@@ -272,9 +274,11 @@ class LCAgentComponent(Component):
                 on_token_callback,
             )
         except ExceptionWithMessageError as e:
-            if hasattr(e, "agent_message") and hasattr(e.agent_message, "id"):
-                msg_id = e.agent_message.id
-                await delete_message(id_=msg_id)
+            # Only delete message from database if it has an ID (was stored)
+            if hasattr(e, "agent_message"):
+                msg_id = e.agent_message.get_id()
+                if msg_id:
+                    await delete_message(id_=msg_id)
             await self._send_message_event(e.agent_message, category="remove_message")
             logger.error(f"ExceptionWithMessageError: {e}")
             raise

lfx/base/agents/altk_base_agent.py

@@ -378,9 +378,11 @@ class ALTKBaseAgentComponent(AgentComponent):
                 cast("SendMessageFunctionType", self.send_message),
             )
         except ExceptionWithMessageError as e:
-            if hasattr(e, "agent_message") and hasattr(e.agent_message, "id"):
-                msg_id = e.agent_message.id
-                await delete_message(id_=msg_id)
+            # Only delete message from database if it has an ID (was stored)
+            if hasattr(e, "agent_message"):
+                msg_id = e.agent_message.get_id()
+                if msg_id:
+                    await delete_message(id_=msg_id)
             await self._send_message_event(e.agent_message, category="remove_message")
             logger.error(f"ExceptionWithMessageError: {e}")
             raise

lfx/base/agents/events.py

@@ -388,7 +388,7 @@ async def process_agent_events(
     agent_message = await send_message_callback(message=agent_message)
     # Capture the original message id - this must stay consistent throughout if streaming
     # Message may not contain id if the Agent is not connected to a Chat Output (_should_skip_message is True)
-    initial_message_id = agent_message.id if hasattr(agent_message, "id") else None
+    initial_message_id = agent_message.get_id()
     try:
         # Create a mapping of run_ids to tool contents
         tool_blocks_map: dict[str, ToolContent] = {}

lfx/base/models/unified_models.py

@@ -75,7 +75,7 @@ def get_model_provider_metadata():
             "icon": "Ollama",
             "variable_name": "OLLAMA_BASE_URL",  # Ollama is local but can have custom URL
         },
-        "IBM Watsonx": {
+        "IBM WatsonX": {
             "icon": "WatsonxAI",
             "variable_name": "WATSONX_APIKEY",
         },

lfx/base/models/watsonx_constants.py

@@ -2,52 +2,55 @@ from .model_metadata import create_model_metadata
 
 WATSONX_DEFAULT_LLM_MODELS = [
     create_model_metadata(
-        provider="IBM Watsonx",
+        provider="IBM WatsonX",
         name="ibm/granite-3-2b-instruct",
         icon="WatsonxAI",
         model_type="llm",
+        tool_calling=False,
         default=True,
     ),
     create_model_metadata(
-        provider="IBM Watsonx",
+        provider="IBM WatsonX",
         name="ibm/granite-3-8b-instruct",
         icon="WatsonxAI",
         model_type="llm",
+        tool_calling=True,
         default=True,
     ),
     create_model_metadata(
-        provider="IBM Watsonx",
+        provider="IBM WatsonX",
         name="ibm/granite-13b-instruct-v2",
         icon="WatsonxAI",
         model_type="llm",
+        tool_calling=False,
         default=True,
     ),
 ]
 
 WATSONX_DEFAULT_EMBEDDING_MODELS = [
     create_model_metadata(
-        provider="IBM Watsonx",
+        provider="IBM WatsonX",
         name="sentence-transformers/all-minilm-l12-v2",
         icon="WatsonxAI",
         model_type="embeddings",
         default=True,
     ),
     create_model_metadata(
-        provider="IBM Watsonx",
+        provider="IBM WatsonX",
         name="ibm/slate-125m-english-rtrvr-v2",
         icon="WatsonxAI",
         model_type="embeddings",
         default=True,
     ),
     create_model_metadata(
-        provider="IBM Watsonx",
+        provider="IBM WatsonX",
         name="ibm/slate-30m-english-rtrvr-v2",
         icon="WatsonxAI",
         model_type="embeddings",
         default=True,
     ),
     create_model_metadata(
-        provider="IBM Watsonx",
+        provider="IBM WatsonX",
         name="intfloat/multilingual-e5-large",
         icon="WatsonxAI",
         model_type="embeddings",

lfx/base/prompts/api_utils.py

@@ -3,6 +3,7 @@ from typing import Any
 
 from fastapi import HTTPException
 from langchain_core.prompts import PromptTemplate
+from langchain_core.prompts.string import mustache_template_vars
 
 from lfx.inputs.inputs import DefaultPromptField
 from lfx.interface.utils import extract_input_variables_from_prompt
@@ -90,7 +91,7 @@ def _check_variable(var, invalid_chars, 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"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)}."
@@ -122,8 +123,37 @@ def _check_input_variables(input_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)
+def validate_prompt(prompt_template: str, *, silent_errors: bool = False, is_mustache: bool = False) -> list[str]:
+    if is_mustache:
+        # Extract only mustache variables
+        try:
+            input_variables = mustache_template_vars(prompt_template)
+        except Exception as exc:
+            # Mustache parser errors are often cryptic (e.g., "unclosed tag at line 1")
+            # Provide a more helpful error message
+            error_str = str(exc).lower()
+            if "unclosed" in error_str or "tag" in error_str:
+                msg = "Invalid template syntax. Check that all {{variables}} have matching opening and closing braces."
+            else:
+                msg = f"Invalid mustache template: {exc}"
+            raise ValueError(msg) from exc
+
+        # Also get f-string variables to filter them out
+        fstring_vars = extract_input_variables_from_prompt(prompt_template)
+
+        # Only keep variables that are actually in mustache syntax (not in f-string syntax)
+        # This handles cases where template has both {var} and {{var}}
+        input_variables = [v for v in input_variables if v not in fstring_vars or f"{{{{{v}}}}}" in prompt_template]
+    else:
+        # Extract f-string variables
+        input_variables = extract_input_variables_from_prompt(prompt_template)
+
+        # Also get mustache variables to filter them out
+        mustache_vars = mustache_template_vars(prompt_template)
+
+        # Only keep variables that are NOT in mustache syntax
+        # This handles cases where template has both {var} and {{var}}
+        input_variables = [v for v in input_variables if v not in mustache_vars]
 
     # Check if there are invalid characters in the input_variables
     input_variables = _check_input_variables(input_variables)
@@ -199,11 +229,16 @@ def update_input_variables_field(input_variables, template) -> None:
 
 
 def process_prompt_template(
-    template: str, name: str, custom_fields: dict[str, list[str]] | None, frontend_node_template: dict[str, Any]
+    template: str,
+    name: str,
+    custom_fields: dict[str, list[str]] | None,
+    frontend_node_template: dict[str, Any],
+    *,
+    is_mustache: bool = False,
 ):
     """Process and validate prompt template, update template and custom fields."""
     # Validate the prompt template and extract input variables
-    input_variables = validate_prompt(template)
+    input_variables = validate_prompt(template, is_mustache=is_mustache)
 
     # Initialize custom_fields if None
     if custom_fields is None:

lfx/cli/__init__.py

@@ -1,5 +1,13 @@
 """LFX CLI module for serving flows."""
 
-from lfx.cli.commands import serve_command
-
 __all__ = ["serve_command"]
+
+
+def __getattr__(name: str):
+    """Lazy import for serve_command."""
+    if name == "serve_command":
+        from lfx.cli.commands import serve_command
+
+        return serve_command
+    msg = f"module {__name__!r} has no attribute {name!r}"
+    raise AttributeError(msg)

lfx/cli/script_loader.py

@@ -15,9 +15,8 @@ from typing import TYPE_CHECKING, Any
 
 import typer
 
-from lfx.graph import Graph
-
 if TYPE_CHECKING:
+    from lfx.graph import Graph
     from lfx.schema.message import Message
 
 
@@ -59,8 +58,10 @@ def _load_module_from_script(script_path: Path) -> Any:
     return module
 
 
-def _validate_graph_instance(graph_obj: Any) -> Graph:
+def _validate_graph_instance(graph_obj: Any) -> "Graph":
     """Extract information from a graph object."""
+    from lfx.graph import Graph
+
     if not isinstance(graph_obj, Graph):
         msg = f"Graph object is not a LFX Graph instance: {type(graph_obj)}"
         raise TypeError(msg)
@@ -82,7 +83,7 @@ def _validate_graph_instance(graph_obj: Any) -> Graph:
     return graph_obj
 
 
-async def load_graph_from_script(script_path: Path) -> Graph:
+async def load_graph_from_script(script_path: Path) -> "Graph":
     """Load and execute a Python script to extract the 'graph' variable or call 'get_graph' function.
 
     Args:

lfx/cli/validation.py

@@ -1,9 +1,10 @@
 """Validation utilities for CLI commands."""
 
 import re
+from typing import TYPE_CHECKING
 
-from lfx.graph.graph.base import Graph
-from lfx.services.deps import get_settings_service
+if TYPE_CHECKING:
+    from lfx.graph.graph.base import Graph
 
 
 def is_valid_env_var_name(name: str) -> bool:
@@ -26,7 +27,7 @@ def is_valid_env_var_name(name: str) -> bool:
     return bool(re.match(pattern, name))
 
 
-def validate_global_variables_for_env(graph: Graph) -> list[str]:
+def validate_global_variables_for_env(graph: "Graph") -> list[str]:
     """Validate that all global variables with load_from_db=True can be used as environment variables.
 
     When the database is not available (noop mode), global variables with load_from_db=True
@@ -39,6 +40,8 @@ def validate_global_variables_for_env(graph: Graph) -> list[str]:
     Returns:
         list[str]: List of error messages for invalid variable names
     """
+    from lfx.services.deps import get_settings_service
+
     errors = []
     settings_service = get_settings_service()
 

lfx/components/datastax/astradb_assistant_manager.py

@@ -299,8 +299,10 @@ class AstraAssistantManager(ComponentWithCache):
                 )
                 self.status = processed_result
         except ExceptionWithMessageError as e:
-            msg_id = e.agent_message.id
-            await delete_message(id_=msg_id)
+            # Only delete message from database if it has an ID (was stored)
+            msg_id = e.agent_message.get_id()
+            if msg_id:
+                await delete_message(id_=msg_id)
             await self._send_message_event(e.agent_message, category="remove_message")
             raise
         except Exception:

lfx/components/docling/docling_remote.py

@@ -39,6 +39,7 @@ class DoclingRemoteComponent(BaseFileComponent):
         "htm",
         "html",
         "jpeg",
+        "jpg",
         "json",
         "md",
         "pdf",

lfx/components/langchain_utilities/ibm_granite_handler.py

@@ -0,0 +1,211 @@
+"""IBM WatsonX-specific tool calling logic.
+
+This module contains all the specialized handling for IBM WatsonX models
+which have different tool calling behavior compared to other LLMs.
+
+The tool calling issues affect ALL models on the WatsonX platform,
+not just Granite models. This includes:
+- meta-llama models
+- mistral models
+- granite models
+- any other model running through WatsonX
+"""
+
+import re
+
+from langchain.agents.format_scratchpad.tools import format_to_tool_messages
+from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnableLambda
+
+from lfx.log.logger import logger
+
+# Pattern to detect placeholder usage in tool arguments
+PLACEHOLDER_PATTERN = re.compile(
+    r"<[^>]*(?:result|value|output|response|data|from|extract|previous|current|date|input|query|search|tool)[^>]*>",
+    re.IGNORECASE,
+)
+
+
+def is_watsonx_model(llm) -> bool:
+    """Check if the LLM is an IBM WatsonX model (any model, not just Granite).
+
+    This detects the provider (WatsonX) rather than a specific model,
+    since tool calling issues affect all models on the WatsonX platform.
+    """
+    # Check class name for WatsonX (e.g., ChatWatsonx)
+    class_name = type(llm).__name__.lower()
+    if "watsonx" in class_name:
+        return True
+
+    # Fallback: check module name (e.g., langchain_ibm)
+    module_name = getattr(type(llm), "__module__", "").lower()
+    return "watsonx" in module_name or "langchain_ibm" in module_name
+
+
+def is_granite_model(llm) -> bool:
+    """Check if the LLM is an IBM Granite model.
+
+    DEPRECATED: Use is_watsonx_model() instead.
+    Kept for backwards compatibility.
+    """
+    model_id = getattr(llm, "model_id", getattr(llm, "model_name", ""))
+    return "granite" in str(model_id).lower()
+
+
+def _get_tool_schema_description(tool) -> str:
+    """Extract a brief description of the tool's expected parameters.
+
+    Returns empty string if schema extraction fails (graceful degradation).
+    """
+    if not hasattr(tool, "args_schema") or not tool.args_schema:
+        return ""
+
+    schema = tool.args_schema
+    if not hasattr(schema, "model_fields"):
+        return ""
+
+    try:
+        fields = schema.model_fields
+        params = []
+        for name, field in fields.items():
+            required = field.is_required() if hasattr(field, "is_required") else True
+            req_str = "(required)" if required else "(optional)"
+            params.append(f"{name} {req_str}")
+        return f"Parameters: {', '.join(params)}" if params else ""
+    except (AttributeError, TypeError) as e:
+        logger.debug(f"Could not extract schema for tool {getattr(tool, 'name', 'unknown')}: {e}")
+        return ""
+
+
+def get_enhanced_system_prompt(base_prompt: str, tools: list) -> str:
+    """Enhance system prompt for WatsonX models with tool usage instructions."""
+    if not tools or len(tools) <= 1:
+        return base_prompt
+
+    # Build detailed tool descriptions with their parameters
+    tool_descriptions = []
+    for t in tools:
+        schema_desc = _get_tool_schema_description(t)
+        if schema_desc:
+            tool_descriptions.append(f"- {t.name}: {schema_desc}")
+        else:
+            tool_descriptions.append(f"- {t.name}")
+
+    tools_section = "\n".join(tool_descriptions)
+
+    # Note: "one tool at a time" is a WatsonX platform limitation, not a design choice.
+    # WatsonX models don't reliably support parallel tool calls.
+    enhancement = f"""
+
+TOOL USAGE GUIDELINES:
+
+1. ALWAYS call tools when you need information - never say "I cannot" or "I don't have access".
+2. Call one tool at a time, then use its result before calling another tool.
+3. Use ACTUAL values in tool arguments - never use placeholder syntax like <result-from-...>.
+4. Each tool has specific parameters - use the correct ones for each tool.
+
+AVAILABLE TOOLS:
+{tools_section}"""
+
+    return base_prompt + enhancement
+
+
+def detect_placeholder_in_args(tool_calls: list) -> tuple[bool, str | None]:
+    """Detect if any tool call contains placeholder syntax in its arguments."""
+    if not tool_calls:
+        return False, None
+
+    for tool_call in tool_calls:
+        args = tool_call.get("args", {})
+        if isinstance(args, dict):
+            for key, value in args.items():
+                if isinstance(value, str) and PLACEHOLDER_PATTERN.search(value):
+                    tool_name = tool_call.get("name", "unknown")
+                    logger.warning(f"[IBM WatsonX] Detected placeholder: {tool_name}.{key}={value}")
+                    return True, value
+        elif isinstance(args, str) and PLACEHOLDER_PATTERN.search(args):
+            logger.warning(f"[IBM WatsonX] Detected placeholder in args: {args}")
+            return True, args
+    return False, None
+
+
+def _limit_to_single_tool_call(llm_response):
+    """Limit response to single tool call (WatsonX platform limitation)."""
+    if not hasattr(llm_response, "tool_calls") or not llm_response.tool_calls:
+        return llm_response
+
+    if len(llm_response.tool_calls) > 1:
+        logger.debug(f"[WatsonX] Limiting {len(llm_response.tool_calls)} tool calls to 1")
+        llm_response.tool_calls = [llm_response.tool_calls[0]]
+
+    return llm_response
+
+
+def _handle_placeholder_in_response(llm_response, messages, llm_auto):
+    """Re-invoke with corrective message if placeholder syntax detected."""
+    if not hasattr(llm_response, "tool_calls") or not llm_response.tool_calls:
+        return llm_response
+
+    has_placeholder, _ = detect_placeholder_in_args(llm_response.tool_calls)
+    if not has_placeholder:
+        return llm_response
+
+    logger.warning("[WatsonX] Placeholder detected, requesting actual values")
+    from langchain_core.messages import SystemMessage
+
+    corrective_msg = SystemMessage(
+        content="Provide your final answer using the actual values from previous tool results."
+    )
+    messages_list = list(messages.messages) if hasattr(messages, "messages") else list(messages)
+    messages_list.append(corrective_msg)
+    return llm_auto.invoke(messages_list)
+
+
+def create_granite_agent(llm, tools: list, prompt: ChatPromptTemplate, forced_iterations: int = 2):
+    """Create a tool calling agent for IBM WatsonX/Granite models.
+
+    Why this exists: WatsonX models have platform-specific tool calling behavior:
+    - With tool_choice='auto': Models often describe tools in text instead of calling them
+    - With tool_choice='required': Models can't provide final answers (causes infinite loops)
+    - Models only reliably support single tool calls per turn
+
+    Solution: Dynamic switching between 'required' (to force tool use) and 'auto' (to allow answers).
+
+    Args:
+        llm: WatsonX language model instance
+        tools: Available tools for the agent
+        prompt: Chat prompt template
+        forced_iterations: Iterations to force tool_choice='required' before allowing 'auto'
+
+    Returns:
+        Runnable agent chain compatible with AgentExecutor
+    """
+    if not hasattr(llm, "bind_tools"):
+        msg = "WatsonX handler requires a language model with bind_tools support."
+        raise ValueError(msg)
+
+    llm_required = llm.bind_tools(tools or [], tool_choice="required")
+    llm_auto = llm.bind_tools(tools or [], tool_choice="auto")
+
+    def invoke(inputs: dict):
+        intermediate_steps = inputs.get("intermediate_steps", [])
+        num_steps = len(intermediate_steps)
+
+        scratchpad = format_to_tool_messages(intermediate_steps)
+        messages = prompt.invoke({**inputs, "agent_scratchpad": scratchpad})
+
+        # Use 'required' for first N iterations, then 'auto' to allow final answers
+        use_required = num_steps < forced_iterations
+        llm_to_use = llm_required if use_required else llm_auto
+        logger.debug(f"[WatsonX] Step {num_steps + 1}, tool_choice={'required' if use_required else 'auto'}")
+
+        response = llm_to_use.invoke(messages)
+        response = _limit_to_single_tool_call(response)
+        return _handle_placeholder_in_response(response, messages, llm_auto)
+
+    return RunnableLambda(invoke) | ToolsAgentOutputParser()
+
+
+# Alias for backwards compatibility
+create_watsonx_agent = create_granite_agent

lfx/components/langchain_utilities/tool_calling.py

@@ -2,6 +2,13 @@ from langchain.agents import create_tool_calling_agent
 from langchain_core.prompts import ChatPromptTemplate
 
 from lfx.base.agents.agent import LCToolsAgentComponent
+
+# IBM Granite-specific logic is in a separate file
+from lfx.components.langchain_utilities.ibm_granite_handler import (
+    create_granite_agent,
+    get_enhanced_system_prompt,
+    is_granite_model,
+)
 from lfx.inputs.inputs import (
     DataInput,
     HandleInput,
@@ -46,8 +53,17 @@ class ToolCallingAgentComponent(LCToolsAgentComponent):
     def create_agent_runnable(self):
         messages = []
 
+        # Use local variable to avoid mutating component state on repeated calls
+        effective_system_prompt = self.system_prompt or ""
+
+        # Enhance prompt for IBM Granite models (they need explicit tool usage instructions)
+        if is_granite_model(self.llm) and self.tools:
+            effective_system_prompt = get_enhanced_system_prompt(effective_system_prompt, self.tools)
+            # Store enhanced prompt for use in agent.py without mutating original
+            self._effective_system_prompt = effective_system_prompt
+
         # Only include system message if system_prompt is provided and not empty
-        if hasattr(self, "system_prompt") and self.system_prompt and self.system_prompt.strip():
+        if effective_system_prompt.strip():
             messages.append(("system", "{system_prompt}"))
 
         messages.extend(
@@ -60,7 +76,14 @@ class ToolCallingAgentComponent(LCToolsAgentComponent):
 
         prompt = ChatPromptTemplate.from_messages(messages)
         self.validate_tool_names()
+
         try:
+            # Use IBM Granite-specific agent if detected
+            # Other WatsonX models (Llama, Mistral, etc.) use default behavior
+            if is_granite_model(self.llm) and self.tools:
+                return create_granite_agent(self.llm, self.tools, prompt)
+
+            # Default behavior for other models (including non-Granite WatsonX models)
             return create_tool_calling_agent(self.llm, self.tools or [], prompt)
         except NotImplementedError as e:
             message = f"{self.display_name} does not support tool calling. Please try using a compatible model."