Return protocol errors for invalid tool arguments

.changeset/tool-input-protocol-error.md

@@ -0,0 +1,5 @@
+---
+"@modelcontextprotocol/server": patch
+---
+
+Return protocol errors for invalid tool arguments instead of tool execution errors.

packages/server/src/server/mcp.ts

@@ -208,8 +208,8 @@ export class McpServer {
                 await this.validateToolOutput(tool, result, request.params.name);
                 return result;
             } catch (error) {
-                if (error instanceof ProtocolError && error.code === ProtocolErrorCode.UrlElicitationRequired) {
-                    throw error; // Return the error to the caller without wrapping in CallToolResult
+                if (error instanceof ProtocolError && this.shouldReturnProtocolError(error)) {
+                    throw error; // Invalid client-supplied arguments and elicitation requests are protocol errors.
                 }
                 return this.createToolError(error instanceof Error ? error.message : String(error));
             }
@@ -236,6 +236,13 @@ export class McpServer {
         };
     }
 
+    private shouldReturnProtocolError(error: ProtocolError): boolean {
+        return (
+            error.code === ProtocolErrorCode.UrlElicitationRequired ||
+            (error.code === ProtocolErrorCode.InvalidParams && error.message.startsWith('Input validation error:'))
+        );
+    }
+
     /**
      * Validates tool input arguments against the tool's input schema.
      */

packages/server/test/server/mcp.compat.test.ts

@@ -2,9 +2,10 @@ import type { JSONRPCMessage } from '@modelcontextprotocol/core';
 import { InMemoryTransport, isStandardSchema, LATEST_PROTOCOL_VERSION } from '@modelcontextprotocol/core';
 import { describe, expect, expectTypeOf, it, vi } from 'vitest';
 import * as z from 'zod/v4';
+
 import { McpServer } from '../../src/index.js';
-import type { InferRawShape } from '../../src/server/mcp.js';
 import { completable } from '../../src/server/completable.js';
+import type { InferRawShape } from '../../src/server/mcp.js';
 
 describe('registerTool/registerPrompt accept raw Zod shape (auto-wrapped)', () => {
     it('registerTool accepts a raw shape for inputSchema and auto-wraps it', () => {
@@ -119,6 +120,55 @@ describe('registerTool/registerPrompt accept raw Zod shape (auto-wrapped)', () =
 
         await server.close();
     });
+
+    it('returns a protocol error for invalid tool arguments', async () => {
+        const server = new McpServer({ name: 't', version: '1.0.0' });
+
+        const handler = vi.fn(async () => ({
+            content: [{ type: 'text' as const, text: 'should not run' }]
+        }));
+        server.registerTool('echo', { inputSchema: { x: z.number() } }, handler);
+
+        const [client, srv] = InMemoryTransport.createLinkedPair();
+        await server.connect(srv);
+        await client.start();
+
+        const responses: JSONRPCMessage[] = [];
+        client.onmessage = m => responses.push(m);
+
+        await client.send({
+            jsonrpc: '2.0',
+            id: 1,
+            method: 'initialize',
+            params: {
+                protocolVersion: LATEST_PROTOCOL_VERSION,
+                capabilities: {},
+                clientInfo: { name: 'c', version: '1.0.0' }
+            }
+        } as JSONRPCMessage);
+        await client.send({ jsonrpc: '2.0', method: 'notifications/initialized' } as JSONRPCMessage);
+        await client.send({
+            jsonrpc: '2.0',
+            id: 2,
+            method: 'tools/call',
+            params: { name: 'echo', arguments: { x: 'not-a-number' } }
+        } as JSONRPCMessage);
+
+        await vi.waitFor(() => expect(responses.some(r => 'id' in r && r.id === 2)).toBe(true));
+
+        expect(handler).not.toHaveBeenCalled();
+        const response = responses.find(r => 'id' in r && r.id === 2) as {
+            error?: { code: number; message: string };
+            result?: unknown;
+        };
+        expect(response.result).toBeUndefined();
+        expect(response.error).toMatchObject({
+            code: -32_602,
+            message: expect.stringContaining('Invalid arguments for tool echo')
+        });
+
+        await server.close();
+    });
 });
 
 describe('InferRawShape', () => {

test/integration/test/server/mcp.test.ts

@@ -1,5 +1,5 @@
 import { Client } from '@modelcontextprotocol/client';
-import type { CallToolResult, Notification, TextContent } from '@modelcontextprotocol/core';
+import type { CallToolResult, Notification, ProtocolError, TextContent } from '@modelcontextprotocol/core';
 import {
     getDisplayName,
     InMemoryTaskStore,
@@ -28,6 +28,18 @@ function createLatch() {
     };
 }
 
+async function expectInvalidToolArguments(call: Promise<unknown>): Promise<ProtocolError> {
+    try {
+        await call;
+        throw new Error('Expected invalid tool arguments to reject');
+    } catch (error) {
+        const protocolError = error as ProtocolError;
+        expect(protocolError.code).toBe(ProtocolErrorCode.InvalidParams);
+        expect(protocolError.message).toContain('Input validation error');
+        return protocolError;
+    }
+}
+
 describe('Zod v4', () => {
     describe('McpServer', () => {
         /***
@@ -1212,26 +1224,20 @@ describe('Zod v4', () => {
 
             await Promise.all([client.connect(clientTransport), mcpServer.server.connect(serverTransport)]);
 
-            const result = await client.request({
-                method: 'tools/call',
-                params: {
-                    name: 'test',
-                    arguments: {
+            const error = await expectInvalidToolArguments(
+                client.request({
+                    method: 'tools/call',
+                    params: {
                         name: 'test',
-                        value: 'not a number'
-                    }
-                }
-            });
-
-            expect(result.isError).toBe(true);
-            expect(result.content).toEqual(
-                expect.arrayContaining([
-                    {
-                        type: 'text',
-                        text: expect.stringContaining('Input validation error: Invalid arguments for tool test')
+                        arguments: {
+                            name: 'test',
+                            value: 'not a number'
+                        }
                     }
-                ])
+                })
             );
+
+            expect(error.message).toContain('Input validation error: Invalid arguments for tool test');
         });
 
         /***
@@ -5149,22 +5155,14 @@ describe('Zod v4', () => {
             await server.connect(serverTransport);
             await client.connect(clientTransport);
 
-            const invalidTypeResult = await client.callTool({
-                name: 'union-test',
-                arguments: {
-                    type: 'a',
-                    value: 123
-                }
-            });
-
-            expect(invalidTypeResult.isError).toBe(true);
-            expect(invalidTypeResult.content).toEqual(
-                expect.arrayContaining([
-                    expect.objectContaining({
-                        type: 'text',
-                        text: expect.stringContaining('Input validation error')
-                    })
-                ])
+            await expectInvalidToolArguments(
+                client.callTool({
+                    name: 'union-test',
+                    arguments: {
+                        type: 'a',
+                        value: 123
+                    }
+                })
             );
         });
     });
@@ -6407,40 +6405,24 @@ describe('Zod v4', () => {
             await server.connect(serverTransport);
             await client.connect(clientTransport);
 
-            const invalidTypeResult = await client.callTool({
-                name: 'union-test',
-                arguments: {
-                    type: 'a',
-                    value: 123
-                }
-            });
-
-            expect(invalidTypeResult.isError).toBe(true);
-            expect(invalidTypeResult.content).toEqual(
-                expect.arrayContaining([
-                    expect.objectContaining({
-                        type: 'text',
-                        text: expect.stringContaining('Input validation error')
-                    })
-                ])
+            await expectInvalidToolArguments(
+                client.callTool({
+                    name: 'union-test',
+                    arguments: {
+                        type: 'a',
+                        value: 123
+                    }
+                })
             );
 
-            const invalidDiscriminatorResult = await client.callTool({
-                name: 'union-test',
-                arguments: {
-                    type: 'c',
-                    value: 'test'
-                }
-            });
-
-            expect(invalidDiscriminatorResult.isError).toBe(true);
-            expect(invalidDiscriminatorResult.content).toEqual(
-                expect.arrayContaining([
-                    expect.objectContaining({
-                        type: 'text',
-                        text: expect.stringContaining('Input validation error')
-                    })
-                ])
+            await expectInvalidToolArguments(
+                client.callTool({
+                    name: 'union-test',
+                    arguments: {
+                        type: 'c',
+                        value: 'test'
+                    }
+                })
             );
         });
     });