Merge branch 'main' into fix/from-json-schema-validator-optional

Author: felixweinberger

.changeset/fix-streamable-http-error-response.md

@@ -0,0 +1,5 @@
+---
+'@modelcontextprotocol/client': patch
+---
+
+Fix StreamableHTTPClientTransport to handle error responses in SSE streams

packages/client/src/client/streamableHttp.ts

@@ -4,6 +4,7 @@ import type { FetchLike, JSONRPCMessage, Transport } from '@modelcontextprotocol
 import {
     createFetchWithInit,
     isInitializedNotification,
+    isJSONRPCErrorResponse,
     isJSONRPCRequest,
     isJSONRPCResultResponse,
     JSONRPCMessageSchema,
@@ -412,7 +413,8 @@ export class StreamableHTTPClientTransport implements Transport {
                     if (!event.event || event.event === 'message') {
                         try {
                             const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
-                            if (isJSONRPCResultResponse(message)) {
+                            // Handle both success AND error responses for completion detection and ID remapping
+                            if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {
                                 // Mark that we received a response - no need to reconnect for this request
                                 receivedResponse = true;
                                 if (replayMessageId !== undefined) {

packages/client/test/client/streamableHttp.test.ts

@@ -1008,6 +1008,78 @@ describe('StreamableHTTPClientTransport', () => {
             expect(fetchMock.mock.calls[0]![1]?.method).toBe('POST');
         });
 
+        it('should NOT reconnect a POST stream when error response was received', async () => {
+            // ARRANGE
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
+                reconnectionOptions: {
+                    initialReconnectionDelay: 10,
+                    maxRetries: 1,
+                    maxReconnectionDelay: 1000,
+                    reconnectionDelayGrowFactor: 1
+                }
+            });
+
+            const messageSpy = vi.fn();
+            transport.onmessage = messageSpy;
+
+            // Create a stream that sends:
+            // 1. Priming event with ID (enables potential reconnection)
+            // 2. An error response (should also prevent reconnection, just like success)
+            // 3. Then closes
+            const streamWithErrorResponse = new ReadableStream({
+                start(controller) {
+                    // Priming event with ID
+                    controller.enqueue(new TextEncoder().encode('id: priming-123\ndata: \n\n'));
+                    // An error response to the request (tool not found, for example)
+                    controller.enqueue(
+                        new TextEncoder().encode(
+                            'id: error-456\ndata: {"jsonrpc":"2.0","error":{"code":-32602,"message":"Tool not found"},"id":"request-1"}\n\n'
+                        )
+                    );
+                    // Stream closes normally
+                    controller.close();
+                }
+            });
+
+            const fetchMock = global.fetch as Mock;
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                headers: new Headers({ 'content-type': 'text/event-stream' }),
+                body: streamWithErrorResponse
+            });
+
+            const requestMessage: JSONRPCRequest = {
+                jsonrpc: '2.0',
+                method: 'tools/call',
+                id: 'request-1',
+                params: { name: 'nonexistent-tool' }
+            };
+
+            // ACT
+            await transport.start();
+            await transport.send(requestMessage);
+            await vi.advanceTimersByTimeAsync(50);
+
+            // ASSERT
+            // THE KEY ASSERTION: Fetch was called ONCE only - no reconnection!
+            // The error response was received, so no need to reconnect.
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+            expect(fetchMock.mock.calls[0]![1]?.method).toBe('POST');
+
+            // Verify the error response was delivered to the message handler
+            expect(messageSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    jsonrpc: '2.0',
+                    error: expect.objectContaining({
+                        code: -32602,
+                        message: 'Tool not found'
+                    }),
+                    id: 'request-1'
+                })
+            );
+        });
+
         it('should not attempt reconnection after close() is called', async () => {
             // ARRANGE
             transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {

packages/server/src/server/mcp.ts

@@ -530,7 +530,8 @@ export class McpServer {
                             name,
                             title: prompt.title,
                             description: prompt.description,
-                            arguments: prompt.argsSchema ? promptArgumentsFromStandardSchema(prompt.argsSchema) : undefined
+                            arguments: prompt.argsSchema ? promptArgumentsFromStandardSchema(prompt.argsSchema) : undefined,
+                            _meta: prompt._meta
                         };
                     })
             })
@@ -699,7 +700,8 @@ export class McpServer {
         title: string | undefined,
         description: string | undefined,
         argsSchema: StandardSchemaWithJSON | undefined,
-        callback: PromptCallback<StandardSchemaWithJSON | undefined>
+        callback: PromptCallback<StandardSchemaWithJSON | undefined>,
+        _meta: Record<string, unknown> | undefined
     ): RegisteredPrompt {
         // Track current schema and callback for handler regeneration
         let currentArgsSchema = argsSchema;
@@ -709,6 +711,7 @@ export class McpServer {
             title,
             description,
             argsSchema,
+            _meta,
             handler: createPromptHandler(name, argsSchema, callback),
             enabled: true,
             disable: () => registeredPrompt.update({ enabled: false }),
@@ -721,6 +724,7 @@ export class McpServer {
                 }
                 if (updates.title !== undefined) registeredPrompt.title = updates.title;
                 if (updates.description !== undefined) registeredPrompt.description = updates.description;
+                if (updates._meta !== undefined) registeredPrompt._meta = updates._meta;
 
                 // Track if we need to regenerate the handler
                 let needsHandlerRegen = false;
@@ -921,21 +925,23 @@ export class McpServer {
             title?: string;
             description?: string;
             argsSchema?: Args;
+            _meta?: Record<string, unknown>;
         },
         cb: PromptCallback<Args>
     ): RegisteredPrompt {
         if (this._registeredPrompts[name]) {
             throw new Error(`Prompt ${name} is already registered`);
         }
 
-        const { title, description, argsSchema } = config;
+        const { title, description, argsSchema, _meta } = config;
 
         const registeredPrompt = this._createRegisteredPrompt(
             name,
             title,
             description,
             argsSchema,
-            cb as PromptCallback<StandardSchemaWithJSON | undefined>
+            cb as PromptCallback<StandardSchemaWithJSON | undefined>,
+            _meta
         );
 
         this.setPromptRequestHandlers();
@@ -1234,6 +1240,7 @@ export type RegisteredPrompt = {
     title?: string;
     description?: string;
     argsSchema?: StandardSchemaWithJSON;
+    _meta?: Record<string, unknown>;
     /** @hidden */
     handler: PromptHandler;
     enabled: boolean;
@@ -1244,6 +1251,7 @@ export type RegisteredPrompt = {
         title?: string;
         description?: string;
         argsSchema?: Args;
+        _meta?: Record<string, unknown>;
         callback?: PromptCallback<Args>;
         enabled?: boolean;
     }): void;

test/integration/test/server/mcp.test.ts

@@ -4253,6 +4253,99 @@ describe('Zod v4', () => {
                 }
             ]);
         });
+
+        /***
+         * Test: Prompt Registration with _meta field
+         */
+        test('should register prompt with _meta field and include it in list response', async () => {
+            const mcpServer = new McpServer({
+                name: 'test server',
+                version: '1.0'
+            });
+            const client = new Client({
+                name: 'test client',
+                version: '1.0'
+            });
+
+            const metaData = {
+                author: 'test-author',
+                version: '1.2.3',
+                category: 'utility',
+                tags: ['test', 'example']
+            };
+
+            mcpServer.registerPrompt(
+                'test-with-meta',
+                {
+                    description: 'A prompt with _meta field',
+                    _meta: metaData
+                },
+                async () => ({
+                    messages: [
+                        {
+                            role: 'assistant',
+                            content: {
+                                type: 'text',
+                                text: 'Test response'
+                            }
+                        }
+                    ]
+                })
+            );
+
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+            await Promise.all([client.connect(clientTransport), mcpServer.server.connect(serverTransport)]);
+
+            const result = await client.request({ method: 'prompts/list' });
+
+            expect(result.prompts).toHaveLength(1);
+            expect(result.prompts[0]!.name).toBe('test-with-meta');
+            expect(result.prompts[0]!.description).toBe('A prompt with _meta field');
+            expect(result.prompts[0]!._meta).toEqual(metaData);
+        });
+
+        /***
+         * Test: Prompt Registration without _meta field should have undefined _meta
+         */
+        test('should register prompt without _meta field and have undefined _meta in response', async () => {
+            const mcpServer = new McpServer({
+                name: 'test server',
+                version: '1.0'
+            });
+            const client = new Client({
+                name: 'test client',
+                version: '1.0'
+            });
+
+            mcpServer.registerPrompt(
+                'test-without-meta',
+                {
+                    description: 'A prompt without _meta field'
+                },
+                async () => ({
+                    messages: [
+                        {
+                            role: 'assistant',
+                            content: {
+                                type: 'text',
+                                text: 'Test response'
+                            }
+                        }
+                    ]
+                })
+            );
+
+            const [clientTransport, serverTransport] = InMemoryTransport.createLinkedPair();
+
+            await Promise.all([client.connect(clientTransport), mcpServer.server.connect(serverTransport)]);
+
+            const result = await client.request({ method: 'prompts/list' });
+
+            expect(result.prompts).toHaveLength(1);
+            expect(result.prompts[0]!.name).toBe('test-without-meta');
+            expect(result.prompts[0]!._meta).toBeUndefined();
+        });
     });
 
     describe('Tool title precedence', () => {