feat: Implement tool mode functionality and dynamic placeholders across input components

src/backend/base/langflow/base/agents/agent.py

@@ -10,7 +10,9 @@
 from langflow.base.agents.events import ExceptionWithMessageError, process_agent_events
 from langflow.base.agents.utils import data_to_messages
 from langflow.custom import Component
-from langflow.inputs.inputs import InputTypes
+from langflow.custom.custom_component.component import _get_component_toolkit
+from langflow.field_typing import Tool
+from langflow.inputs.inputs import InputTypes, MultilineInput
 from langflow.io import BoolInput, HandleInput, IntInput, MessageTextInput
 from langflow.memory import delete_message
 from langflow.schema import Data
@@ -24,10 +26,19 @@
     from langchain_core.messages import BaseMessage
 
 
+DEFAULT_TOOLS_DESCRIPTION = "A helpful assistant with access to the following tools:"
+DEFAULT_AGENT_NAME = "Agent ({tools_names})"
+
+
 class LCAgentComponent(Component):
     trace_type = "agent"
     _base_inputs: list[InputTypes] = [
-        MessageTextInput(name="input_value", display_name="Input"),
+        MessageTextInput(
+            name="input_value",
+            display_name="Input",
+            info="The input provided by the user for the agent to process.",
+            tool_mode=True,
+        ),
         BoolInput(
             name="handle_parsing_errors",
             display_name="Handle Parse Errors",
@@ -46,6 +57,16 @@ class LCAgentComponent(Component):
             value=15,
             advanced=True,
         ),
+        MultilineInput(
+            name="agent_description",
+            display_name="Agent Description",
+            info=(
+                "The description of the agent. This is only used when in Tool Mode. "
+                f"Defaults to '{DEFAULT_TOOLS_DESCRIPTION}' and tools are added dynamically."
+            ),
+            advanced=True,
+            value=DEFAULT_TOOLS_DESCRIPTION,
+        ),
     ]
 
     outputs = [
@@ -117,7 +138,7 @@ async def run_agent(
 
         agent_message = Message(
             sender=MESSAGE_SENDER_AI,
-            sender_name="Agent",
+            sender_name=self.display_name or "Agent",
             properties={"icon": "Bot", "state": "partial"},
             content_blocks=[ContentBlock(title="Agent Steps", contents=[])],
             session_id=self.graph.session_id,
@@ -136,7 +157,7 @@ async def run_agent(
             msg_id = e.agent_message.id
             await asyncio.to_thread(delete_message, id_=msg_id)
             self._send_message_event(e.agent_message, category="remove_message")
-            raise e.exception  # noqa: B904
+            raise
         except Exception:
             raise
 
@@ -167,3 +188,28 @@ def build_agent(self) -> AgentExecutor:
     @abstractmethod
     def create_agent_runnable(self) -> Runnable:
         """Create the agent."""
+
+    def get_tool_name(self) -> str:
+        return self.display_name
+
+    def get_tool_description(self) -> str:
+        return self.agent_description or DEFAULT_TOOLS_DESCRIPTION
+
+    def _build_tools_names(self):
+        tools_names = ""
+        if self.tools:
+            tools_names = ", ".join([tool.name for tool in self.tools])
+        return tools_names
+
+    def to_toolkit(self) -> list[Tool]:
+        component_toolkit = _get_component_toolkit()
+        tools_names = self._build_tools_names()
+        agent_description = self.get_tool_description()
+        # Check if tools_description is the default value
+        if agent_description == DEFAULT_TOOLS_DESCRIPTION:
+            description = f"{agent_description}{tools_names}"
+        else:
+            description = agent_description
+        return component_toolkit(component=self).get_tools(
+            tool_name=self.get_tool_name(), tool_description=description, callbacks=self.get_langchain_callbacks()
+        )

src/backend/base/langflow/base/agents/events.py

@@ -252,6 +252,6 @@ async def process_agent_events(
                 agent_message, start_time = chain_handler(event, agent_message, send_message_method, start_time)
                 start_time = start_time or perf_counter()
         agent_message.properties.state = "complete"
-        return Message(**agent_message.model_dump())
     except Exception as e:
         raise ExceptionWithMessageError(e, agent_message) from e
+    return Message(**agent_message.model_dump())

src/backend/base/langflow/base/tools/component_tool.py

@@ -1,24 +1,30 @@
 from __future__ import annotations
 
+import asyncio
 import re
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Literal
 
 from langchain_core.tools import ToolException
 from langchain_core.tools.structured import StructuredTool
 from loguru import logger
+from pydantic import BaseModel
 
 from langflow.base.tools.constants import TOOL_OUTPUT_NAME
 from langflow.io.schema import create_input_schema
+from langflow.schema.data import Data
+from langflow.schema.message import Message
 
 if TYPE_CHECKING:
     from collections.abc import Callable
 
+    from langchain_core.callbacks import Callbacks
     from langchain_core.tools import BaseTool
 
     from langflow.custom.custom_component.component import Component
     from langflow.events.event_manager import EventManager
     from langflow.inputs.inputs import InputTypes
     from langflow.io import Output
+    from langflow.schema.content_types import ContentBlock
 
 
 def _get_input_type(_input: InputTypes):
@@ -47,10 +53,57 @@ def build_description(component: Component, output: Output) -> str:
     return f"{output.method}({args}) - {component.description}"
 
 
+def send_message_noop(
+    message: Message | None = None,
+    text: str | None = None,  # noqa: ARG001
+    background_color: str | None = None,  # noqa: ARG001
+    text_color: str | None = None,  # noqa: ARG001
+    icon: str | None = None,  # noqa: ARG001
+    content_blocks: list[ContentBlock] | None = None,  # noqa: ARG001
+    format_type: Literal["default", "error", "warning", "info"] = "default",  # noqa: ARG001
+    id_: str | None = None,  # noqa: ARG001
+    *,
+    allow_markdown: bool = True,  # noqa: ARG001
+) -> Message:
+    """No-op implementation of send_message."""
+    return message
+
+
+def patch_components_send_message(component: Component):
+    old_send_message = component.send_message
+    component.send_message = send_message_noop
+    return old_send_message
+
+
+def _patch_send_message_decorator(component, func):
+    """Decorator to patch the send_message method of a component.
+
+    This is useful when we want to use a component as a tool, but we don't want to
+    send any messages to the UI. With this only the Component calling the tool
+    will send messages to the UI.
+    """
+
+    async def async_wrapper(*args, **kwargs):
+        original_send_message = component.send_message
+        component.send_message = send_message_noop
+        try:
+            return await func(*args, **kwargs)
+        finally:
+            component.send_message = original_send_message
+
+    def sync_wrapper(*args, **kwargs):
+        original_send_message = component.send_message
+        component.send_message = send_message_noop
+        try:
+            return func(*args, **kwargs)
+        finally:
+            component.send_message = original_send_message
+
+    return async_wrapper if asyncio.iscoroutinefunction(func) else sync_wrapper
+
+
 def _build_output_function(component: Component, output_method: Callable, event_manager: EventManager | None = None):
     def output_function(*args, **kwargs):
-        # set the component with the arguments
-        # set functionality was updatedto handle list of components and other values separately
         try:
             if event_manager:
                 event_manager.on_build_start(data={"id": component._id})
@@ -60,10 +113,40 @@ def output_function(*args, **kwargs):
                 event_manager.on_build_end(data={"id": component._id})
         except Exception as e:
             raise ToolException(e) from e
-        else:
-            return result
 
-    return output_function
+        if isinstance(result, Message):
+            return result.get_text()
+        if isinstance(result, Data):
+            return result.data
+        if isinstance(result, BaseModel):
+            return result.model_dump()
+        return result
+
+    return _patch_send_message_decorator(component, output_function)
+
+
+def _build_output_async_function(
+    component: Component, output_method: Callable, event_manager: EventManager | None = None
+):
+    async def output_function(*args, **kwargs):
+        try:
+            if event_manager:
+                event_manager.on_build_start(data={"id": component._id})
+            component.set(*args, **kwargs)
+            result = await output_method()
+            if event_manager:
+                event_manager.on_build_end(data={"id": component._id})
+        except Exception as e:
+            raise ToolException(e) from e
+        if isinstance(result, Message):
+            return result.get_text()
+        if isinstance(result, Data):
+            return result.data
+        if isinstance(result, BaseModel):
+            return result.model_dump()
+        return result
+
+    return _patch_send_message_decorator(component, output_function)
 
 
 def _format_tool_name(name: str):
@@ -77,7 +160,9 @@ class ComponentToolkit:
     def __init__(self, component: Component):
         self.component = component
 
-    def get_tools(self) -> list[BaseTool]:
+    def get_tools(
+        self, tool_name: str | None = None, tool_description: str | None = None, callbacks: Callbacks | None = None
+    ) -> list[BaseTool]:
         tools = []
         for output in self.component.outputs:
             if output.name == TOOL_OUTPUT_NAME:
@@ -89,23 +174,56 @@ def get_tools(self) -> list[BaseTool]:
 
             output_method: Callable = getattr(self.component, output.method)
             args_schema = None
+            tool_mode_inputs = [_input for _input in self.component.inputs if getattr(_input, "tool_mode", False)]
             if output.required_inputs:
                 inputs = [self.component._inputs[input_name] for input_name in output.required_inputs]
+                # If any of the required inputs are not in tool mode, this means
+                # that when the tool is called it will raise an error.
+                # so we should raise an error here.
+                if not all(getattr(_input, "tool_mode", False) for _input in inputs):
+                    non_tool_mode_inputs = [input_.name for input_ in inputs if not getattr(input_, "tool_mode", False)]
+                    msg = (
+                        f"Output '{output.name}' requires inputs that are not in tool mode. "
+                        f"The following inputs are not in tool mode: {', '.join(non_tool_mode_inputs)}. "
+                        "Please ensure all required inputs are set to tool mode."
+                    )
+                    raise ValueError(msg)
                 args_schema = create_input_schema(inputs)
             else:
-                args_schema = create_input_schema(self.component.inputs)
+                args_schema = create_input_schema(tool_mode_inputs)
             name = f"{self.component.name}.{output.method}"
             formatted_name = _format_tool_name(name)
-            tools.append(
-                StructuredTool(
-                    name=formatted_name,
-                    description=build_description(component=self.component, output=output),
-                    func=_build_output_function(
-                        component=self.component,
-                        output_method=output_method,
-                        event_manager=self.component._event_manager,
-                    ),
-                    args_schema=args_schema,
+            event_manager = self.component._event_manager
+            if asyncio.iscoroutinefunction(output_method):
+                tools.append(
+                    StructuredTool(
+                        name=formatted_name,
+                        description=build_description(self.component, output),
+                        coroutine=_build_output_async_function(self.component, output_method, event_manager),
+                        args_schema=args_schema,
+                        handle_tool_error=True,
+                        callbacks=callbacks,
+                    )
+                )
+            else:
+                tools.append(
+                    StructuredTool(
+                        name=formatted_name,
+                        description=build_description(self.component, output),
+                        func=_build_output_function(self.component, output_method, event_manager),
+                        args_schema=args_schema,
+                        handle_tool_error=True,
+                        callbacks=callbacks,
+                    )
                 )
+        if len(tools) == 1 and (tool_name or tool_description):
+            tool = tools[0]
+            tool.name = tool_name or tool.name
+            tool.description = tool_description or tool.description
+        elif tool_name or tool_description:
+            msg = (
+                "When passing a tool name or description, there must be only one tool, "
+                f"but {len(tools)} tools were found."
             )
+            raise ValueError(msg)
         return tools

src/backend/base/langflow/base/tools/constants.py

@@ -1 +1,2 @@
 TOOL_OUTPUT_NAME = "component_as_tool"
+TOOL_OUTPUT_DISPLAY_NAME = "Toolset"

src/backend/base/langflow/components/agents/agent.py

@@ -42,24 +42,24 @@ class AgentComponent(ToolCallingAgentComponent):
         *LCToolsAgentComponent._base_inputs,
         *memory_inputs,
     ]
-    outputs = [Output(name="response", display_name="Response", method="get_response")]
+    outputs = [Output(name="response", display_name="Response", method="message_response")]
 
-    async def get_response(self) -> Message:
+    async def message_response(self) -> Message:
         llm_model = self.get_llm()
         if llm_model is None:
             msg = "No language model selected"
             raise ValueError(msg)
         self.chat_history = self.get_memory_data()
 
-        agent = self.set(
+        self.set(
             llm=llm_model,
             tools=[self.tools],
             chat_history=self.chat_history,
             input_value=self.input_value,
             system_prompt=self.system_prompt,
         )
-
-        return await agent.message_response()
+        agent = self.create_agent_runnable()
+        return await self.run_agent(agent)
 
     def get_memory_data(self):
         memory_kwargs = {

src/backend/base/langflow/components/agents/tool_calling.py

@@ -23,11 +23,6 @@ class ToolCallingAgentComponent(LCToolsAgentComponent):
             info="Initial instructions and context provided to guide the agent's behavior.",
             value="You are a helpful assistant that can use tools to answer questions and perform tasks.",
         ),
-        MessageTextInput(
-            name="input_value",
-            display_name="Input",
-            info="The input provided by the user for the agent to process.",
-        ),
         DataInput(name="chat_history", display_name="Chat Memory", is_list=True, advanced=True),
     ]
 

src/backend/base/langflow/components/custom_component/custom_component.py

@@ -12,7 +12,7 @@ class CustomComponent(Component):
     name = "CustomComponent"
 
     inputs = [
-        MessageTextInput(name="input_value", display_name="Input Value", value="Hello, World!"),
+        MessageTextInput(name="input_value", display_name="Input Value", value="Hello, World!", tool_mode=True),
     ]
 
     outputs = [

src/backend/base/langflow/components/outputs/chat.py

@@ -101,7 +101,7 @@ def message_response(self) -> Message:
         message.sender_name = self.sender_name
         message.session_id = self.session_id
         message.flow_id = self.graph.flow_id
-        message.properties.source = Source(id=_source_id, display_name=_display_name, source=_source)
+        message.properties.source = self._build_source(_source_id, _display_name, _source)
         message.properties.icon = _icon
         message.properties.background_color = _background_color
         message.properties.text_color = _text_color

src/backend/base/langflow/custom/attributes.py

@@ -73,4 +73,5 @@ def getattr_return_dict(value):
     "outputs": getattr_return_list_of_object,
     "inputs": getattr_return_list_of_object,
     "metadata": getattr_return_dict,
+    "tool_mode": getattr_return_bool,
 }