revert: restore MCPServer interface and listTools signature

Reverts prior tool filtering interface changes and updates corresponding tests.

Author: vrtnis

packages/agents-core/src/mcp.ts

@@ -14,11 +14,7 @@ import {
   JsonObjectSchemaStrict,
   UnknownContext,
 } from './types';
-import type {
-  ToolFilterCallable,
-  ToolFilterStatic,
-  ToolFilterContext,
-} from './mcpUtil';
+import type { ToolFilterCallable, ToolFilterStatic } from './mcpUtil';
 import type { RunContext } from './runContext';
 import type { Agent } from './agent';
 
@@ -34,7 +30,6 @@ export const DEFAULT_STREAMABLE_HTTP_MCP_CLIENT_LOGGER_NAME =
  */
 export interface MCPServer {
   cacheToolsList: boolean;
-  toolFilter?: ToolFilterCallable | ToolFilterStatic;
   connect(): Promise<void>;
   readonly name: string;
   close(): Promise<void>;
@@ -52,7 +47,7 @@ export interface MCPServer {
 export abstract class BaseMCPServerStdio implements MCPServer {
   public cacheToolsList: boolean;
   protected _cachedTools: any[] | undefined = undefined;
-  public toolFilter?: ToolFilterCallable | ToolFilterStatic;
+  protected toolFilter?: ToolFilterCallable | ToolFilterStatic;
 
   protected logger: Logger;
   constructor(options: MCPServerStdioOptions) {
@@ -90,7 +85,7 @@ export abstract class BaseMCPServerStdio implements MCPServer {
 export abstract class BaseMCPServerStreamableHttp implements MCPServer {
   public cacheToolsList: boolean;
   protected _cachedTools: any[] | undefined = undefined;
-  public toolFilter?: ToolFilterCallable | ToolFilterStatic;
+  protected toolFilter?: ToolFilterCallable | ToolFilterStatic;
 
   protected logger: Logger;
   constructor(options: MCPServerStreamableHttpOptions) {
@@ -163,13 +158,13 @@ export class MCPServerStdio extends BaseMCPServerStdio {
     return this.underlying.close();
   }
   async listTools(
-    _runContext?: RunContext<any>,
-    _agent?: Agent<any, any>,
+    runContext?: RunContext<any>,
+    agent?: Agent<any, any>,
   ): Promise<MCPTool[]> {
     if (this.cacheToolsList && this._cachedTools) {
       return this._cachedTools;
     }
-    const tools = await this.underlying.listTools();
+    const tools = await this.underlying.listTools(runContext, agent);
     if (this.cacheToolsList) {
       this._cachedTools = tools;
     }
@@ -202,13 +197,13 @@ export class MCPServerStreamableHttp extends BaseMCPServerStreamableHttp {
     return this.underlying.close();
   }
   async listTools(
-    _runContext?: RunContext<any>,
-    _agent?: Agent<any, any>,
+    runContext?: RunContext<any>,
+    agent?: Agent<any, any>,
   ): Promise<MCPTool[]> {
     if (this.cacheToolsList && this._cachedTools) {
       return this._cachedTools;
     }
-    const tools = await this.underlying.listTools();
+    const tools = await this.underlying.listTools(runContext, agent);
     if (this.cacheToolsList) {
       this._cachedTools = tools;
     }
@@ -284,16 +279,7 @@ async function getFunctionToolsFromServer<TContext = UnknownContext>(
   }
   return withMCPListToolsSpan(
     async (span) => {
-      let mcpTools = await server.listTools(runContext, agent);
-      if (server.toolFilter) {
-        mcpTools = await filterMcpTools(
-          mcpTools,
-          server.toolFilter as ToolFilterCallable<TContext> | ToolFilterStatic,
-          runContext,
-          agent,
-          server.name,
-        );
-      }
+      const mcpTools = await server.listTools(runContext, agent);
       span.spanData.result = mcpTools.map((t) => t.name);
       const tools: FunctionTool<TContext, any, string>[] = mcpTools.map((t) =>
         mcpToFunctionTool(t, server, convertSchemasToStrict),
@@ -396,41 +382,6 @@ function ensureStrictJsonSchema(
   return out;
 }
 
-async function filterMcpTools<TContext = UnknownContext>(
-  tools: MCPTool[],
-  filter: ToolFilterCallable<TContext> | ToolFilterStatic,
-  runContext: RunContext<TContext> | undefined,
-  agent: Agent<TContext, any> | undefined,
-  serverName: string,
-): Promise<MCPTool[]> {
-  if (typeof filter === 'function') {
-    if (!runContext || !agent) {
-      return tools;
-    }
-    const ctx = {
-      runContext,
-      agent,
-      serverName,
-    } as ToolFilterContext<TContext>;
-    const result: MCPTool[] = [];
-    for (const tool of tools) {
-      if (await filter(ctx, tool)) {
-        result.push(tool);
-      }
-    }
-    return result;
-  }
-  return tools.filter((t) => {
-    if (filter.allowedToolNames && !filter.allowedToolNames.includes(t.name)) {
-      return false;
-    }
-    if (filter.blockedToolNames && filter.blockedToolNames.includes(t.name)) {
-      return false;
-    }
-    return true;
-  });
-}
-
 /**
  * Abstract base class for MCP servers that use a ClientSession for communication.
  * Handles session management, tool listing, tool calling, and cleanup.

packages/agents-core/test/mcpToolFilter.test.ts

@@ -2,7 +2,6 @@ import { describe, it, expect } from 'vitest';
 import { withTrace } from '../src/tracing';
 import { NodeMCPServerStdio } from '../src/shims/mcp-server/node';
 import { createStaticToolFilter } from '../src/mcpUtil';
-import { getAllMcpTools } from '../src/mcp';
 import { Agent } from '../src/agent';
 import { RunContext } from '../src/runContext';
 
@@ -199,47 +198,4 @@ describe('MCP tool filtering', () => {
       expect(result.map((t) => t.name)).toEqual(['x']);
     });
   });
-
-  it('applies filter in getAllMcpTools', async () => {
-    await withTrace('test', async () => {
-      const tools = [
-        {
-          name: 'allow',
-          description: '',
-          inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-            additionalProperties: false,
-          },
-        },
-        {
-          name: 'block',
-          description: '',
-          inputSchema: {
-            type: 'object',
-            properties: {},
-            required: [],
-            additionalProperties: false,
-          },
-        },
-      ];
-      const server = new StubServer(
-        'filter',
-        tools,
-        createStaticToolFilter({ allowed: ['allow'] }),
-      );
-      const agent = new Agent({
-        name: 'agent',
-        instructions: '',
-        model: '',
-        modelSettings: {},
-        tools: [],
-        mcpServers: [server],
-      });
-      const runContext = new RunContext();
-      const result = await getAllMcpTools([server], false, runContext, agent);
-      expect(result.map((t) => t.name)).toEqual(['allow']);
-    });
-  });
 });