Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

4.8 KB
Raw Blame
import asyncio
from collections.abc import Awaitable
from typing import Any

from langchain_core.runnables import RunnableConfig

from products.skills.backend.tools.skills import GetLLMSkillFileTool, GetLLMSkillTool, ListLLMSkillsTool
from products.tasks.backend.facade.max_tools import (
    CreateTaskTool,
    GetTaskRunLogsTool,
    GetTaskRunTool,
    ListRepositoriesTool,
    ListTaskRunsTool,
    ListTasksTool,
    RunTaskTool,
)

from ee.hogai.core.agent_modes.toolkit import AgentToolkit, AgentToolkitManager
from ee.hogai.registry import get_contextual_tool_class
from ee.hogai.tool import MaxTool
from ee.hogai.tools import (
    CreateFormTool,
    CreateNotebookTool,
    ListDataTool,
    ListFeatureFlagsTool,
    ManageMemoriesTool,
    ReadDataTool,
    ReadTaxonomyTool,
    SearchTool,
    SwitchModeTool,
    TaskTool,
    TodoWriteTool,
)
from ee.hogai.tools.call_mcp_server.tool import CallMCPServerTool
from ee.hogai.tools.finalize_plan.tool import FinalizePlanTool
from ee.hogai.utils.feature_flags import (
    has_mcp_gateway_feature_flag,
    has_memory_tool_feature_flag,
    has_phai_tasks_feature_flag,
    has_task_tool_feature_flag,
)
from ee.hogai.utils.types.base import AssistantState

DEFAULT_TOOLS: list[type[MaxTool]] = [
    ReadTaxonomyTool,
    ReadDataTool,
    SearchTool,
    ListDataTool,
    ListFeatureFlagsTool,
    TodoWriteTool,
    SwitchModeTool,
    CreateFormTool,
    CreateNotebookTool,
    ListLLMSkillsTool,
    GetLLMSkillTool,
    GetLLMSkillFileTool,
]

TASK_TOOLS: list[type[MaxTool]] = [
    CreateTaskTool,
    RunTaskTool,
    GetTaskRunTool,
    GetTaskRunLogsTool,
    ListTasksTool,
    ListTaskRunsTool,
    ListRepositoriesTool,
]


class ChatAgentPlanToolkit(AgentToolkit):
    """Agent toolkit for plan mode with base tools + plan-specific tools."""

    @property
    def tools(self) -> list[type[MaxTool]]:
        tools: list[type[MaxTool]] = [
            ReadTaxonomyTool,
            SearchTool,
            TodoWriteTool,
            SwitchModeTool,
            CreateFormTool,
            FinalizePlanTool,
        ]
        if has_memory_tool_feature_flag(self._team, self._user):
            tools.append(ManageMemoriesTool)
        return tools


class ChatAgentToolkit(AgentToolkit):
    @property
    def tools(self) -> list[type[MaxTool]]:
        # TRICKY: DO NOT EXTEND THE TOOLKIT HERE. THE TOOLS HERE ARE USED ACROSS ALL AGENT MODES.
        tools = list(DEFAULT_TOOLS)
        if has_phai_tasks_feature_flag(self._team, self._user):
            tools.extend(TASK_TOOLS)
        if has_task_tool_feature_flag(self._team, self._user):
            tools.append(TaskTool)
        if has_memory_tool_feature_flag(self._team, self._user):
            tools.append(ManageMemoriesTool)
        return tools


class PlanModeSwitchAgentToolkit(AgentToolkit):
    """Empty toolkit for the fictitious execution/plan modes that triggers transition to execution/plan mode."""

    pass


class ChatAgentToolkitManager(AgentToolkitManager):
    async def get_tools(self, state: AssistantState, config: RunnableConfig) -> list[MaxTool | dict[str, Any]]:
        available_tools = await super().get_tools(state, config)

        tool_names = self._context_manager.get_contextual_tools().keys()
        awaited_contextual_tools: list[Awaitable[MaxTool]] = []
        for tool_name in tool_names:
            ContextualMaxToolClass = get_contextual_tool_class(tool_name)
            if ContextualMaxToolClass is None:
                continue  # Ignoring a tool that the backend doesn't know about - might be a deployment mismatch
            awaited_contextual_tools.append(
                ContextualMaxToolClass.create_tool_class(
                    team=self._team,
                    user=self._user,
                    state=state,
                    config=config,
                    context_manager=self._context_manager,
                )
            )

        contextual_tools = await asyncio.gather(*awaited_contextual_tools)

        # Deduplicate contextual tools
        initialized_tool_names = {tool.get_name() for tool in available_tools if isinstance(tool, MaxTool)}
        for tool in contextual_tools:
            if tool.get_name() not in initialized_tool_names:
                available_tools.append(tool)

        # Add MCP server tool if user has installations and flag is enabled
        if has_mcp_gateway_feature_flag(self._team, self._user):
            mcp_tool = await CallMCPServerTool.create_tool_class(
                team=self._team,
                user=self._user,
                state=state,
                config=config,
                context_manager=self._context_manager,
            )
            if mcp_tool._installations:
                available_tools.append(mcp_tool)

        available_tools.append({"type": "web_search_20250305", "name": "web_search", "max_uses": 5})

        return available_tools