refactor: integrate filtered tool logic into agent-level, clean up tests and server impl

Author: vrtnis

examples/mcp/tool-filter-example.ts

@@ -12,10 +12,10 @@ async function main() {
   const mcpServer = new MCPServerStdio({
     name: 'Filesystem Server with filter',
     fullCommand: `npx -y @modelcontextprotocol/server-filesystem ${samplesDir}`,
-    toolFilter: createStaticToolFilter(
-      ['read_file', 'list_directory'],
-      ['write_file'],
-    ),
+    toolFilter: createStaticToolFilter({
+      allowed: ['read_file', 'list_directory'],
+      blocked: ['write_file'],
+    }),
   });
 
   await mcpServer.connect();

packages/agents-core/src/mcpUtil.ts

@@ -28,19 +28,19 @@ export interface ToolFilterStatic {
 }
 
 /** Convenience helper to create a static tool filter. */
-export function createStaticToolFilter(
-  allowedToolNames?: string[],
-  blockedToolNames?: string[],
-): ToolFilterStatic | undefined {
-  if (!allowedToolNames && !blockedToolNames) {
+export function createStaticToolFilter(options?: {
+  allowed?: string[];
+  blocked?: string[];
+}): ToolFilterStatic | undefined {
+  if (!options?.allowed && !options?.blocked) {
     return undefined;
   }
   const filter: ToolFilterStatic = {};
-  if (allowedToolNames) {
-    filter.allowedToolNames = allowedToolNames;
+  if (options?.allowed) {
+    filter.allowedToolNames = options.allowed;
   }
-  if (blockedToolNames) {
-    filter.blockedToolNames = blockedToolNames;
+  if (options?.blocked) {
+    filter.blockedToolNames = options.blocked;
   }
   return filter;
 }

packages/agents-core/src/shims/mcp-server/node.ts

@@ -12,7 +12,6 @@ import {
   invalidateServerToolsCache,
 } from '../../mcp';
 import logger from '../../logger';
-import type { ToolFilterContext } from '../../mcpUtil';
 import type { RunContext } from '../../runContext';
 import type { Agent } from '../../agent';
 
@@ -99,52 +98,9 @@ export class NodeMCPServerStdio extends BaseMCPServerStdio {
     this._cacheDirty = true;
   }
 
-  // The response element type is intentionally left as `any` to avoid explosing MCP SDK type dependencies.
-  protected async _applyToolFilter(
-    tools: MCPTool[],
-    runContext?: RunContext<any>,
-    agent?: Agent<any, any>,
-  ): Promise<MCPTool[]> {
-    if (!this.toolFilter) {
-      return tools;
-    }
-
-    if (typeof this.toolFilter === 'function') {
-      const ctx = {
-        runContext: runContext as RunContext<any>,
-        agent: agent as Agent<any, any>,
-        serverName: this.name,
-      } as ToolFilterContext<any>;
-      const filtered: MCPTool[] = [];
-      for (const t of tools) {
-        try {
-          const res = this.toolFilter(ctx, t);
-          const include = res instanceof Promise ? await res : res;
-          if (include) filtered.push(t);
-        } catch (e) {
-          this.logger.error(
-            `Error applying tool filter to tool '${t.name}' on server '${this.name}': ${e}`,
-          );
-        }
-      }
-      return filtered;
-    }
-
-    let filtered = tools;
-    if (this.toolFilter.allowedToolNames) {
-      const allowed = new Set(this.toolFilter.allowedToolNames);
-      filtered = filtered.filter((t) => allowed.has(t.name));
-    }
-    if (this.toolFilter.blockedToolNames) {
-      const blocked = new Set(this.toolFilter.blockedToolNames);
-      filtered = filtered.filter((t) => !blocked.has(t.name));
-    }
-    return filtered;
-  }
-
   async listTools(
-    runContext?: RunContext<any>,
-    agent?: Agent<any, any>,
+    _runContext?: RunContext<any>,
+    _agent?: Agent<any, any>,
   ): Promise<MCPTool[]> {
     const { ListToolsResultSchema } = await import(
       '@modelcontextprotocol/sdk/types.js'
@@ -154,17 +110,15 @@ export class NodeMCPServerStdio extends BaseMCPServerStdio {
         'Server not initialized. Make sure you call connect() first.',
       );
     }
-    let tools: MCPTool[];
     if (this.cacheToolsList && !this._cacheDirty && this._toolsList) {
-      tools = this._toolsList;
-    } else {
-      this._cacheDirty = false;
-      const response = await this.session.listTools();
-      this.debugLog(() => `Listed tools: ${JSON.stringify(response)}`);
-      this._toolsList = ListToolsResultSchema.parse(response).tools;
-      tools = this._toolsList;
+      return this._toolsList;
     }
-    return this._applyToolFilter(tools, runContext, agent);
+
+    this._cacheDirty = false;
+    const response = await this.session.listTools();
+    this.debugLog(() => `Listed tools: ${JSON.stringify(response)}`);
+    this._toolsList = ListToolsResultSchema.parse(response).tools;
+    return this._toolsList;
   }
 
   async callTool(
@@ -264,51 +218,9 @@ export class NodeMCPServerStreamableHttp extends BaseMCPServerStreamableHttp {
     this._cacheDirty = true;
   }
 
-  // The response element type is intentionally left as `any` to avoid explosing MCP SDK type dependencies.
-  protected async _applyToolFilter(
-    tools: MCPTool[],
-    runContext?: RunContext<any>,
-    agent?: Agent<any, any>,
-  ): Promise<MCPTool[]> {
-    if (!this.toolFilter) {
-      return tools;
-    }
-    if (typeof this.toolFilter === 'function') {
-      const ctx: ToolFilterContext<any> = {
-        runContext: runContext as RunContext<any>,
-        agent: agent as Agent<any, any>,
-        serverName: this.name,
-      };
-      const filtered: MCPTool[] = [];
-      for (const t of tools) {
-        try {
-          const res = this.toolFilter(ctx, t);
-          const include = res instanceof Promise ? await res : res;
-          if (include) filtered.push(t);
-        } catch (e) {
-          this.logger.error(
-            `Error applying tool filter to tool '${t.name}' on server '${this.name}': ${e}`,
-          );
-        }
-      }
-      return filtered;
-    }
-
-    let filtered = tools;
-    if (this.toolFilter.allowedToolNames) {
-      const allowed = new Set(this.toolFilter.allowedToolNames);
-      filtered = filtered.filter((t) => allowed.has(t.name));
-    }
-    if (this.toolFilter.blockedToolNames) {
-      const blocked = new Set(this.toolFilter.blockedToolNames);
-      filtered = filtered.filter((t) => !blocked.has(t.name));
-    }
-    return filtered;
-  }
-
   async listTools(
-    runContext?: RunContext<any>,
-    agent?: Agent<any, any>,
+    _runContext?: RunContext<any>,
+    _agent?: Agent<any, any>,
   ): Promise<MCPTool[]> {
     const { ListToolsResultSchema } = await import(
       '@modelcontextprotocol/sdk/types.js'
@@ -318,17 +230,15 @@ export class NodeMCPServerStreamableHttp extends BaseMCPServerStreamableHttp {
         'Server not initialized. Make sure you call connect() first.',
       );
     }
-    let tools: MCPTool[];
     if (this.cacheToolsList && !this._cacheDirty && this._toolsList) {
-      tools = this._toolsList;
-    } else {
-      this._cacheDirty = false;
-      const response = await this.session.listTools();
-      this.debugLog(() => `Listed tools: ${JSON.stringify(response)}`);
-      this._toolsList = ListToolsResultSchema.parse(response).tools;
-      tools = this._toolsList;
+      return this._toolsList;
     }
-    return this._applyToolFilter(tools, runContext, agent);
+
+    this._cacheDirty = false;
+    const response = await this.session.listTools();
+    this.debugLog(() => `Listed tools: ${JSON.stringify(response)}`);
+    this._toolsList = ListToolsResultSchema.parse(response).tools;
+    return this._toolsList;
   }
 
   async callTool(

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

@@ -49,7 +49,7 @@ describe('MCP tool filtering', () => {
       const server = new StubServer(
         's',
         tools,
-        createStaticToolFilter(['a'], ['b']),
+        createStaticToolFilter({ allowed: ['a'], blocked: ['b'] }),
       );
       const agent = new Agent({
         name: 'agent',
@@ -61,7 +61,7 @@ describe('MCP tool filtering', () => {
       });
       const runContext = new RunContext();
       const result = await server.listTools(runContext, agent);
-      expect(result.map((t) => t.name)).toEqual(['a']);
+      expect(result.map((t) => t.name)).toEqual(['a', 'b']);
     });
   });
 
@@ -101,7 +101,7 @@ describe('MCP tool filtering', () => {
       });
       const runContext = new RunContext();
       const result = await server.listTools(runContext, agent);
-      expect(result.map((t) => t.name)).toEqual(['good']);
+      expect(result.map((t) => t.name)).toEqual(['good', 'bad']);
     });
   });
 
@@ -144,7 +144,7 @@ describe('MCP tool filtering', () => {
       const serverA = new StubServer(
         'A',
         toolsA,
-        createStaticToolFilter(['a1']),
+        createStaticToolFilter({ allowed: ['a1'] }),
       );
       const serverB = new StubServer('B', toolsB);
       const agent = new Agent({
@@ -158,7 +158,7 @@ describe('MCP tool filtering', () => {
       const runContext = new RunContext();
       const resultA = await serverA.listTools(runContext, agent);
       const resultB = await serverB.listTools(runContext, agent);
-      expect(resultA.map((t) => t.name)).toEqual(['a1']);
+      expect(resultA.map((t) => t.name)).toEqual(['a1', 'a2']);
       expect(resultB.map((t) => t.name)).toEqual(['b1']);
     });
   });
@@ -180,7 +180,7 @@ describe('MCP tool filtering', () => {
       const server = new StubServer(
         'cache',
         tools,
-        createStaticToolFilter(['x']),
+        createStaticToolFilter({ allowed: ['x'] }),
       );
       const agent = new Agent({
         name: 'agent',
@@ -193,9 +193,9 @@ describe('MCP tool filtering', () => {
       const runContext = new RunContext();
       let result = await server.listTools(runContext, agent);
       expect(result.map((t) => t.name)).toEqual(['x']);
-      server.toolFilter = createStaticToolFilter(['y']);
+      (server as any).toolFilter = createStaticToolFilter({ allowed: ['y'] });
       result = await server.listTools(runContext, agent);
-      expect(result.map((t) => t.name)).toEqual([]);
+      expect(result.map((t) => t.name)).toEqual(['x']);
     });
   });
 });