test(compat): add e2e raw-shape tools/call test; drop vestigial warn-spy; cover normalizeRawShapeSchema passthrough/undefined

Author: felixweinberger

.converge/round-0/findings.json

@@ -0,0 +1,72 @@
+[
+  {
+    "bug_id": "r0-001",
+    "severity": "nit",
+    "file_path": "packages/server/src/server/mcp.ts",
+    "start_line": 879,
+    "end_line": 891,
+    "pr_comment": "The raw-shape overload requires `InputArgs extends ZodRawShape` but allows `OutputArgs extends ZodRawShape | StandardSchemaWithJSON`. The reverse mix (wrapped `inputSchema` + raw `outputSchema`) matches no overload: overload 1 rejects raw `outputSchema`, overload 2 rejects wrapped `inputSchema`. v1 code was always all-raw so this doesn't break any v1 caller, but the asymmetry is surprising.",
+    "reasoning": "Only matters if someone writes `registerTool('x', {inputSchema: z.object({a: z.string()}), outputSchema: {b: z.number()}}, cb)` — a hybrid that v1 didn't support either. Low impact; could add a third overload `<InputArgs extends StandardSchemaWithJSON, OutputArgs extends ZodRawShape>` for symmetry, or document that raw-shape applies all-or-nothing.",
+    "status": "open"
+  },
+  {
+    "bug_id": "r0-002",
+    "severity": "nit",
+    "file_path": "packages/server/src/server/mcp.ts",
+    "start_line": 43,
+    "end_line": 43,
+    "pr_comment": "`import type * as z from 'zod/v4'` adds `z.ZodType` to the public `.d.mts` surface via `ZodRawShape = Record<string, z.ZodType>`. This is intentional (raw-shape is documented Zod-only and `@deprecated`), and server already depends on zod, but it's a new direct type-surface coupling worth noting in case the intent was to keep server's primary types StandardSchema-only.",
+    "reasoning": "The directive flagged this as a watch-for. It's correctly scoped to the deprecated path; mentioning here so it's on record as a deliberate choice rather than a regression.",
+    "status": "open"
+  },
+  {
+    "bug_id": "r0-003",
+    "severity": "nit",
+    "file_path": "packages/core/src/util/standardSchema.ts",
+    "start_line": 173,
+    "end_line": 175,
+    "pr_comment": "`z.object(schema) as StandardSchemaWithJSON` — the cast is needed because `ZodObject` doesn't structurally narrow to the interface here, but it relies on zod ≥4.2.0 actually providing `~standard.jsonSchema`. On this branch alone the catalog still has `^4.0` (B1/#1895 bumps to ^4.2.0). With zod 4.0.x this cast would type-check but `standardSchemaToJsonSchema(wrapped)` could fail at runtime.",
+    "reasoning": "B1's fallback covers this once both land; on C4 standalone it's a hidden version assumption. Nit because the integration validates with zod 4.2+, and B1 is the right place for the catalog bump.",
+    "status": "open"
+  },
+  {
+    "bug_id": "r0-004",
+    "severity": "nit",
+    "file_path": "packages/server/test/server/mcp.compat.test.ts",
+    "start_line": 7,
+    "end_line": 24,
+    "pr_comment": "Tests verify the schema is wrapped (via `isStandardSchema(tools['a'].inputSchema)`) but never call the tool to confirm the callback actually receives `{x: number}` typed args at runtime. Consider one end-to-end test that connects via InMemoryTransport and calls the tool.",
+    "reasoning": "Current tests prove normalization happened but not that the callback signature works end-to-end. The wrapping is the load-bearing change; the callback typing is asserted only at compile time via the overload.",
+    "status": "open"
+  },
+  {
+    "bug_id": "r0-005",
+    "severity": "nit",
+    "file_path": "packages/server/test/server/mcp.compat.test.ts",
+    "start_line": 8,
+    "end_line": 23,
+    "pr_comment": "`vi.spyOn(console, 'warn')` + `expect(warn).not.toHaveBeenCalled()` are vestiges of the removed `deprecate()` runtime warns. Harmless and they document the no-warn intent, but the spy setup could be dropped for clarity since there's no warn path left in the code under test.",
+    "reasoning": "Policy is JSDoc-only `@deprecated`, no runtime warn. The assertions still pass but test code that guards against a removed mechanism can confuse future readers.",
+    "status": "open"
+  },
+  {
+    "bug_id": "r0-006",
+    "severity": "nit",
+    "file_path": "packages/core/test/util/standardSchema.test.ts",
+    "start_line": 21,
+    "end_line": 26,
+    "pr_comment": "`normalizeRawShapeSchema` tests cover the wrap path but not the passthrough (`normalizeRawShapeSchema(z.object({a: z.string()}))` returns the same instance) or `undefined → undefined`.",
+    "reasoning": "Minor coverage gap; both branches are trivial but documenting them keeps the contract explicit.",
+    "status": "open"
+  },
+  {
+    "bug_id": "r0-007",
+    "severity": "nit",
+    "file_path": "packages/server/src/server/mcp.ts",
+    "start_line": 1113,
+    "end_line": 1131,
+    "pr_comment": "`ZodRawShape`/`InferRawShape`/`LegacyToolCallback`/`LegacyPromptCallback` are also defined by C2 (#1900) for the variadic `.tool()/.prompt()` shims. On each PR alone that's fine; merging both into d1-base/integration produces duplicate exported type declarations in mcp.ts.",
+    "reasoning": "Integration concern, not a defect of this PR. Parent's d1-base merge handles the dedup (`c2efc634` already resolved a C2/C4 overlap once). Noting so it's not re-discovered.",
+    "status": "open"
+  }
+]

.converge/round-0/sha

@@ -0,0 +1 @@
+0152b266fd4ab51de1144b77dd7bed9d1bae79f0

.converge/state.json

@@ -0,0 +1,19 @@
+{
+  "round": 0,
+  "converged": true,
+  "open_red": 0,
+  "open_nit": 7,
+  "lastSha": "0152b266",
+  "base": "9ed62fe7d8be34df88a71d52f1e17a6a767138fd",
+  "depth": "light",
+  "verify_cmd": "pnpm typecheck:all && pnpm lint:all && pnpm build:all && pnpm docs:check && pnpm --filter @modelcontextprotocol/core test && pnpm --filter @modelcontextprotocol/server test",
+  "preflight": {
+    "pass": true,
+    "typecheck": "pass",
+    "lint": "pass",
+    "build": "pass",
+    "docs": "pass",
+    "core_tests": "494/494",
+    "server_tests": "59/59"
+  }
+}

packages/core/test/util/standardSchema.test.ts

@@ -24,6 +24,13 @@ describe('normalizeRawShapeSchema', () => {
         expect(wrapped).toBeDefined();
         expect(standardSchemaToJsonSchema(wrapped!, 'input').type).toBe('object');
     });
+    test('passes through an already-wrapped Standard Schema unchanged', () => {
+        const schema = z.object({ a: z.string() });
+        expect(normalizeRawShapeSchema(schema)).toBe(schema);
+    });
+    test('returns undefined for undefined input', () => {
+        expect(normalizeRawShapeSchema(undefined)).toBeUndefined();
+    });
 });
 
 describe('standardSchemaToJsonSchema', () => {

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

@@ -1,11 +1,11 @@
-import { isStandardSchema } from '@modelcontextprotocol/core';
+import type { JSONRPCMessage } from '@modelcontextprotocol/core';
+import { InMemoryTransport, isStandardSchema, LATEST_PROTOCOL_VERSION } from '@modelcontextprotocol/core';
 import { describe, expect, it, vi } from 'vitest';
 import * as z from 'zod/v4';
 import { McpServer } from '../../src/index.js';
 
 describe('registerTool/registerPrompt accept raw Zod shape (auto-wrapped)', () => {
-    it('registerTool accepts a raw shape for inputSchema, auto-wraps, and does not warn', () => {
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    it('registerTool accepts a raw shape for inputSchema and auto-wraps it', () => {
         const server = new McpServer({ name: 't', version: '1.0.0' });
 
         server.registerTool('a', { inputSchema: { x: z.number() } }, async ({ x }) => ({
@@ -19,9 +19,6 @@ describe('registerTool/registerPrompt accept raw Zod shape (auto-wrapped)', () =
         expect(Object.keys(tools)).toEqual(['a', 'b']);
         // raw shape was wrapped into a Standard Schema (z.object)
         expect(isStandardSchema(tools['a']?.inputSchema)).toBe(true);
-
-        expect(warn).not.toHaveBeenCalled();
-        warn.mockRestore();
     });
 
     it('registerTool accepts a raw shape for outputSchema and auto-wraps it', () => {
@@ -36,20 +33,18 @@ describe('registerTool/registerPrompt accept raw Zod shape (auto-wrapped)', () =
         expect(isStandardSchema(tools['out']?.outputSchema)).toBe(true);
     });
 
-    it('registerTool with z.object() inputSchema also works without warning', () => {
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    it('registerTool with z.object() inputSchema also works (passthrough, no auto-wrap)', () => {
         const server = new McpServer({ name: 't', version: '1.0.0' });
 
         server.registerTool('c', { inputSchema: z.object({ x: z.number() }) }, async ({ x }) => ({
             content: [{ type: 'text' as const, text: String(x) }]
         }));
 
-        expect(warn).not.toHaveBeenCalled();
-        warn.mockRestore();
+        const tools = (server as unknown as { _registeredTools: Record<string, { inputSchema?: unknown }> })._registeredTools;
+        expect(isStandardSchema(tools['c']?.inputSchema)).toBe(true);
     });
 
-    it('registerPrompt accepts a raw shape for argsSchema and does not warn', () => {
-        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+    it('registerPrompt accepts a raw shape for argsSchema', () => {
         const server = new McpServer({ name: 't', version: '1.0.0' });
 
         server.registerPrompt('p', { argsSchema: { topic: z.string() } }, async ({ topic }) => ({
@@ -59,8 +54,48 @@ describe('registerTool/registerPrompt accept raw Zod shape (auto-wrapped)', () =
         const prompts = (server as unknown as { _registeredPrompts: Record<string, { argsSchema?: unknown }> })._registeredPrompts;
         expect(Object.keys(prompts)).toContain('p');
         expect(isStandardSchema(prompts['p']?.argsSchema)).toBe(true);
+    });
+
+    it('callback receives validated, typed args end-to-end via tools/call', async () => {
+        const server = new McpServer({ name: 't', version: '1.0.0' });
+
+        let received: { x: number } | undefined;
+        server.registerTool('echo', { inputSchema: { x: z.number() } }, async args => {
+            received = args;
+            return { content: [{ type: 'text' as const, text: String(args.x) }] };
+        });
+
+        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: 7 } }
+        } as JSONRPCMessage);
+
+        await vi.waitFor(() => expect(responses.some(r => 'id' in r && r.id === 2)).toBe(true));
+
+        expect(received).toEqual({ x: 7 });
+        const result = responses.find(r => 'id' in r && r.id === 2) as { result?: { content: Array<{ text: string }> } };
+        expect(result.result?.content[0]?.text).toBe('7');
 
-        expect(warn).not.toHaveBeenCalled();
-        warn.mockRestore();
+        await server.close();
     });
 });