Merge branch 'main' into feature/v2-sdk-error-add-tests

KKonstantinov · web-flow · commit 330d4f880545 · 2026-06-10T20:15:00.000+03:00
diff --git a/.changeset/stdio-max-buffer-size.md b/.changeset/stdio-max-buffer-size.md
@@ -0,0 +1,7 @@
+---
+'@modelcontextprotocol/core': patch
+'@modelcontextprotocol/client': patch
+'@modelcontextprotocol/server': patch
+---
+
+Add a configurable `maxBufferSize` (default 10 MB) to the stdio transports. When a single message would push the read buffer past the limit, the transport now emits an `onerror` and closes instead of growing the buffer unbounded. Configure via `new StdioClientTransport({ ..., maxBufferSize })` or `new StdioServerTransport(stdin, stdout, { maxBufferSize })`. The default is exported from `@modelcontextprotocol/core` as `STDIO_DEFAULT_MAX_BUFFER_SIZE`.
diff --git a/packages/client/src/client/stdio.ts b/packages/client/src/client/stdio.ts
@@ -38,6 +38,14 @@ export type StdioServerParameters = {
      * If not specified, the current working directory will be inherited.
      */
     cwd?: string;
+
+    /**
+     * Maximum size of the read buffer in bytes. If a single message exceeds
+     * this size the transport will emit an error and close.
+     *
+     * Defaults to 10 MB.
+     */
+    maxBufferSize?: number;
 };
 
 /**
@@ -92,7 +100,7 @@ export function getDefaultEnvironment(): Record<string, string> {
  */
 export class StdioClientTransport implements Transport {
     private _process?: ChildProcess;
-    private _readBuffer: ReadBuffer = new ReadBuffer();
+    private _readBuffer: ReadBuffer;
     private _serverParams: StdioServerParameters;
     private _stderrStream: PassThrough | null = null;
 
@@ -102,6 +110,7 @@ export class StdioClientTransport implements Transport {
 
     constructor(server: StdioServerParameters) {
         this._serverParams = server;
+        this._readBuffer = new ReadBuffer({ maxBufferSize: server.maxBufferSize });
         if (server.stderr === 'pipe' || server.stderr === 'overlapped') {
             this._stderrStream = new PassThrough();
         }
@@ -149,8 +158,13 @@ export class StdioClientTransport implements Transport {
             });
 
             this._process.stdout?.on('data', chunk => {
-                this._readBuffer.append(chunk);
-                this.processReadBuffer();
+                try {
+                    this._readBuffer.append(chunk);
+                    this.processReadBuffer();
+                } catch (error) {
+                    this.onerror?.(error as Error);
+                    this.close().catch(() => {});
+                }
             });
 
             this._process.stdout?.on('error', error => {
diff --git a/packages/client/test/client/stdio.test.ts b/packages/client/test/client/stdio.test.ts
@@ -77,3 +77,44 @@ test('should return child process pid', async () => {
     await client.close();
     expect(client.pid).toBeNull();
 });
+
+test('should respect custom maxBufferSize option', async () => {
+    const client = new StdioClientTransport({
+        command: 'node',
+        args: ['-e', 'process.stdout.write(Buffer.alloc(200, 0x41))'],
+        maxBufferSize: 100
+    });
+
+    const errorReceived = new Promise<Error>(resolve => {
+        client.onerror = resolve;
+    });
+    const closed = new Promise<void>(resolve => {
+        client.onclose = () => resolve();
+    });
+
+    await client.start();
+
+    const error = await errorReceived;
+    expect(error.message).toMatch(/ReadBuffer exceeded maximum size/);
+    await closed;
+});
+
+test('should fire onerror and close when ReadBuffer overflows', async () => {
+    const client = new StdioClientTransport({
+        command: 'node',
+        args: ['-e', 'process.stdout.write(Buffer.alloc(11 * 1024 * 1024, 0x41))']
+    });
+
+    const errorReceived = new Promise<Error>(resolve => {
+        client.onerror = resolve;
+    });
+    const closed = new Promise<void>(resolve => {
+        client.onclose = () => resolve();
+    });
+
+    await client.start();
+
+    const error = await errorReceived;
+    expect(error.message).toMatch(/ReadBuffer exceeded maximum size/);
+    await closed;
+});
diff --git a/packages/codemod/src/bin/batchTest.ts b/packages/codemod/src/bin/batchTest.ts
@@ -87,6 +87,7 @@ const LOCAL_PACKAGE_DIRS: Record<string, string> = {
     '@modelcontextprotocol/client': path.join(SDK_ROOT, 'packages/client'),
     '@modelcontextprotocol/core': path.join(SDK_ROOT, 'packages/core'),
     '@modelcontextprotocol/server': path.join(SDK_ROOT, 'packages/server'),
+    '@modelcontextprotocol/server-legacy': path.join(SDK_ROOT, 'packages/server-legacy'),
     '@modelcontextprotocol/express': path.join(SDK_ROOT, 'packages/middleware/express'),
     '@modelcontextprotocol/fastify': path.join(SDK_ROOT, 'packages/middleware/fastify'),
     '@modelcontextprotocol/hono': path.join(SDK_ROOT, 'packages/middleware/hono'),
diff --git a/packages/codemod/src/migrations/v1-to-v2/mappings/importMap.ts b/packages/codemod/src/migrations/v1-to-v2/mappings/importMap.ts
@@ -62,7 +62,11 @@ export const IMPORT_MAP: Record<string, ImportMapping> = {
             StreamableHTTPServerTransport: 'NodeStreamableHTTPServerTransport'
         },
         symbolTargetOverrides: {
-            StreamableHTTPServerTransport: '@modelcontextprotocol/node'
+            StreamableHTTPServerTransport: '@modelcontextprotocol/node',
+            // The companion options type moved with the transport. @modelcontextprotocol/node
+            // re-exports it under the same name (a backward-compat alias for
+            // WebStandardStreamableHTTPServerTransportOptions), so route it there without renaming.
+            StreamableHTTPServerTransportOptions: '@modelcontextprotocol/node'
         }
     },
     '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js': {
diff --git a/packages/codemod/src/migrations/v1-to-v2/transforms/specSchemaAccess.ts b/packages/codemod/src/migrations/v1-to-v2/transforms/specSchemaAccess.ts
@@ -101,28 +101,15 @@ function handleReference(
             return rewriteCapturedSafeParse(safeParseCall, localName, typeName, sourceFile, diagnostics);
         }
 
-        diagnostics.push(
-            actionRequired(
-                sourceFile.getFilePath(),
-                ref,
-                `${localName}.safeParse() not available in v2. Use \`isSpecType.${typeName}(value)\` for boolean validation, ` +
-                    `or \`specTypeSchemas.${typeName}['~standard'].validate(value)\` for full result.`
-            )
-        );
-        return false;
+        return rewriteUnsupportedSchemaCall(ref, safeParseCall, localName, typeName, 'safeParse', sourceFile, diagnostics);
     }
 
-    // Pattern: XSchema.parse(v) — diagnostic only
+    // Pattern: XSchema.parse(v) — rewrite to the StandardSchema validate() primitive (or, when the
+    // result is used, swap the identifier) so we never leave behind an import of a non-exported schema.
     if (isParsePattern(ref)) {
-        diagnostics.push(
-            actionRequired(
-                sourceFile.getFilePath(),
-                ref,
-                `${localName}.parse() not available in v2. Use \`isSpecType.${typeName}(value)\` for validation, ` +
-                    `or \`specTypeSchemas.${typeName}['~standard'].validate(value)\` and check for issues.`
-            )
-        );
-        return false;
+        const parseAccess = ref.getParent() as import('ts-morph').PropertyAccessExpression;
+        const parseCall = parseAccess.getParent() as import('ts-morph').CallExpression;
+        return rewriteUnsupportedSchemaCall(ref, parseCall, localName, typeName, 'parse', sourceFile, diagnostics);
     }
 
     // Pattern: XSchema used as value (function arg, assignment, etc.)
@@ -327,6 +314,68 @@ function rewriteCapturedSafeParse(
     return true;
 }
 
+/**
+ * Handles spec-schema usages that have no behavior-preserving v2 equivalent: the Zod-only
+ * methods `.parse()` and (uncaptured) `.safeParse()`. In v2 these schemas are StandardSchemaV1
+ * values that are NOT named public exports, so leaving the original import in place produces an
+ * unresolved-import error (e.g. `PromptSchema` is not exported by `@modelcontextprotocol/server`).
+ *
+ * - Result discarded (validation for side-effect only): rewrite `XSchema.parse(v)` →
+ *   `specTypeSchemas.T['~standard'].validate(v)` so the code compiles. NOTE: `validate()` does not
+ *   throw, so `.parse()`'s throw-on-invalid behavior is lost — flagged via an actionRequired comment.
+ * - Result used: swap only the identifier to `specTypeSchemas.T` so the import resolves; the
+ *   `.parse()`/`.safeParse()` call and its result shape still need a manual fix (flagged).
+ *
+ * Either way the original (now non-exported) schema import is dropped by the caller's
+ * removeUnusedImport, so no dangling import survives.
+ */
+function rewriteUnsupportedSchemaCall(
+    ref: import('ts-morph').Node,
+    callNode: import('ts-morph').CallExpression,
+    localName: string,
+    typeName: string,
+    method: 'parse' | 'safeParse',
+    sourceFile: SourceFile,
+    diagnostics: Diagnostic[]
+): boolean {
+    const resultDiscarded = Node.isExpressionStatement(callNode.getParent());
+
+    if (resultDiscarded) {
+        const argText = callNode
+            .getArguments()
+            .map(a => a.getText())
+            .join(', ');
+        const semantics =
+            method === 'parse'
+                ? 'validate() does NOT throw on invalid input (parse() did) — if you relied on that, add `if (result.issues) throw …`.'
+                : 'the result shape changed from { success, data, error } to { value, issues }.';
+        diagnostics.push(
+            actionRequired(
+                sourceFile.getFilePath(),
+                callNode,
+                `Rewrote ${localName}.${method}() to specTypeSchemas.${typeName}['~standard'].validate(): ` +
+                    `v2 spec schemas are StandardSchemaV1, not Zod. Note: ${semantics}`
+            )
+        );
+        callNode.replaceWithText(`specTypeSchemas.${typeName}['~standard'].validate(${argText})`);
+        ensureImport(sourceFile, 'specTypeSchemas');
+        return true;
+    }
+
+    diagnostics.push(
+        actionRequired(
+            sourceFile.getFilePath(),
+            ref,
+            `${localName}.${method}() is not available on v2 spec schemas (StandardSchemaV1, not Zod). ` +
+                `Replaced ${localName} with specTypeSchemas.${typeName}; rewrite the .${method}(...) call using ` +
+                `specTypeSchemas.${typeName}['~standard'].validate(...) (returns { value, issues }, does not throw).`
+        )
+    );
+    ref.replaceWithText(`specTypeSchemas.${typeName}`);
+    ensureImport(sourceFile, 'specTypeSchemas');
+    return true;
+}
+
 function ensureImport(sourceFile: SourceFile, symbol: string): void {
     const existingImport = sourceFile.getImportDeclarations().find(imp => {
         if (!isAnyMcpSpecifier(imp.getModuleSpecifierValue())) return false;
diff --git a/packages/codemod/test/v1-to-v2/transforms/specSchemaAccess.test.ts b/packages/codemod/test/v1-to-v2/transforms/specSchemaAccess.test.ts
@@ -210,10 +210,12 @@ describe('spec-schema-access transform', () => {
             expect(text).not.toContain('return result.value');
         });
 
-        it('falls back to diagnostic for non-captured safeParse (bare expression)', () => {
+        it('rewrites non-captured safeParse (bare expression) to validate()', () => {
             const input = [`import { ToolSchema } from '@modelcontextprotocol/server';`, `ToolSchema.safeParse(data);`, ''].join('\n');
-            const { result } = applyTransform(input);
-            expect(result.changesCount).toBe(0);
+            const { text, result } = applyTransform(input);
+            expect(text).toContain("specTypeSchemas.Tool['~standard'].validate(data)");
+            expect(text).not.toMatch(/import\s*\{[^}]*ToolSchema[^}]*\}/);
+            expect(result.changesCount).toBeGreaterThan(0);
             expect(result.diagnostics.length).toBe(1);
         });
     });
@@ -327,16 +329,24 @@ describe('spec-schema-access transform', () => {
         });
     });
 
-    describe('diagnostic only: .parse(v)', () => {
-        it('emits diagnostic for parse usage', () => {
+    describe('.parse(v)', () => {
+        it('rewrites discarded parse() to the validate() primitive', () => {
+            const input = [`import { ToolSchema } from '@modelcontextprotocol/server';`, `ToolSchema.parse(raw);`, ''].join('\n');
+            const { text, result } = applyTransform(input);
+            expect(text).toContain("specTypeSchemas.Tool['~standard'].validate(raw)");
+            expect(text).not.toMatch(/import\s*\{[^}]*ToolSchema[^}]*\}/);
+            expect(result.changesCount).toBeGreaterThan(0);
+        });
+
+        it('swaps the identifier (import stays resolvable) when the parse() result is used', () => {
             const input = [`import { ToolSchema } from '@modelcontextprotocol/server';`, `const tool = ToolSchema.parse(raw);`, ''].join(
                 '\n'
             );
             const { text, result } = applyTransform(input);
-            expect(text).toContain('ToolSchema.parse');
-            expect(result.changesCount).toBe(0);
-            expect(result.diagnostics.length).toBe(1);
-            expect(result.diagnostics[0]!.message).toContain('isSpecType.Tool');
+            expect(text).toContain('specTypeSchemas.Tool.parse(raw)');
+            expect(text).not.toMatch(/import\s*\{[^}]*ToolSchema[^}]*\}/);
+            expect(result.changesCount).toBeGreaterThan(0);
+            expect(result.diagnostics[0]!.message).toContain('specTypeSchemas.Tool');
         });
     });
 
@@ -392,7 +402,7 @@ describe('spec-schema-access transform', () => {
             expect(text).not.toMatch(/import\s*\{[^}]*CallToolRequestSchema[^}]*\}/);
         });
 
-        it('keeps original schema import when some refs are diagnostic-only', () => {
+        it('removes the schema import even when a ref falls back to a parse()/safeParse() rewrite', () => {
             const input = [
                 `import { CallToolRequestSchema } from '@modelcontextprotocol/server';`,
                 `const valid = CallToolRequestSchema.safeParse(data).success;`,
@@ -401,8 +411,8 @@ describe('spec-schema-access transform', () => {
             ].join('\n');
             const { text } = applyTransform(input);
             expect(text).toContain('isSpecType.CallToolRequest(data)');
-            expect(text).toContain('CallToolRequestSchema.parse');
-            expect(text).toMatch(/import\s*\{[^}]*CallToolRequestSchema[^}]*\}/);
+            expect(text).toContain('specTypeSchemas.CallToolRequest.parse(data)');
+            expect(text).not.toMatch(/import\s*\{[^}]*CallToolRequestSchema[^}]*\}/);
         });
 
         it('removes schema specifier from import that also has other symbols', () => {
diff --git a/packages/core/src/exports/public/index.ts b/packages/core/src/exports/public/index.ts
@@ -53,7 +53,7 @@ export type {
 export { DEFAULT_REQUEST_TIMEOUT_MSEC } from '../../shared/protocol.js';
 
 // stdio message framing utilities (for custom transport authors)
-export { deserializeMessage, ReadBuffer, serializeMessage } from '../../shared/stdio.js';
+export { deserializeMessage, ReadBuffer, serializeMessage, STDIO_DEFAULT_MAX_BUFFER_SIZE } from '../../shared/stdio.js';
 
 // Transport types (NOT normalizeHeaders)
 export type { FetchLike, Transport, TransportSendOptions } from '../../shared/transport.js';
diff --git a/packages/core/src/shared/stdio.ts b/packages/core/src/shared/stdio.ts
@@ -1,13 +1,25 @@
 import type { JSONRPCMessage } from '../types/index.js';
 import { JSONRPCMessageSchema } from '../types/index.js';
 
+export const STDIO_DEFAULT_MAX_BUFFER_SIZE = 10 * 1024 * 1024;
+
 /**
  * Buffers a continuous stdio stream into discrete JSON-RPC messages.
  */
 export class ReadBuffer {
     private _buffer?: Buffer;
+    private _maxBufferSize: number;
+
+    constructor(options?: { maxBufferSize?: number }) {
+        this._maxBufferSize = options?.maxBufferSize ?? STDIO_DEFAULT_MAX_BUFFER_SIZE;
+    }
 
     append(chunk: Buffer): void {
+        const newSize = (this._buffer?.length ?? 0) + chunk.length;
+        if (newSize > this._maxBufferSize) {
+            this.clear();
+            throw new Error(`ReadBuffer exceeded maximum size of ${this._maxBufferSize} bytes`);
+        }
         this._buffer = this._buffer ? Buffer.concat([this._buffer, chunk]) : chunk;
     }
 
diff --git a/packages/core/test/shared/stdio.test.ts b/packages/core/test/shared/stdio.test.ts
@@ -1,4 +1,4 @@
-import { ReadBuffer } from '../../src/shared/stdio.js';
+import { ReadBuffer, STDIO_DEFAULT_MAX_BUFFER_SIZE } from '../../src/shared/stdio.js';
 import type { JSONRPCMessage } from '../../src/types/index.js';
 
 const testMessage: JSONRPCMessage = {
@@ -113,3 +113,46 @@ describe('non-JSON line filtering', () => {
         expect(() => readBuffer.readMessage()).toThrow();
     });
 });
+
+describe('buffer size limit', () => {
+    test('should throw when buffer exceeds default max size', () => {
+        const readBuffer = new ReadBuffer();
+        const chunkSize = 1024 * 1024; // 1 MB
+        const chunk = Buffer.alloc(chunkSize);
+        const chunksToFill = Math.floor(STDIO_DEFAULT_MAX_BUFFER_SIZE / chunkSize);
+        for (let i = 0; i < chunksToFill; i++) {
+            readBuffer.append(chunk);
+        }
+        expect(() => readBuffer.append(chunk)).toThrow(/ReadBuffer exceeded maximum size/);
+    });
+
+    test('should throw when buffer exceeds custom max size', () => {
+        const readBuffer = new ReadBuffer({ maxBufferSize: 100 });
+        readBuffer.append(Buffer.alloc(50));
+        expect(() => readBuffer.append(Buffer.alloc(51))).toThrow(/ReadBuffer exceeded maximum size/);
+    });
+
+    test('should clear buffer before throwing on overflow', () => {
+        const readBuffer = new ReadBuffer({ maxBufferSize: 100 });
+        readBuffer.append(Buffer.alloc(50));
+        expect(() => readBuffer.append(Buffer.alloc(51))).toThrow();
+
+        // Buffer should be cleared — can append again
+        readBuffer.append(Buffer.alloc(50));
+        // And read messages normally
+        expect(readBuffer.readMessage()).toBeNull();
+    });
+
+    test('should allow appending up to exactly the max size', () => {
+        const readBuffer = new ReadBuffer({ maxBufferSize: 100 });
+        // Should not throw — exactly at limit
+        expect(() => readBuffer.append(Buffer.alloc(100))).not.toThrow();
+    });
+
+    test('should work with no options (backwards compatible)', () => {
+        const readBuffer = new ReadBuffer();
+        // Small append should always work
+        readBuffer.append(Buffer.from(JSON.stringify({ jsonrpc: '2.0', method: 'ping' }) + '\n'));
+        expect(readBuffer.readMessage()).not.toBeNull();
+    });
+});
diff --git a/packages/server/src/server/stdio.ts b/packages/server/src/server/stdio.ts
diff --git a/packages/server/test/server/stdio.test.ts b/packages/server/test/server/stdio.test.ts
