feat: Add registerTools() bulk method for efficient tool registration

- Adds registerTools() method that accepts an array of tools
- Registers all tools and sends only one list_changed notification
- Prevents memory leak warnings when registering many tools
- Uses same pattern as individual registerTool() method
- Includes comprehensive test coverage

This solves the GitHub issue where registering 80+ tools caused EventEmitter
memory leak warnings due to multiple rapid notifications.

Author: cameroncooke

src/server/mcp.test.ts

@@ -4406,4 +4406,113 @@ describe("elicitInput()", () => {
     expect(toolsResult.tools).toHaveLength(2);
     expect(toolsResult.tools.map(t => t.name).sort()).toEqual(["test2", "tool1"]);
   });
+
+  /***
+   * Test: registerTools() bulk method
+   */
+  test("should register multiple tools with single notification using registerTools()", async () => {
+    const mcpServer = new McpServer({
+      name: "test server",
+      version: "1.0",
+    });
+
+    // Register first tool to establish capabilities
+    mcpServer.tool("initial", async () => ({
+      content: [{ type: "text", text: "Initial" }]
+    }));
+
+    const notifications: Notification[] = []
+    const client = new Client({
+      name: "test client",
+      version: "1.0",
+    });
+    client.fallbackNotificationHandler = async (notification) => {
+      notifications.push(notification)
+    }
+
+    const [clientTransport, serverTransport] =
+      InMemoryTransport.createLinkedPair();
+
+    await Promise.all([
+      client.connect(clientTransport),
+      mcpServer.connect(serverTransport),
+    ]);
+
+    // Clear initial notifications
+    notifications.length = 0;
+
+    // Register multiple tools at once using the bulk method
+    const tools = mcpServer.registerTools([
+      {
+        name: "bulk1",
+        config: { 
+          title: "Bulk Tool 1",
+          description: "First bulk tool"
+        },
+        callback: async () => ({
+          content: [{ type: "text" as const, text: "Bulk 1" }]
+        })
+      },
+      {
+        name: "bulk2", 
+        config: {
+          title: "Bulk Tool 2",
+          description: "Second bulk tool"
+        },
+        callback: async () => ({
+          content: [{ type: "text" as const, text: "Bulk 2" }]
+        })
+      },
+      {
+        name: "bulk3",
+        config: {
+          description: "Third bulk tool"
+        },
+        callback: async () => ({
+          content: [{ type: "text" as const, text: "Bulk 3" }]
+        })
+      }
+    ]);
+
+    // Yield event loop to let notifications process
+    await new Promise(process.nextTick);
+
+    // Should have sent exactly ONE notification for all three tools
+    expect(notifications).toHaveLength(1);
+    expect(notifications[0]).toMatchObject({
+      method: "notifications/tools/list_changed",
+    });
+
+    // Should return array of registered tools
+    expect(tools).toHaveLength(3);
+    expect(tools[0].title).toBe("Bulk Tool 1");
+    expect(tools[1].title).toBe("Bulk Tool 2");
+    expect(tools[2].title).toBeUndefined(); // No title provided
+
+    // Verify all tools are registered and functional
+    const toolsResult = await client.request(
+      { method: "tools/list" },
+      ListToolsResultSchema,
+    );
+    expect(toolsResult.tools).toHaveLength(4); // initial + 3 bulk tools
+    
+    const toolNames = toolsResult.tools.map(t => t.name).sort();
+    expect(toolNames).toEqual(["bulk1", "bulk2", "bulk3", "initial"]);
+
+    // Test that the tools actually work
+    const callResult = await client.request(
+      {
+        method: "tools/call",
+        params: {
+          name: "bulk1",
+          arguments: {}
+        }
+      },
+      CallToolResultSchema,
+    );
+    expect(callResult.content[0]).toMatchObject({
+      type: "text",
+      text: "Bulk 1"
+    });
+  });
 });

src/server/mcp.ts

@@ -955,6 +955,55 @@ export class McpServer {
     return result;
   }
 
+  /**
+   * Registers multiple tools at once with a single notification.
+   * This is more efficient than calling registerTool() multiple times,
+   * especially when registering many tools, as it sends only one list_changed notification.
+   */
+  registerTools<T extends Array<{
+    name: string;
+    config: {
+      title?: string;
+      description?: string;
+      inputSchema?: ZodRawShape;
+      outputSchema?: ZodRawShape;
+      annotations?: ToolAnnotations;
+    };
+    callback: ToolCallback<ZodRawShape | undefined>;
+  }>>(tools: T): RegisteredTool[] {
+    const results: RegisteredTool[] = [];
+
+    // First, validate that none of the tools are already registered
+    for (const { name } of tools) {
+      if (this._registeredTools[name]) {
+        throw new Error(`Tool ${name} is already registered`);
+      }
+    }
+
+    // Register all tools without sending notifications
+    for (const { name, config, callback } of tools) {
+      const { title, description, inputSchema, outputSchema, annotations } = config;
+      
+      const result = this._createRegisteredTool(
+        name,
+        title,
+        description,
+        inputSchema,
+        outputSchema,
+        annotations,
+        callback as ToolCallback<ZodRawShape | undefined>
+      );
+      
+      results.push(result);
+    }
+
+    // Set up handlers and send single notification at the end
+    this.setToolRequestHandlers();
+    this.sendToolListChanged();
+
+    return results;
+  }
+
   /**
    * Registers a zero-argument prompt `name`, which will run the given function when the client calls it.
    */