Method _execute_tool_request

agent.py:1134–1223

(
        self,
        tool_name: str,
        tool_args: dict,
        message: str,
        raw_tool_name: str = "",
        responses_item_factory: Callable[[Any], dict[str, Any]] | None = None,
    )

        return await self.process_tools(llm_result.response)

    async def _execute_tool_request(
        self,
        tool_name: str,
        tool_args: dict,
        message: str,
        raw_tool_name: str = "",
        responses_item_factory: Callable[[Any], dict[str, Any]] | None = None,
    ):
        raw_tool_name = raw_tool_name or tool_name
        tool_method = None
        tool = None

        try:
            import helpers.mcp_handler as mcp_helper

            mcp_tool_candidate = mcp_helper.MCPConfig.get_instance().get_tool(
                self, tool_name
            )
            if mcp_tool_candidate:
                tool = mcp_tool_candidate
        except ImportError:
            PrintStyle(
                background_color="black", font_color="yellow", padding=True
            ).print("MCP helper module not found. Skipping MCP tool lookup.")
        except Exception as e:
            PrintStyle(background_color="black", font_color="red", padding=True).print(
                f"Failed to get MCP tool '{tool_name}': {e}"
            )

        if not tool:
            tool = self.get_tool(
                name=tool_name,
                method=tool_method,
                args=tool_args,
                message=message,
                loop_data=self.loop_data,
            )

        if not tool:
            error_detail = (
                f"Tool '{raw_tool_name}' not found or could not be initialized."
            )
            wmsg = self.hist_add_warning(error_detail)
            PrintStyle(font_color="red", padding=True).print(error_detail)
            self.context.log.log(
                type="warning",
                content=f"{self.agent_name}: {error_detail}",
                id=wmsg.id,
            )
            return None

        self.loop_data.current_tool = tool  # type: ignore
        try:
            await self.handle_intervention()

            await tool.before_execution(**tool_args)
            await self.handle_intervention()