feat: add optional strict parameter to registerTool for Zod validation

  Add strict parameter to registerTool config that defaults to false for
  backward compatibility. When strict=true, applies .strict() to Zod
  schema creation for tool input validation to throw errors on unknown
  parameters instead of silently ignoring them.

  - Add strict?: boolean to registerTool config interface
  - Modify _createRegisteredTool to accept and use strict parameter
  - Apply z.object(inputSchema).strict() when strict=true
  - Update legacy tool() method to pass strict=false (backward compatibility)
  - Update test to verify strict validation rejects unknown parameters
  - All existing tests continue to pass (no breaking changes)

  This fixes the issue where parameter name typos are silently dropped,
  leading to confusing behavior where tools execute with missing data.

Author: Adam Bloomston

src/server/mcp.test.ts

@@ -4125,4 +4125,44 @@ describe('elicitInput()', () => {
         expect(result.isError).toBe(true);
         expect(result.content[0].text).toContain('Invalid arguments');
     });
+
+    test('should reject unknown parameters when strict validation is enabled', async () => {
+        const mcpServer = new McpServer({
+            name: 'test server',
+            version: '1.0'
+        });
+
+        const client = new Client({
+            name: 'test client',
+            version: '1.0'
+        });
+
+        mcpServer.registerTool(
+            'test-strict',
+            {
+                inputSchema: { userName: z.string().optional(), itemCount: z.number().optional() },
+                strict: true
+            },
+            async ({ userName, itemCount }) => ({
+                content: [{ type: 'text', text: `${userName || 'none'}: ${itemCount || 0}` }]
+            })
+        );
+
+        const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+        await Promise.all([client.connect(clientTransport), mcpServer.server.connect(serverTransport)]);
+
+        await expect(
+            client.request(
+                {
+                    method: 'tools/call',
+                    params: {
+                        name: 'test-strict',
+                        arguments: { username: 'test', itemcount: 42 }
+                    }
+                },
+                CallToolResultSchema
+            )
+        ).rejects.toThrow('Invalid arguments');
+    });
 });

src/server/mcp.ts

@@ -647,13 +647,14 @@ export class McpServer {
         inputSchema: ZodRawShape | undefined,
         outputSchema: ZodRawShape | undefined,
         annotations: ToolAnnotations | undefined,
+        strict: boolean | undefined,
         _meta: Record<string, unknown> | undefined,
         callback: ToolCallback<ZodRawShape | undefined>
     ): RegisteredTool {
         const registeredTool: RegisteredTool = {
             title,
             description,
-            inputSchema: inputSchema === undefined ? undefined : z.object(inputSchema),
+            inputSchema: inputSchema === undefined ? undefined : strict === true ? z.object(inputSchema).strict() : z.object(inputSchema),
             outputSchema: outputSchema === undefined ? undefined : z.object(outputSchema),
             annotations,
             _meta,
@@ -780,7 +781,7 @@ export class McpServer {
         }
         const callback = rest[0] as ToolCallback<ZodRawShape | undefined>;
 
-        return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, undefined, callback);
+        return this._createRegisteredTool(name, undefined, description, inputSchema, outputSchema, annotations, false, undefined, callback);
     }
 
     /**
@@ -794,6 +795,7 @@ export class McpServer {
             inputSchema?: InputArgs;
             outputSchema?: OutputArgs;
             annotations?: ToolAnnotations;
+            strict?: boolean;
             _meta?: Record<string, unknown>;
         },
         cb: ToolCallback<InputArgs>
@@ -802,7 +804,7 @@ export class McpServer {
             throw new Error(`Tool ${name} is already registered`);
         }
 
-        const { title, description, inputSchema, outputSchema, annotations, _meta } = config;
+        const { title, description, inputSchema, outputSchema, annotations, strict, _meta } = config;
 
         return this._createRegisteredTool(
             name,
@@ -811,6 +813,7 @@ export class McpServer {
             inputSchema,
             outputSchema,
             annotations,
+            strict,
             _meta,
             cb as ToolCallback<ZodRawShape | undefined>
         );