fix(compat): pass StandardSchema without ~standard.jsonSchema through normalizeRawShapeSchema

The merge from main brought in the zod 4.0-4.1 fallback in
standardSchemaToJsonSchema, but normalizeRawShapeSchema's guard (tightened
to isStandardSchemaWithJSON before that fallback existed on main) threw at
registration time for exactly the schemas the fallback handles, making it
unreachable from registerTool/registerPrompt.

Relax the guard to isStandardSchema so any valid StandardSchema passes
through; standardSchemaToJsonSchema already owns per-vendor handling for
schemas without ~standard.jsonSchema (zod 4.0-4.1 fallback, zod 3 error,
non-zod error). This keeps a single source of truth for what is convertible.

Author: felixweinberger

packages/core/src/util/zodCompat.ts

@@ -7,7 +7,7 @@
 import * as z from 'zod/v4';
 
 import type { StandardSchemaWithJSON } from './standardSchema.js';
-import { isStandardSchema, isStandardSchemaWithJSON } from './standardSchema.js';
+import { isStandardSchema } from './standardSchema.js';
 
 function isZodV4Schema(v: unknown): v is z.ZodType {
     // `_zod` is the v4 internal namespace property. Zod v3 schemas have `_def`
@@ -67,10 +67,14 @@ export function normalizeRawShapeSchema(
             'Raw-shape inputSchema/outputSchema/argsSchema fields must be Zod v4 schemas. Got a Zod v3 field schema. Import from `zod/v4` (or upgrade your zod import), or wrap with `z.object({...})` yourself.'
         );
     }
-    if (!isStandardSchemaWithJSON(schema)) {
+    if (!isStandardSchema(schema)) {
         throw new TypeError(
-            'inputSchema/outputSchema/argsSchema must be a Standard Schema with JSON Schema export (`~standard.jsonSchema`, e.g. z.object({...}) from zod >=4.2.0) or a raw Zod shape ({ field: z.string() }).'
+            'inputSchema/outputSchema/argsSchema must be a Standard Schema (e.g. z.object({...})) or a raw Zod shape ({ field: z.string() }).'
         );
     }
+    // Any StandardSchema passes through; standardSchemaToJsonSchema owns the per-vendor
+    // handling for schemas without `~standard.jsonSchema` (zod 4.0-4.1 fallback, zod 3
+    // and non-zod errors). Gating on `~standard.jsonSchema` here would unreachably
+    // front-run that fallback.
     return schema;
 }

packages/core/test/util/zodCompat.test.ts

@@ -1,3 +1,4 @@
+import { vi } from 'vitest';
 import * as z from 'zod/v4';
 
 import { standardSchemaToJsonSchema } from '../../src/util/standardSchema.js';
@@ -60,9 +61,24 @@ describe('normalizeRawShapeSchema', () => {
     test('throws TypeError for an invalid object that is neither raw shape nor Standard Schema', () => {
         expect(() => normalizeRawShapeSchema({ a: 'not a zod schema' } as never)).toThrow(TypeError);
     });
-    test('throws TypeError for a Standard Schema without JSON Schema export', () => {
+    test('passes through a Standard Schema without `~standard.jsonSchema` (per-vendor handling deferred to standardSchemaToJsonSchema)', () => {
         const noJson = { '~standard': { version: 1, vendor: 'x', validate: () => ({ value: {} }) } };
-        expect(() => normalizeRawShapeSchema(noJson as never)).toThrow(/~standard\.jsonSchema/);
+        expect(normalizeRawShapeSchema(noJson as never)).toBe(noJson);
+    });
+    test('passes through a zod 4.0-4.1 schema so standardSchemaToJsonSchema can apply its z.toJSONSchema fallback', () => {
+        const warn = vi.spyOn(console, 'warn').mockImplementation(() => {});
+        const real = z.object({ a: z.string() });
+        // Simulate zod 4.0-4.1: shadow `~standard` with `jsonSchema` removed, keep `_zod` intact.
+        const { jsonSchema: _drop, ...stdNoJson } = real['~standard'] as unknown as Record<string, unknown>;
+        void _drop;
+        Object.defineProperty(real, '~standard', { value: { ...stdNoJson, vendor: 'zod' }, configurable: true });
+
+        const normalized = normalizeRawShapeSchema(real);
+        expect(normalized).toBe(real);
+        const json = standardSchemaToJsonSchema(normalized!, 'input');
+        expect(json.type).toBe('object');
+        expect((json.properties as Record<string, unknown>)?.a).toBeDefined();
+        warn.mockRestore();
     });
     test('throws actionable TypeError for a raw shape with Zod v3 fields', () => {
         expect(() => normalizeRawShapeSchema({ a: mockZodV3String() } as never)).toThrow(/Zod v4 schemas.*Got a Zod v3 field schema/);

packages/server/src/server/mcp.ts

@@ -39,8 +39,8 @@ import {
     validateAndWarnToolName,
     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';