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

lfx/base/agents/crewai/crew.py

@@ -0,0 +1,231 @@
+from collections.abc import Callable
+from typing import Any, cast
+
+import litellm
+from pydantic import SecretStr
+
+from lfx.custom.custom_component.component import Component
+from lfx.inputs.inputs import HandleInput, InputTypes
+from lfx.io import BoolInput, IntInput, Output
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+from lfx.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

lfx/base/agents/crewai/tasks.py

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

lfx/base/agents/default_prompts.py

@@ -0,0 +1,23 @@
+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

lfx/base/agents/errors.py

@@ -0,0 +1,15 @@
+from anthropic import BadRequestError as AnthropicBadRequestError
+from cohere import BadRequestError as CohereBadRequestError
+from httpx import HTTPStatusError
+
+from lfx.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}"

lfx/base/agents/events.py

@@ -0,0 +1,346 @@
+# 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 lfx.schema.content_block import ContentBlock
+from lfx.schema.content_types import TextContent, ToolContent
+from lfx.schema.log import SendMessageFunctionType
+from lfx.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())