wip: mcp tool

Author: tysonthomas9

config/gni/devtools_grd_files.gni

@@ -633,6 +633,7 @@ grd_files_bundled_sources = [
   "front_end/panels/ai_chat/core/PageInfoManager.js",
   "front_end/panels/ai_chat/core/AgentNodes.js",
   "front_end/panels/ai_chat/core/GraphHelpers.js",
+  "front_end/panels/ai_chat/core/ToolSurfaceProvider.js",
   "front_end/panels/ai_chat/core/StateGraph.js",
   "front_end/panels/ai_chat/core/Logger.js",
   "front_end/panels/ai_chat/core/AgentErrorHandler.js",
@@ -700,6 +701,11 @@ grd_files_bundled_sources = [
   "front_end/panels/ai_chat/evaluation/utils/PromptTemplates.js",
   "front_end/panels/ai_chat/evaluation/utils/ResponseParsingUtils.js",
   "front_end/panels/ai_chat/evaluation/utils/SanitizationUtils.js",
+  "front_end/panels/ai_chat/mcp/MCPConfig.js",
+  "front_end/panels/ai_chat/mcp/MCPRegistry.js",
+  "front_end/panels/ai_chat/mcp/MCPToolAdapter.js",
+  "front_end/panels/ai_chat/mcp/MCPMetaTools.js",
+  "front_end/panels/ai_chat/tools/LLMTracingWrapper.js",
   "front_end/panels/animation/animation-meta.js",
   "front_end/panels/animation/animation.js",
   "front_end/panels/application/application-meta.js",
@@ -837,6 +843,17 @@ grd_files_bundled_sources = [
   "front_end/third_party/lighthouse/lighthouse-dt-bundle.js",
   "front_end/third_party/lighthouse/report/report.js",
   "front_end/third_party/lit/lit.js",
+  "front_end/third_party/mcp-sdk/ajv/dist/ajv.js",
+  "front_end/third_party/mcp-sdk/zod/lib/index.js",
+  "front_end/third_party/mcp-sdk/zod/lib/index.mjs",
+  "front_end/third_party/mcp-sdk/eventsource-parser/package/dist/index.js",
+  "front_end/third_party/mcp-sdk/eventsource-parser/package/dist/stream.js",
+  "front_end/third_party/mcp-sdk/mcp-sdk.js",
+  "front_end/third_party/mcp-sdk/package/dist/client/index.js",
+  "front_end/third_party/mcp-sdk/package/dist/client/sse.js",
+  "front_end/third_party/mcp-sdk/package/dist/shared/protocol.js",
+  "front_end/third_party/mcp-sdk/package/dist/shared/transport.js",
+  "front_end/third_party/mcp-sdk/package/dist/types.js",
   "front_end/third_party/marked/marked.js",
   "front_end/third_party/puppeteer-replay/puppeteer-replay.js",
   "front_end/third_party/puppeteer/puppeteer.js",

front_end/panels/ai_chat/BUILD.gn

@@ -34,6 +34,7 @@ devtools_module("ai_chat") {
     "core/PageInfoManager.ts",
     "core/AgentNodes.ts",
     "core/GraphHelpers.ts",
+    "core/ToolSurfaceProvider.ts",
     "core/StateGraph.ts",
     "core/Logger.ts",
     "core/AgentErrorHandler.ts",
@@ -99,6 +100,10 @@ devtools_module("ai_chat") {
     "tracing/TracingConfig.ts",
     "auth/PKCEUtils.ts",
     "auth/OpenRouterOAuth.ts",
+    "mcp/MCPConfig.ts",
+    "mcp/MCPToolAdapter.ts",
+    "mcp/MCPRegistry.ts",
+    "mcp/MCPMetaTools.ts",
   ]
 
   deps = [
@@ -108,6 +113,7 @@ devtools_module("ai_chat") {
     "../../core/sdk:bundle",
     "../../generated:protocol",
     "../../models/logs:bundle",
+    "../../third_party/mcp-sdk:bundle",
     "../../ui/components/helpers:bundle",
     "../../ui/components/markdown_view:bundle",
     "../../ui/components/snackbars:bundle",
@@ -139,6 +145,7 @@ _ai_chat_sources = [
     "core/PageInfoManager.ts",
     "core/AgentNodes.ts",
     "core/GraphHelpers.ts",
+    "core/ToolSurfaceProvider.ts",
     "core/StateGraph.ts",
     "core/Logger.ts",
     "core/AgentErrorHandler.ts",
@@ -203,6 +210,10 @@ _ai_chat_sources = [
     "tracing/TracingConfig.ts",
     "auth/PKCEUtils.ts",
     "auth/OpenRouterOAuth.ts",
+    "mcp/MCPConfig.ts",
+    "mcp/MCPToolAdapter.ts",
+    "mcp/MCPRegistry.ts",
+    "mcp/MCPMetaTools.ts",
 ]
 
 # Construct the expected JS output paths for the metadata
@@ -287,6 +298,9 @@ ts_library("unittests") {
 
   sources = [
     "common/utils.test.ts",
+    "mcp/MCPClientSDK.test.ts",
+    "core/ToolSurfaceProvider.test.ts",
+    "core/ToolNameMapping.test.ts",
   ]
 
   deps = [

front_end/panels/ai_chat/agent_framework/ConfigurableAgentTool.ts

@@ -182,7 +182,7 @@ export class ToolRegistry {
     try {
         const instance = factory();
         this.registeredTools.set(name, instance);
-        logger.info('Registered and instantiated tool: ${name}');
+        logger.info(`Registered and instantiated tool: ${name}`);
     } catch (error) {
         logger.error(`Failed to instantiate tool '${name}' during registration:`, error);
         // Remove the factory entry if instantiation fails

front_end/panels/ai_chat/agent_framework/implementation/ConfiguredAgents.ts

@@ -19,6 +19,7 @@ import {
 import { WaitTool } from '../../tools/Tools.js';
 import { ThinkingTool } from '../../tools/ThinkingTool.js';
 import type { Tool } from '../../tools/Tools.js';
+import { registerMCPMetaTools } from '../../mcp/MCPMetaTools.js';
 
 /**
  * Configuration for the Direct URL Navigator Agent
@@ -94,6 +95,8 @@ Remember: Always use navigate_url to actually go to the constructed URLs. Return
  * Initialize all configured agents
  */
 export function initializeConfiguredAgents(): void {
+  // Ensure MCP meta-tools are available regardless of mode; selection logic decides if they are surfaced
+  registerMCPMetaTools();
   // Register core tools
   ToolRegistry.registerToolFactory('navigate_url', () => new NavigateURLTool());
   ToolRegistry.registerToolFactory('navigate_back', () => new NavigateBackTool());

front_end/panels/ai_chat/core/AgentNodes.test.ts

@@ -0,0 +1,204 @@
+// Copyright 2025 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import { createToolExecutorNode } from './AgentNodes.js';
+import { ConfigurableAgentTool } from '../agent_framework/ConfigurableAgentTool.js';
+import { ChatMessageEntity } from '../ui/ChatView.js';
+import type { AgentState } from './State.js';
+import type { ConfigurableAgentResult } from '../agent_framework/ConfigurableAgentTool.js';
+
+declare global {
+  function describe(name: string, fn: () => void): void;
+  function it(name: string, fn: () => void): void;
+  function beforeEach(fn: () => void): void;
+  function afterEach(fn: () => void): void;
+  namespace assert {
+    function strictEqual(actual: unknown, expected: unknown): void;
+    function deepEqual(actual: unknown, expected: unknown): void;
+    function isTrue(value: unknown): void;
+    function isFalse(value: unknown): void;
+    function doesNotMatch(actual: string, regexp: RegExp): void;
+  }
+}
+
+describe('AgentNodes ToolExecutorNode', () => {
+  describe('ConfigurableAgentTool result filtering', () => {
+    it('should filter out agentSession data from error results', async () => {
+      // Create a mock ConfigurableAgentTool that returns error with intermediateSteps
+      const mockAgentSession = {
+        sessionId: 'test-session-123',
+        agentName: 'test-agent',
+        status: 'error',
+        messages: [
+          { id: '1', type: 'tool_call', content: { toolName: 'test_tool' } },
+          { id: '2', type: 'tool_result', content: { result: 'test result' } }
+        ],
+        // This contains sensitive data that should not leak to LLM
+        nestedSessions: [],
+        tools: [],
+        startTime: new Date(),
+        endTime: new Date(),
+        terminationReason: 'max_iterations'
+      };
+
+      const errorResultWithSession: ConfigurableAgentResult & { agentSession: any } = {
+        success: false,
+        error: 'Agent reached maximum iterations',
+        terminationReason: 'max_iterations',
+        // This is the problematic field that contains session data
+        intermediateSteps: [
+          { entity: ChatMessageEntity.USER, text: 'test query' },
+          { entity: ChatMessageEntity.AGENT_SESSION, agentSession: mockAgentSession, summary: 'test' }
+        ],
+        agentSession: mockAgentSession
+      };
+
+      // Create mock ConfigurableAgentTool
+      class MockConfigurableAgentTool extends ConfigurableAgentTool {
+        constructor() {
+          super({
+            name: 'mock_agent',
+            description: 'Mock agent for testing',
+            systemPrompt: 'Test prompt',
+            tools: [],
+            schema: { type: 'object', properties: {}, required: [] }
+          });
+        }
+
+        async execute(): Promise<ConfigurableAgentResult & { agentSession: any }> {
+          return errorResultWithSession;
+        }
+      }
+
+      const mockTool = new MockConfigurableAgentTool();
+
+      // Create initial state with a tool call message
+      const initialState: AgentState = {
+        messages: [
+          {
+            entity: ChatMessageEntity.MODEL,
+            action: 'tool',
+            toolName: 'mock_agent',
+            toolArgs: { query: 'test' },
+            toolCallId: 'test-call-id',
+            isFinalAnswer: false
+          }
+        ],
+        agentType: 'web_task',
+        context: {}
+      };
+
+      // Create modified state with mock tool in registry
+      const stateWithMockTool = {
+        ...initialState,
+        // We need to mock the tool registry or provide tools directly
+        tools: [mockTool]
+      };
+
+      // Create ToolExecutorNode
+      const toolExecutorNode = createToolExecutorNode(stateWithMockTool);
+
+      // Execute the node
+      const result = await toolExecutorNode.invoke(stateWithMockTool);
+
+      // Verify the result
+      assert.isTrue(result.messages.length > initialState.messages.length, 'Should add tool result message');
+      
+      const toolResultMessage = result.messages[result.messages.length - 1];
+      assert.strictEqual(toolResultMessage.entity, ChatMessageEntity.TOOL_RESULT);
+      
+      // The critical test: resultText should NOT contain agentSession data
+      const resultText = (toolResultMessage as any).resultText;
+      assert.strictEqual(resultText, 'Error: Agent reached maximum iterations');
+      
+      // Verify that the resultText does not contain session data
+      assert.doesNotMatch(resultText, /sessionId/);
+      assert.doesNotMatch(resultText, /test-session-123/);
+      assert.doesNotMatch(resultText, /intermediateSteps/);
+      assert.doesNotMatch(resultText, /agentSession/);
+      assert.doesNotMatch(resultText, /nestedSessions/);
+      
+      // The resultText should be clean and only contain the error message
+      assert.strictEqual(resultText.includes('test-session-123'), false);
+    });
+
+    it('should filter out agentSession data from success results', async () => {
+      // Create a success result with intermediateSteps containing session data
+      const mockAgentSession = {
+        sessionId: 'success-session-456',
+        agentName: 'success-agent',
+        status: 'completed',
+        messages: [],
+        nestedSessions: [],
+        tools: [],
+        startTime: new Date(),
+        endTime: new Date(),
+        terminationReason: 'final_answer'
+      };
+
+      const successResultWithSession: ConfigurableAgentResult & { agentSession: any } = {
+        success: true,
+        output: 'Task completed successfully',
+        terminationReason: 'final_answer',
+        // This should not leak to LLM
+        intermediateSteps: [
+          { entity: ChatMessageEntity.AGENT_SESSION, agentSession: mockAgentSession, summary: 'test' }
+        ],
+        agentSession: mockAgentSession
+      };
+
+      class MockSuccessAgentTool extends ConfigurableAgentTool {
+        constructor() {
+          super({
+            name: 'mock_success_agent',
+            description: 'Mock success agent for testing',
+            systemPrompt: 'Test prompt',
+            tools: [],
+            schema: { type: 'object', properties: {}, required: [] }
+          });
+        }
+
+        async execute(): Promise<ConfigurableAgentResult & { agentSession: any }> {
+          return successResultWithSession;
+        }
+      }
+
+      const mockTool = new MockSuccessAgentTool();
+
+      const initialState: AgentState = {
+        messages: [
+          {
+            entity: ChatMessageEntity.MODEL,
+            action: 'tool',
+            toolName: 'mock_success_agent',
+            toolArgs: { query: 'test' },
+            toolCallId: 'test-call-id-2',
+            isFinalAnswer: false
+          }
+        ],
+        agentType: 'web_task',
+        context: {}
+      };
+
+      const stateWithMockTool = {
+        ...initialState,
+        tools: [mockTool]
+      };
+
+      const toolExecutorNode = createToolExecutorNode(stateWithMockTool);
+      const result = await toolExecutorNode.invoke(stateWithMockTool);
+
+      const toolResultMessage = result.messages[result.messages.length - 1];
+      const resultText = (toolResultMessage as any).resultText;
+      
+      // Should contain only the clean output
+      assert.strictEqual(resultText, 'Task completed successfully');
+      
+      // Should NOT contain session data
+      assert.doesNotMatch(resultText, /success-session-456/);
+      assert.doesNotMatch(resultText, /intermediateSteps/);
+      assert.doesNotMatch(resultText, /agentSession/);
+    });
+  });
+});

front_end/panels/ai_chat/core/AgentNodes.ts

@@ -4,12 +4,13 @@
 
 import type { getTools } from '../tools/Tools.js';
 import { ChatMessageEntity, type ModelChatMessage, type ToolResultMessage, type ChatMessage, type AgentSessionMessage } from '../ui/ChatView.js';
-import { ConfigurableAgentTool } from '../agent_framework/ConfigurableAgentTool.js';
+import { ConfigurableAgentTool, ToolRegistry } from '../agent_framework/ConfigurableAgentTool.js';
 
 import { LLMClient } from '../LLM/LLMClient.js';
 import type { LLMMessage } from '../LLM/LLMTypes.js';
 import { AIChatPanel } from '../ui/AIChatPanel.js';
 import { createSystemPromptAsync, getAgentToolsFromState } from './GraphHelpers.js';
+import { ToolSurfaceProvider } from './ToolSurfaceProvider.js';
 import { createLogger } from './Logger.js';
 import type { AgentState } from './State.js';
 import type { Runnable } from './Types.js';
@@ -142,12 +143,17 @@ export function createAgentNode(modelName: string, temperature: number): Runnabl
 
       try {
         const llm = LLMClient.getInstance();
-        
+
         // Get provider for the specific model
         const provider = AIChatPanel.getProviderForModel(this.modelName);
-        
-        // Get tools for the current agent type
-        const tools = getAgentToolsFromState(state);
+
+        // Select tools based on MCP mode (all/router/meta)
+        const baseTools = getAgentToolsFromState(state);
+        const selection = await ToolSurfaceProvider.select(state, baseTools, { maxToolsPerTurn: 20, maxMcpPerTurn: 8 });
+        // Persist selection in context so ToolExecutorNode can resolve the same set
+        if (!state.context) { (state as any).context = {}; }
+        (state.context as any).selectedToolNames = selection.selectedNames;
+        const tools = selection.tools;
 
         // Convert ChatMessage[] to LLMMessage[]
         const llmMessages = this.convertChatMessagesToLLMMessages(state.messages);
@@ -421,9 +427,21 @@ export function createAgentNode(modelName: string, temperature: number): Runnabl
 }
 
 export function createToolExecutorNode(state: AgentState): Runnable<AgentState, AgentState> {
-  const tools = getAgentToolsFromState(state); // Adjusted to use getAgentToolsFromState
+  // If AgentNode has pre-selected tool names, honor that set to ensure consistency
+  const selectedNames: string[] | undefined = (state.context as any)?.selectedToolNames;
+  let tools: ReturnType<typeof getTools>;
+  if (selectedNames && selectedNames.length > 0) {
+    const resolved: any[] = [];
+    for (const name of selectedNames) {
+      const inst = ToolRegistry.getRegisteredTool(name as any);
+      if (inst) { resolved.push(inst as any); }
+    }
+    tools = resolved as any;
+  } else {
+    tools = getAgentToolsFromState(state) as any;
+  }
   const toolMap = new Map<string, ReturnType<typeof getTools>[number]>();
-  tools.forEach((tool: ReturnType<typeof getTools>[number]) => toolMap.set(tool.name, tool));
+  (tools as any[]).forEach((tool: any) => toolMap.set(tool.name, tool));
 
   const toolExecutorNode = new class ToolExecutorNode implements Runnable<AgentState, AgentState> {
     private toolMap: Map<string, ReturnType<typeof getTools>[number]>;