fix(core): reject Standard Schema failures with empty issues

Author: MindOfqc

.changeset/standard-schema-empty-issues.md

@@ -0,0 +1,6 @@
+---
+'@modelcontextprotocol/client': patch
+'@modelcontextprotocol/server': patch
+---
+
+Treat Standard Schema validation results with an empty `issues` array as failures instead of accepting an undefined value.

packages/core-internal/src/util/standardSchema.ts

@@ -284,7 +284,7 @@ export async function validateStandardSchema<T extends StandardSchemaV1>(
     data: unknown
 ): Promise<StandardSchemaValidationResult<StandardSchemaV1.InferOutput<T>>> {
     const result = await schema['~standard'].validate(data);
-    if (result.issues && result.issues.length > 0) {
+    if (result.issues) {
         return { success: false, error: result.issues.map(i => formatIssue(i)).join(', ') };
     }
     return { success: true, data: (result as StandardSchemaV1.SuccessResult<unknown>).value as StandardSchemaV1.InferOutput<T> };

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

@@ -1,6 +1,30 @@
 import * as z from 'zod/v4';
 
-import { standardSchemaToJsonSchema } from '../../src/util/standardSchema';
+import { type StandardSchemaV1, standardSchemaToJsonSchema, validateStandardSchema } from '../../src/util/standardSchema';
+
+describe('validateStandardSchema', () => {
+    test.each(['synchronous', 'asynchronous'] as const)('rejects %s failures with an empty issues array', async mode => {
+        const schema: StandardSchemaV1 = {
+            '~standard': {
+                version: 1,
+                vendor: 'empty-issues',
+                validate: () => (mode === 'asynchronous' ? Promise.resolve({ issues: [] }) : { issues: [] })
+            }
+        };
+
+        await expect(validateStandardSchema(schema, { name: 'example' })).resolves.toEqual({ success: false, error: '' });
+    });
+
+    test('preserves transformed values when validation succeeds', async () => {
+        const schema = z.string().transform(value => value.toUpperCase());
+
+        await expect(validateStandardSchema(schema, 'hello')).resolves.toEqual({ success: true, data: 'HELLO' });
+    });
+
+    test('preserves undefined when validation succeeds', async () => {
+        await expect(validateStandardSchema(z.undefined(), undefined)).resolves.toEqual({ success: true, data: undefined });
+    });
+});
 
 describe('standardSchemaToJsonSchema', () => {
     test('emits type:object for plain z.object schemas', () => {