fix(compat): narrow ZodRawShape to Zod-only (detector + type); add outputSchema raw-shape test

Author: felixweinberger

packages/core/src/util/standardSchema.ts

@@ -138,19 +138,25 @@ export function isStandardSchemaWithJSON(schema: unknown): schema is StandardSch
     return isStandardJSONSchema(schema) && isStandardSchema(schema);
 }
 
+function isZodSchema(v: unknown): v is z.ZodType {
+    if (typeof v !== 'object' || v === null) return false;
+    if ('_def' in v) return true;
+    return isStandardSchema(v) && (v as StandardSchemaV1)['~standard'].vendor === 'zod';
+}
+
 /**
  * Detects a "raw shape" — a plain object whose values are Zod field schemas,
  * e.g. `{ name: z.string() }`. Powers the auto-wrap in
  * {@linkcode normalizeRawShapeSchema}, which wraps with `z.object()`, so only
- * Zod values are supported even though the predicate accepts any Standard Schema.
+ * Zod values are supported.
  *
  * @internal
  */
-export function isZodRawShape(obj: unknown): obj is Record<string, StandardSchemaV1> {
+export function isZodRawShape(obj: unknown): obj is Record<string, z.ZodType> {
     if (typeof obj !== 'object' || obj === null) return false;
     if (isStandardSchema(obj)) return false;
     // [].every() is true, so an empty object is a valid raw shape (matches v1).
-    return Object.values(obj).every(v => isStandardSchema(v) || (typeof v === 'object' && v !== null && '_def' in v));
+    return Object.values(obj).every(v => isZodSchema(v));
 }
 
 /**
@@ -162,11 +168,11 @@ export function isZodRawShape(obj: unknown): obj is Record<string, StandardSchem
  * @internal
  */
 export function normalizeRawShapeSchema(
-    schema: StandardSchemaWithJSON | Record<string, StandardSchemaV1> | undefined
+    schema: StandardSchemaWithJSON | Record<string, z.ZodType> | undefined
 ): StandardSchemaWithJSON | undefined {
     if (schema === undefined) return undefined;
     if (isZodRawShape(schema)) {
-        return z.object(schema as z.ZodRawShape) as StandardSchemaWithJSON;
+        return z.object(schema) as StandardSchemaWithJSON;
     }
     return schema;
 }

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

@@ -12,6 +12,10 @@ describe('isZodRawShape', () => {
     test('rejects a Standard Schema instance', () => {
         expect(isZodRawShape(z.object({ a: z.string() }))).toBe(false);
     });
+    test('rejects a shape with non-Zod Standard Schema fields', () => {
+        const nonZod = { '~standard': { version: 1, vendor: 'arktype', validate: () => ({ value: 'x' }) } };
+        expect(isZodRawShape({ a: nonZod })).toBe(false);
+    });
 });
 
 describe('normalizeRawShapeSchema', () => {

packages/server/src/server/mcp.ts

@@ -40,6 +40,7 @@ import {
     validateStandardSchema
 } from '@modelcontextprotocol/core';
 
+import type * as z from 'zod/v4';
 import type { ToolTaskHandler } from '../experimental/tasks/interfaces.js';
 import { ExperimentalMcpServerTasks } from '../experimental/tasks/mcpServer.js';
 import { getCompleter, isCompletable } from './completable.js';
@@ -1110,13 +1111,14 @@ export class ResourceTemplate {
 }
 
 /**
- * A plain record of field schemas, e.g. `{ name: z.string() }`. Accepted by
+ * A plain record of Zod field schemas, e.g. `{ name: z.string() }`. Accepted by
  * `registerTool`/`registerPrompt` as a shorthand; auto-wrapped with `z.object()`.
+ * Zod schemas only — `z.object()` cannot wrap other Standard Schema libraries.
  */
-export type ZodRawShape = Record<string, StandardSchemaWithJSON>;
+export type ZodRawShape = Record<string, z.ZodType>;
 
 /** Infers the parsed-output type of a {@linkcode ZodRawShape}. */
-export type InferRawShape<S extends ZodRawShape> = { [K in keyof S]: StandardSchemaWithJSON.InferOutput<S[K]> };
+export type InferRawShape<S extends ZodRawShape> = { [K in keyof S]: z.output<S[K]> };
 
 /** {@linkcode ToolCallback} variant used when `inputSchema` is a {@linkcode ZodRawShape}. */
 export type LegacyToolCallback<Args extends ZodRawShape | undefined> = Args extends ZodRawShape

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

@@ -24,6 +24,18 @@ describe('registerTool/registerPrompt accept raw Zod shape (auto-wrapped)', () =
         warn.mockRestore();
     });
 
+    it('registerTool accepts a raw shape for outputSchema and auto-wraps it', () => {
+        const server = new McpServer({ name: 't', version: '1.0.0' });
+
+        server.registerTool('out', { inputSchema: { n: z.number() }, outputSchema: { result: z.string() } }, async ({ n }) => ({
+            content: [{ type: 'text' as const, text: String(n) }],
+            structuredContent: { result: String(n) }
+        }));
+
+        const tools = (server as unknown as { _registeredTools: Record<string, { outputSchema?: unknown }> })._registeredTools;
+        expect(isStandardSchema(tools['out']?.outputSchema)).toBe(true);
+    });
+
     it('registerTool with z.object() inputSchema also works without warning', () => {
         const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
         const server = new McpServer({ name: 't', version: '1.0.0' });