langflow-base-nightly 0.5.1.dev2__py3-none-any.whl → 0.5.1.dev4__py3-none-any.whl

langflow/base/agents/agent.py

@@ -1,267 +0,0 @@
-import re
-from abc import abstractmethod
-from typing import TYPE_CHECKING, cast
-
-from langchain.agents import AgentExecutor, BaseMultiActionAgent, BaseSingleActionAgent
-from langchain.agents.agent import RunnableAgent
-from langchain_core.messages import HumanMessage
-from langchain_core.runnables import Runnable
-
-from langflow.base.agents.callback import AgentAsyncHandler
-from langflow.base.agents.events import ExceptionWithMessageError, process_agent_events
-from langflow.base.agents.utils import data_to_messages
-from langflow.custom.custom_component.component import Component, _get_component_toolkit
-from langflow.field_typing import Tool
-from langflow.inputs.inputs import InputTypes, MultilineInput
-from langflow.io import BoolInput, HandleInput, IntInput, MessageInput
-from langflow.logging import logger
-from langflow.memory import delete_message
-from langflow.schema.content_block import ContentBlock
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-from langflow.template.field.base import Output
-from langflow.utils.constants import MESSAGE_SENDER_AI
-
-if TYPE_CHECKING:
-    from langchain_core.messages import BaseMessage
-
-    from langflow.schema.log import SendMessageFunctionType
-
-
-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] = [
-        MessageInput(
-            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",
-            value=True,
-            advanced=True,
-            info="Should the Agent fix errors when reading user input for better processing?",
-        ),
-        BoolInput(name="verbose", display_name="Verbose", value=True, advanced=True),
-        IntInput(
-            name="max_iterations",
-            display_name="Max Iterations",
-            value=15,
-            advanced=True,
-            info="The maximum number of attempts the agent can make to complete its task before it stops.",
-        ),
-        MultilineInput(
-            name="agent_description",
-            display_name="Agent Description [Deprecated]",
-            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. "
-                "This feature is deprecated and will be removed in future versions."
-            ),
-            advanced=True,
-            value=DEFAULT_TOOLS_DESCRIPTION,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Agent", name="agent", method="build_agent", hidden=True, tool_mode=False),
-        Output(display_name="Response", name="response", method="message_response"),
-    ]
-
-    @abstractmethod
-    def build_agent(self) -> AgentExecutor:
-        """Create the agent."""
-
-    async def message_response(self) -> Message:
-        """Run the agent and return the response."""
-        agent = self.build_agent()
-        message = await self.run_agent(agent=agent)
-
-        self.status = message
-        return message
-
-    def _validate_outputs(self) -> None:
-        required_output_methods = ["build_agent"]
-        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 get_agent_kwargs(self, *, flatten: bool = False) -> dict:
-        base = {
-            "handle_parsing_errors": self.handle_parsing_errors,
-            "verbose": self.verbose,
-            "allow_dangerous_code": True,
-        }
-        agent_kwargs = {
-            "handle_parsing_errors": self.handle_parsing_errors,
-            "max_iterations": self.max_iterations,
-        }
-        if flatten:
-            return {
-                **base,
-                **agent_kwargs,
-            }
-        return {**base, "agent_executor_kwargs": agent_kwargs}
-
-    def get_chat_history_data(self) -> list[Data] | None:
-        # might be overridden in subclasses
-        return None
-
-    async def run_agent(
-        self,
-        agent: Runnable | BaseSingleActionAgent | BaseMultiActionAgent | AgentExecutor,
-    ) -> Message:
-        if isinstance(agent, AgentExecutor):
-            runnable = agent
-        else:
-            # note the tools are not required to run the agent, hence the validation removed.
-            handle_parsing_errors = hasattr(self, "handle_parsing_errors") and self.handle_parsing_errors
-            verbose = hasattr(self, "verbose") and self.verbose
-            max_iterations = hasattr(self, "max_iterations") and self.max_iterations
-            runnable = AgentExecutor.from_agent_and_tools(
-                agent=agent,
-                tools=self.tools or [],
-                handle_parsing_errors=handle_parsing_errors,
-                verbose=verbose,
-                max_iterations=max_iterations,
-            )
-        input_dict: dict[str, str | list[BaseMessage]] = {
-            "input": self.input_value.to_lc_message() if isinstance(self.input_value, Message) else self.input_value
-        }
-        if hasattr(self, "system_prompt"):
-            input_dict["system_prompt"] = self.system_prompt
-        if hasattr(self, "chat_history") and self.chat_history:
-            if isinstance(self.chat_history, Data):
-                input_dict["chat_history"] = data_to_messages(self.chat_history)
-            if all(isinstance(m, Message) for m in self.chat_history):
-                input_dict["chat_history"] = data_to_messages([m.to_data() for m in self.chat_history])
-        if hasattr(input_dict["input"], "content") and isinstance(input_dict["input"].content, list):
-            # ! Because the input has to be a string, we must pass the images in the chat_history
-
-            image_dicts = [item for item in input_dict["input"].content if item.get("type") == "image"]
-            input_dict["input"].content = [item for item in input_dict["input"].content if item.get("type") != "image"]
-
-            if "chat_history" not in input_dict:
-                input_dict["chat_history"] = []
-            if isinstance(input_dict["chat_history"], list):
-                input_dict["chat_history"].extend(HumanMessage(content=[image_dict]) for image_dict in image_dicts)
-            else:
-                input_dict["chat_history"] = [HumanMessage(content=[image_dict]) for image_dict in image_dicts]
-
-        if hasattr(self, "graph"):
-            session_id = self.graph.session_id
-        elif hasattr(self, "_session_id"):
-            session_id = self._session_id
-        else:
-            session_id = None
-
-        agent_message = Message(
-            sender=MESSAGE_SENDER_AI,
-            sender_name=self.display_name or "Agent",
-            properties={"icon": "Bot", "state": "partial"},
-            content_blocks=[ContentBlock(title="Agent Steps", contents=[])],
-            session_id=session_id,
-        )
-        try:
-            result = await process_agent_events(
-                runnable.astream_events(
-                    input_dict,
-                    config={"callbacks": [AgentAsyncHandler(self.log), *self.get_langchain_callbacks()]},
-                    version="v2",
-                ),
-                agent_message,
-                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)
-            await self._send_message_event(e.agent_message, category="remove_message")
-            logger.error(f"ExceptionWithMessageError: {e}")
-            raise
-        except Exception as e:
-            # Log or handle any other exceptions
-            logger.error(f"Error: {e}")
-            raise
-
-        self.status = result
-        return result
-
-    @abstractmethod
-    def create_agent_runnable(self) -> Runnable:
-        """Create the agent."""
-
-    def validate_tool_names(self) -> None:
-        """Validate tool names to ensure they match the required pattern."""
-        pattern = re.compile(r"^[a-zA-Z0-9_-]+$")
-        if hasattr(self, "tools") and self.tools:
-            for tool in self.tools:
-                if not pattern.match(tool.name):
-                    msg = (
-                        f"Invalid tool name '{tool.name}': must only contain letters, numbers, underscores, dashes,"
-                        " and cannot contain spaces."
-                    )
-                    raise ValueError(msg)
-
-
-class LCToolsAgentComponent(LCAgentComponent):
-    _base_inputs = [
-        HandleInput(
-            name="tools",
-            display_name="Tools",
-            input_types=["Tool"],
-            is_list=True,
-            required=False,
-            info="These are the tools that the agent can use to help with tasks.",
-        ),
-        *LCAgentComponent._base_inputs,
-    ]
-
-    def build_agent(self) -> AgentExecutor:
-        self.validate_tool_names()
-        agent = self.create_agent_runnable()
-        return AgentExecutor.from_agent_and_tools(
-            agent=RunnableAgent(runnable=agent, input_keys_arg=["input"], return_keys_arg=["output"]),
-            tools=self.tools,
-            **self.get_agent_kwargs(flatten=True),
-        )
-
-    @abstractmethod
-    def create_agent_runnable(self) -> Runnable:
-        """Create the agent."""
-
-    def get_tool_name(self) -> str:
-        return self.display_name or "Agent"
-
-    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
-
-    async def _get_tools(self) -> list[Tool]:
-        component_toolkit = _get_component_toolkit()
-        tools_names = self._build_tools_names()
-        agent_description = self.get_tool_description()
-        # TODO: Agent Description Depreciated Feature to be removed
-        description = f"{agent_description}{tools_names}"
-        tools = component_toolkit(component=self).get_tools(
-            tool_name=self.get_tool_name(), tool_description=description, callbacks=self.get_langchain_callbacks()
-        )
-        if hasattr(self, "tools_metadata"):
-            tools = component_toolkit(component=self, metadata=self.tools_metadata).update_tools_metadata(tools=tools)
-        return tools

langflow/base/agents/callback.py

@@ -1,130 +0,0 @@
-from typing import Any
-from uuid import UUID
-
-from langchain.callbacks.base import AsyncCallbackHandler
-from langchain_core.agents import AgentAction, AgentFinish
-
-from langflow.schema.log import LogFunctionType
-
-
-class AgentAsyncHandler(AsyncCallbackHandler):
-    """Async callback handler that can be used to handle callbacks from langchain."""
-
-    def __init__(self, log_function: LogFunctionType | None = None):
-        self.log_function = log_function
-
-    async def on_chain_start(
-        self,
-        serialized: dict[str, Any],
-        inputs: dict[str, Any],
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        if self.log_function is None:
-            return
-        self.log_function(
-            {
-                "type": "chain_start",
-                "serialized": serialized,
-                "inputs": inputs,
-                "run_id": run_id,
-                "parent_run_id": parent_run_id,
-                "tags": tags,
-                "metadata": metadata,
-                **kwargs,
-            },
-            name="Chain Start",
-        )
-
-    async def on_tool_start(
-        self,
-        serialized: dict[str, Any],
-        input_str: str,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        metadata: dict[str, Any] | None = None,
-        inputs: dict[str, Any] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        if self.log_function is None:
-            return
-        self.log_function(
-            {
-                "type": "tool_start",
-                "serialized": serialized,
-                "input_str": input_str,
-                "run_id": run_id,
-                "parent_run_id": parent_run_id,
-                "tags": tags,
-                "metadata": metadata,
-                "inputs": inputs,
-                **kwargs,
-            },
-            name="Tool Start",
-        )
-
-    async def on_tool_end(self, output: Any, *, run_id: UUID, parent_run_id: UUID | None = None, **kwargs: Any) -> None:
-        if self.log_function is None:
-            return
-        self.log_function(
-            {
-                "type": "tool_end",
-                "output": output,
-                "run_id": run_id,
-                "parent_run_id": parent_run_id,
-                **kwargs,
-            },
-            name="Tool End",
-        )
-
-    async def on_agent_action(
-        self,
-        action: AgentAction,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        if self.log_function is None:
-            return
-        self.log_function(
-            {
-                "type": "agent_action",
-                "action": action,
-                "run_id": run_id,
-                "parent_run_id": parent_run_id,
-                "tags": tags,
-                **kwargs,
-            },
-            name="Agent Action",
-        )
-
-    async def on_agent_finish(
-        self,
-        finish: AgentFinish,
-        *,
-        run_id: UUID,
-        parent_run_id: UUID | None = None,
-        tags: list[str] | None = None,
-        **kwargs: Any,
-    ) -> None:
-        if self.log_function is None:
-            return
-        self.log_function(
-            {
-                "type": "agent_finish",
-                "finish": finish,
-                "run_id": run_id,
-                "parent_run_id": parent_run_id,
-                "tags": tags,
-                **kwargs,
-            },
-            name="Agent Finish",
-        )

langflow/base/agents/context.py

@@ -1,109 +0,0 @@
-from datetime import datetime, timezone
-from typing import Any
-
-from langchain_core.language_models import BaseLanguageModel, BaseLLM
-from langchain_core.language_models.chat_models import BaseChatModel
-from pydantic import BaseModel, Field, field_validator, model_serializer
-
-from langflow.field_typing import LanguageModel
-from langflow.schema.data import Data
-
-
-class AgentContext(BaseModel):
-    tools: dict[str, Any]
-    llm: Any
-    context: str = ""
-    iteration: int = 0
-    max_iterations: int = 5
-    thought: str = ""
-    last_action: Any = None
-    last_action_result: Any = None
-    final_answer: Any = ""
-    context_history: list[tuple[str, str, str]] = Field(default_factory=list)
-
-    @model_serializer(mode="plain")
-    def serialize_agent_context(self):
-        serliazed_llm = self.llm.to_json() if hasattr(self.llm, "to_json") else str(self.llm)
-        serliazed_tools = {k: v.to_json() if hasattr(v, "to_json") else str(v) for k, v in self.tools.items()}
-        return {
-            "tools": serliazed_tools,
-            "llm": serliazed_llm,
-            "context": self.context,
-            "iteration": self.iteration,
-            "max_iterations": self.max_iterations,
-            "thought": self.thought,
-            "last_action": self.last_action.to_json()
-            if hasattr(self.last_action, "to_json")
-            else str(self.last_action),
-            "action_result": self.last_action_result.to_json()
-            if hasattr(self.last_action_result, "to_json")
-            else str(self.last_action_result),
-            "final_answer": self.final_answer,
-            "context_history": self.context_history,
-        }
-
-    @field_validator("llm", mode="before")
-    @classmethod
-    def validate_llm(cls, v) -> LanguageModel:
-        if not isinstance(v, BaseLLM | BaseChatModel | BaseLanguageModel):
-            msg = "llm must be an instance of LanguageModel"
-            raise TypeError(msg)
-        return v
-
-    def to_data_repr(self):
-        data_objs = []
-        for name, val, time_str in self.context_history:
-            content = val.content if hasattr(val, "content") else val
-            data_objs.append(Data(name=name, value=content, timestamp=time_str))
-
-        sorted_data_objs = sorted(data_objs, key=lambda x: datetime.fromisoformat(x.timestamp), reverse=True)
-
-        sorted_data_objs.append(
-            Data(
-                name="Formatted Context",
-                value=self.get_full_context(),
-            )
-        )
-        return sorted_data_objs
-
-    def _build_tools_context(self):
-        tool_context = ""
-        for tool_name, tool_obj in self.tools.items():
-            tool_context += f"{tool_name}: {tool_obj.description}\n"
-        return tool_context
-
-    def _build_init_context(self):
-        return f"""
-{self.context}
-
-"""
-
-    def model_post_init(self, _context: Any) -> None:
-        if hasattr(self.llm, "bind_tools"):
-            self.llm = self.llm.bind_tools(self.tools.values())
-        if self.context:
-            self.update_context("Initial Context", self.context)
-
-    def update_context(self, key: str, value: str):
-        self.context_history.insert(0, (key, value, datetime.now(tz=timezone.utc).astimezone().isoformat()))
-
-    def _serialize_context_history_tuple(self, context_history_tuple: tuple[str, str, str]) -> str:
-        name, value, _ = context_history_tuple
-        if hasattr(value, "content"):
-            value = value.content
-        elif hasattr(value, "log"):
-            value = value.log
-        return f"{name}: {value}"
-
-    def get_full_context(self) -> str:
-        context_history_reversed = self.context_history[::-1]
-        context_formatted = "\n".join(
-            [
-                self._serialize_context_history_tuple(context_history_tuple)
-                for context_history_tuple in context_history_reversed
-            ]
-        )
-        return f"""
-Context:
-{context_formatted}
-"""