langflow-base-nightly 0.5.1.dev3__py3-none-any.whl → 0.5.1.dev5__py3-none-any.whl

langflow/base/agents/crewai/crew.py

@@ -1,231 +0,0 @@
-from collections.abc import Callable
-from typing import Any, cast
-
-import litellm
-from pydantic import SecretStr
-
-from langflow.custom.custom_component.component import Component
-from langflow.inputs.inputs import HandleInput, InputTypes
-from langflow.io import BoolInput, IntInput, Output
-from langflow.schema.data import Data
-from langflow.schema.message import Message
-from langflow.utils.constants import MESSAGE_SENDER_AI
-
-
-def _find_api_key(model):
-    """Attempts to find the API key attribute for a LangChain LLM model instance using partial matching.
-
-    Args:
-        model: LangChain LLM model instance.
-
-    Returns:
-        The API key if found, otherwise None.
-    """
-    # Define the possible API key attribute patterns
-    key_patterns = ["key", "token"]
-
-    # Iterate over the model attributes
-    for attr in dir(model):
-        attr_lower = attr.lower()
-
-        # Check if the attribute name contains any of the key patterns
-        if any(pattern in attr_lower for pattern in key_patterns):
-            value = getattr(model, attr, None)
-
-            # Check if the value is a non-empty string
-            if isinstance(value, str):
-                return value
-            if isinstance(value, SecretStr):
-                return value.get_secret_value()
-
-    return None
-
-
-def convert_llm(llm: Any, excluded_keys=None):
-    """Converts a LangChain LLM object to a CrewAI-compatible LLM object.
-
-    Args:
-        llm: A LangChain LLM object.
-        excluded_keys: A set of keys to exclude from the conversion.
-
-    Returns:
-        A CrewAI-compatible LLM object
-    """
-    try:
-        from crewai import LLM
-    except ImportError as e:
-        msg = "CrewAI is not installed. Please install it with `uv pip install crewai`."
-        raise ImportError(msg) from e
-
-    if not llm:
-        return None
-
-    # Check if this is already an LLM object
-    if isinstance(llm, LLM):
-        return llm
-
-    # Check if we should use model_name model, or something else
-    if hasattr(llm, "model_name") and llm.model_name:
-        model_name = llm.model_name
-    elif hasattr(llm, "model") and llm.model:
-        model_name = llm.model
-    elif hasattr(llm, "deployment_name") and llm.deployment_name:
-        model_name = llm.deployment_name
-    else:
-        msg = "Could not find model name in the LLM object"
-        raise ValueError(msg)
-
-    # Normalize to the LLM model name
-    # Remove langchain_ prefix if present
-    provider = llm.get_lc_namespace()[0]
-    api_base = None
-    if provider.startswith("langchain_"):
-        provider = provider[10:]
-        model_name = f"{provider}/{model_name}"
-    elif hasattr(llm, "azure_endpoint"):
-        api_base = llm.azure_endpoint
-        model_name = f"azure/{model_name}"
-
-    # Retrieve the API Key from the LLM
-    if excluded_keys is None:
-        excluded_keys = {"model", "model_name", "_type", "api_key", "azure_deployment"}
-
-    # Find the API key in the LLM
-    api_key = _find_api_key(llm)
-
-    # Convert Langchain LLM to CrewAI-compatible LLM object
-    return LLM(
-        model=model_name,
-        api_key=api_key,
-        api_base=api_base,
-        **{k: v for k, v in llm.dict().items() if k not in excluded_keys},
-    )
-
-
-def convert_tools(tools):
-    """Converts LangChain tools to CrewAI-compatible tools.
-
-    Args:
-        tools: A LangChain tools list.
-
-    Returns:
-        A CrewAI-compatible tools list.
-    """
-    try:
-        from crewai.tools.base_tool import Tool
-    except ImportError as e:
-        msg = "CrewAI is not installed. Please install it with `uv pip install crewai`."
-        raise ImportError(msg) from e
-
-    if not tools:
-        return []
-
-    return [Tool.from_langchain(tool) for tool in tools]
-
-
-class BaseCrewComponent(Component):
-    description: str = (
-        "Represents a group of agents, defining how they should collaborate and the tasks they should perform."
-    )
-    icon = "CrewAI"
-
-    _base_inputs: list[InputTypes] = [
-        IntInput(name="verbose", display_name="Verbose", value=0, advanced=True),
-        BoolInput(name="memory", display_name="Memory", value=False, advanced=True),
-        BoolInput(name="use_cache", display_name="Cache", value=True, advanced=True),
-        IntInput(name="max_rpm", display_name="Max RPM", value=100, advanced=True),
-        BoolInput(name="share_crew", display_name="Share Crew", value=False, advanced=True),
-        HandleInput(
-            name="function_calling_llm",
-            display_name="Function Calling LLM",
-            input_types=["LanguageModel"],
-            info="Turns the ReAct CrewAI agent into a function-calling agent",
-            required=False,
-            advanced=True,
-        ),
-    ]
-
-    outputs = [
-        Output(display_name="Output", name="output", method="build_output"),
-    ]
-
-    # Model properties to exclude when creating a CrewAI LLM object
-    manager_llm = None
-
-    def task_is_valid(self, task_data: Data, crew_type) -> bool:
-        return "task_type" in task_data and task_data.task_type == crew_type
-
-    def get_tasks_and_agents(self, agents_list=None) -> tuple[list, list]:
-        # Allow passing a custom list of agents
-        if not agents_list:
-            agents_list = self.agents or []
-
-        # Set all the agents llm attribute to the crewai llm
-        for agent in agents_list:
-            # Convert Agent LLM and Tools to proper format
-            agent.llm = convert_llm(agent.llm)
-            agent.tools = convert_tools(agent.tools)
-
-        return self.tasks, agents_list
-
-    def get_manager_llm(self):
-        if not self.manager_llm:
-            return None
-
-        self.manager_llm = convert_llm(self.manager_llm)
-
-        return self.manager_llm
-
-    def build_crew(self):
-        msg = "build_crew must be implemented in subclasses"
-        raise NotImplementedError(msg)
-
-    def get_task_callback(
-        self,
-    ) -> Callable:
-        try:
-            from crewai.task import TaskOutput
-        except ImportError as e:
-            msg = "CrewAI is not installed. Please install it with `uv pip install crewai`."
-            raise ImportError(msg) from e
-
-        def task_callback(task_output: TaskOutput) -> None:
-            vertex_id = self._vertex.id if self._vertex else self.display_name or self.__class__.__name__
-            self.log(task_output.model_dump(), name=f"Task (Agent: {task_output.agent}) - {vertex_id}")
-
-        return task_callback
-
-    def get_step_callback(
-        self,
-    ) -> Callable:
-        try:
-            from langchain_core.agents import AgentFinish
-        except ImportError as e:
-            msg = "langchain_core is not installed. Please install it with `uv pip install langchain-core`."
-            raise ImportError(msg) from e
-
-        def step_callback(agent_output) -> None:
-            id_ = self._vertex.id if self._vertex else self.display_name
-            if isinstance(agent_output, AgentFinish):
-                messages = agent_output.messages
-                self.log(cast("dict", messages[0].to_json()), name=f"Finish (Agent: {id_})")
-            elif isinstance(agent_output, list):
-                messages_dict_ = {f"Action {i}": action.messages for i, (action, _) in enumerate(agent_output)}
-                # Serialize the messages with to_json() to avoid issues with circular references
-                serializable_dict = {k: [m.to_json() for m in v] for k, v in messages_dict_.items()}
-                messages_dict = {k: v[0] if len(v) == 1 else v for k, v in serializable_dict.items()}
-                self.log(messages_dict, name=f"Step (Agent: {id_})")
-
-        return step_callback
-
-    async def build_output(self) -> Message:
-        try:
-            crew = self.build_crew()
-            result = await crew.kickoff_async()
-            message = Message(text=result.raw, sender=MESSAGE_SENDER_AI)
-        except litellm.exceptions.BadRequestError as e:
-            raise ValueError(e) from e
-
-        self.status = message
-
-        return message

langflow/base/agents/crewai/tasks.py

@@ -1,12 +0,0 @@
-try:
-    from crewai import Task
-except ImportError:
-    Task = object
-
-
-class SequentialTask(Task):
-    pass
-
-
-class HierarchicalTask(Task):
-    pass

langflow/base/agents/default_prompts.py

@@ -1,23 +0,0 @@
-XML_AGENT_PROMPT = """You are a helpful assistant. Help the user answer any questions.
-
-            You have access to the following tools:
-
-            {tools}
-
-            In order to use a tool, you can use <tool></tool> and <tool_input></tool_input> tags. You will then get back a response in the form <observation></observation>
-            For example, if you have a tool called 'search' that could run a google search, in order to search for the weather in SF you would respond:
-
-            <tool>search</tool><tool_input>weather in SF</tool_input>
-            <observation>64 degrees</observation>
-
-            When you are done, respond with a final answer between <final_answer></final_answer>. For example:
-
-            <final_answer>The weather in SF is 64 degrees</final_answer>
-
-            Begin!
-
-            Previous Conversation:
-            {chat_history}
-
-            Question: {input}
-            {agent_scratchpad}"""  # noqa: E501

langflow/base/agents/errors.py

@@ -1,15 +0,0 @@
-from anthropic import BadRequestError as AnthropicBadRequestError
-from cohere import BadRequestError as CohereBadRequestError
-from httpx import HTTPStatusError
-
-from langflow.schema.message import Message
-
-
-class CustomBadRequestError(AnthropicBadRequestError, CohereBadRequestError, HTTPStatusError):
-    def __init__(self, agent_message: Message | None, message: str):
-        super().__init__(message)
-        self.message = message
-        self.agent_message = agent_message
-
-    def __str__(self):
-        return f"{self.message}"

langflow/base/agents/events.py

@@ -1,346 +0,0 @@
-# Add helper functions for each event type
-from collections.abc import AsyncIterator
-from time import perf_counter
-from typing import Any, Protocol
-
-from langchain_core.agents import AgentFinish
-from langchain_core.messages import AIMessageChunk, BaseMessage
-from typing_extensions import TypedDict
-
-from langflow.schema.content_block import ContentBlock
-from langflow.schema.content_types import TextContent, ToolContent
-from langflow.schema.log import SendMessageFunctionType
-from langflow.schema.message import Message
-
-
-class ExceptionWithMessageError(Exception):
-    def __init__(self, agent_message: Message, message: str):
-        self.agent_message = agent_message
-        super().__init__(message)
-        self.message = message
-
-    def __str__(self):
-        return (
-            f"Agent message: {self.agent_message.text} \nError: {self.message}."
-            if self.agent_message.error or self.agent_message.text
-            else f"{self.message}."
-        )
-
-
-class InputDict(TypedDict):
-    input: str
-    chat_history: list[BaseMessage]
-
-
-def _build_agent_input_text_content(agent_input_dict: InputDict) -> str:
-    final_input = agent_input_dict.get("input", "")
-    return f"**Input**: {final_input}"
-
-
-def _calculate_duration(start_time: float) -> int:
-    """Calculate duration in milliseconds from start time to now."""
-    # Handle the calculation
-    current_time = perf_counter()
-    if isinstance(start_time, int):
-        # If we got an integer, treat it as milliseconds
-        duration = current_time - (start_time / 1000)
-        result = int(duration * 1000)
-    else:
-        # If we got a float, treat it as perf_counter time
-        result = int((current_time - start_time) * 1000)
-
-    return result
-
-
-async def handle_on_chain_start(
-    event: dict[str, Any], agent_message: Message, send_message_method: SendMessageFunctionType, start_time: float
-) -> tuple[Message, float]:
-    # Create content blocks if they don't exist
-    if not agent_message.content_blocks:
-        agent_message.content_blocks = [ContentBlock(title="Agent Steps", contents=[])]
-
-    if event["data"].get("input"):
-        input_data = event["data"].get("input")
-        if isinstance(input_data, dict) and "input" in input_data:
-            # Cast the input_data to InputDict
-            input_message = input_data.get("input", "")
-            if isinstance(input_message, BaseMessage):
-                input_message = input_message.text()
-            elif not isinstance(input_message, str):
-                input_message = str(input_message)
-
-            input_dict: InputDict = {
-                "input": input_message,
-                "chat_history": input_data.get("chat_history", []),
-            }
-            text_content = TextContent(
-                type="text",
-                text=_build_agent_input_text_content(input_dict),
-                duration=_calculate_duration(start_time),
-                header={"title": "Input", "icon": "MessageSquare"},
-            )
-            agent_message.content_blocks[0].contents.append(text_content)
-            agent_message = await send_message_method(message=agent_message)
-            start_time = perf_counter()
-    return agent_message, start_time
-
-
-def _extract_output_text(output: str | list) -> str:
-    if isinstance(output, str):
-        return output
-    if isinstance(output, list) and len(output) == 0:
-        return ""
-    if not isinstance(output, list) or len(output) != 1:
-        msg = f"Output is not a string or list of dictionaries with 'text' key: {output}"
-        raise TypeError(msg)
-
-    item = output[0]
-    if isinstance(item, str):
-        return item
-    if isinstance(item, dict):
-        if "text" in item:
-            return item["text"]
-        # If the item's type is "tool_use", return an empty string.
-        # This likely indicates that "tool_use" outputs are not meant to be displayed as text.
-        if item.get("type") == "tool_use":
-            return ""
-    if isinstance(item, dict):
-        if "text" in item:
-            return item["text"]
-        # If the item's type is "tool_use", return an empty string.
-        # This likely indicates that "tool_use" outputs are not meant to be displayed as text.
-        if item.get("type") == "tool_use":
-            return ""
-        # This is a workaround to deal with function calling by Anthropic
-        # since the same data comes in the tool_output we don't need to stream it here
-        # although it would be nice to
-        if "partial_json" in item:
-            return ""
-    msg = f"Output is not a string or list of dictionaries with 'text' key: {output}"
-    raise TypeError(msg)
-
-
-async def handle_on_chain_end(
-    event: dict[str, Any], agent_message: Message, send_message_method: SendMessageFunctionType, start_time: float
-) -> tuple[Message, float]:
-    data_output = event["data"].get("output")
-    if data_output and isinstance(data_output, AgentFinish) and data_output.return_values.get("output"):
-        output = data_output.return_values.get("output")
-
-        agent_message.text = _extract_output_text(output)
-        agent_message.properties.state = "complete"
-        # Add duration to the last content if it exists
-        if agent_message.content_blocks:
-            duration = _calculate_duration(start_time)
-            text_content = TextContent(
-                type="text",
-                text=agent_message.text,
-                duration=duration,
-                header={"title": "Output", "icon": "MessageSquare"},
-            )
-            agent_message.content_blocks[0].contents.append(text_content)
-        agent_message = await send_message_method(message=agent_message)
-        start_time = perf_counter()
-    return agent_message, start_time
-
-
-async def handle_on_tool_start(
-    event: dict[str, Any],
-    agent_message: Message,
-    tool_blocks_map: dict[str, ToolContent],
-    send_message_method: SendMessageFunctionType,
-    start_time: float,
-) -> tuple[Message, float]:
-    tool_name = event["name"]
-    tool_input = event["data"].get("input")
-    run_id = event.get("run_id", "")
-    tool_key = f"{tool_name}_{run_id}"
-
-    # Create content blocks if they don't exist
-    if not agent_message.content_blocks:
-        agent_message.content_blocks = [ContentBlock(title="Agent Steps", contents=[])]
-
-    duration = _calculate_duration(start_time)
-    new_start_time = perf_counter()  # Get new start time for next operation
-
-    # Create new tool content with the input exactly as received
-    tool_content = ToolContent(
-        type="tool_use",
-        name=tool_name,
-        tool_input=tool_input,
-        output=None,
-        error=None,
-        header={"title": f"Accessing **{tool_name}**", "icon": "Hammer"},
-        duration=duration,  # Store the actual duration
-    )
-
-    # Store in map and append to message
-    tool_blocks_map[tool_key] = tool_content
-    agent_message.content_blocks[0].contents.append(tool_content)
-
-    agent_message = await send_message_method(message=agent_message)
-    if agent_message.content_blocks and agent_message.content_blocks[0].contents:
-        tool_blocks_map[tool_key] = agent_message.content_blocks[0].contents[-1]
-    return agent_message, new_start_time
-
-
-async def handle_on_tool_end(
-    event: dict[str, Any],
-    agent_message: Message,
-    tool_blocks_map: dict[str, ToolContent],
-    send_message_method: SendMessageFunctionType,
-    start_time: float,
-) -> tuple[Message, float]:
-    run_id = event.get("run_id", "")
-    tool_name = event.get("name", "")
-    tool_key = f"{tool_name}_{run_id}"
-    tool_content = tool_blocks_map.get(tool_key)
-
-    if tool_content and isinstance(tool_content, ToolContent):
-        # Call send_message_method first to get the updated message structure
-        agent_message = await send_message_method(message=agent_message)
-        new_start_time = perf_counter()
-
-        # Now find and update the tool content in the current message
-        duration = _calculate_duration(start_time)
-        tool_key = f"{tool_name}_{run_id}"
-
-        # Find the corresponding tool content in the updated message
-        updated_tool_content = None
-        if agent_message.content_blocks and agent_message.content_blocks[0].contents:
-            for content in agent_message.content_blocks[0].contents:
-                if (
-                    isinstance(content, ToolContent)
-                    and content.name == tool_name
-                    and content.tool_input == tool_content.tool_input
-                ):
-                    updated_tool_content = content
-                    break
-
-        # Update the tool content that's actually in the message
-        if updated_tool_content:
-            updated_tool_content.duration = duration
-            updated_tool_content.header = {"title": f"Executed **{updated_tool_content.name}**", "icon": "Hammer"}
-            updated_tool_content.output = event["data"].get("output")
-
-            # Update the map reference
-            tool_blocks_map[tool_key] = updated_tool_content
-
-        return agent_message, new_start_time
-    return agent_message, start_time
-
-
-async def handle_on_tool_error(
-    event: dict[str, Any],
-    agent_message: Message,
-    tool_blocks_map: dict[str, ToolContent],
-    send_message_method: SendMessageFunctionType,
-    start_time: float,
-) -> tuple[Message, float]:
-    run_id = event.get("run_id", "")
-    tool_name = event.get("name", "")
-    tool_key = f"{tool_name}_{run_id}"
-    tool_content = tool_blocks_map.get(tool_key)
-
-    if tool_content and isinstance(tool_content, ToolContent):
-        tool_content.error = event["data"].get("error", "Unknown error")
-        tool_content.duration = _calculate_duration(start_time)
-        tool_content.header = {"title": f"Error using **{tool_content.name}**", "icon": "Hammer"}
-        agent_message = await send_message_method(message=agent_message)
-        start_time = perf_counter()
-    return agent_message, start_time
-
-
-async def handle_on_chain_stream(
-    event: dict[str, Any],
-    agent_message: Message,
-    send_message_method: SendMessageFunctionType,
-    start_time: float,
-) -> tuple[Message, float]:
-    data_chunk = event["data"].get("chunk", {})
-    if isinstance(data_chunk, dict) and data_chunk.get("output"):
-        output = data_chunk.get("output")
-        if output and isinstance(output, str | list):
-            agent_message.text = _extract_output_text(output)
-        agent_message.properties.state = "complete"
-        agent_message = await send_message_method(message=agent_message)
-        start_time = perf_counter()
-    elif isinstance(data_chunk, AIMessageChunk):
-        output_text = _extract_output_text(data_chunk.content)
-        if output_text and isinstance(agent_message.text, str):
-            agent_message.text += output_text
-            agent_message.properties.state = "partial"
-            agent_message = await send_message_method(message=agent_message)
-        if not agent_message.text:
-            start_time = perf_counter()
-    return agent_message, start_time
-
-
-class ToolEventHandler(Protocol):
-    async def __call__(
-        self,
-        event: dict[str, Any],
-        agent_message: Message,
-        tool_blocks_map: dict[str, ContentBlock],
-        send_message_method: SendMessageFunctionType,
-        start_time: float,
-    ) -> tuple[Message, float]: ...
-
-
-class ChainEventHandler(Protocol):
-    async def __call__(
-        self,
-        event: dict[str, Any],
-        agent_message: Message,
-        send_message_method: SendMessageFunctionType,
-        start_time: float,
-    ) -> tuple[Message, float]: ...
-
-
-EventHandler = ToolEventHandler | ChainEventHandler
-
-# Define separate mappings of event types to their respective handler functions
-CHAIN_EVENT_HANDLERS: dict[str, ChainEventHandler] = {
-    "on_chain_start": handle_on_chain_start,
-    "on_chain_end": handle_on_chain_end,
-    "on_chain_stream": handle_on_chain_stream,
-    "on_chat_model_stream": handle_on_chain_stream,
-}
-
-TOOL_EVENT_HANDLERS: dict[str, ToolEventHandler] = {
-    "on_tool_start": handle_on_tool_start,
-    "on_tool_end": handle_on_tool_end,
-    "on_tool_error": handle_on_tool_error,
-}
-
-
-async def process_agent_events(
-    agent_executor: AsyncIterator[dict[str, Any]],
-    agent_message: Message,
-    send_message_method: SendMessageFunctionType,
-) -> Message:
-    """Process agent events and return the final output."""
-    if isinstance(agent_message.properties, dict):
-        agent_message.properties.update({"icon": "Bot", "state": "partial"})
-    else:
-        agent_message.properties.icon = "Bot"
-        agent_message.properties.state = "partial"
-    # Store the initial message
-    agent_message = await send_message_method(message=agent_message)
-    try:
-        # Create a mapping of run_ids to tool contents
-        tool_blocks_map: dict[str, ToolContent] = {}
-        start_time = perf_counter()
-        async for event in agent_executor:
-            if event["event"] in TOOL_EVENT_HANDLERS:
-                tool_handler = TOOL_EVENT_HANDLERS[event["event"]]
-                agent_message, start_time = await tool_handler(
-                    event, agent_message, tool_blocks_map, send_message_method, start_time
-                )
-            elif event["event"] in CHAIN_EVENT_HANDLERS:
-                chain_handler = CHAIN_EVENT_HANDLERS[event["event"]]
-                agent_message, start_time = await chain_handler(event, agent_message, send_message_method, start_time)
-        agent_message.properties.state = "complete"
-    except Exception as e:
-        raise ExceptionWithMessageError(agent_message, str(e)) from e
-    return await Message.create(**agent_message.model_dump())