fix: don't reconnect POST stream when response was already received

Per SEP-1699, the client should only reconnect when the server
disconnects BEFORE sending a response (for long-running operations).
The previous implementation would reconnect after ANY stream completion
when a priming event was received, even when the response was already
delivered.

This fix tracks whether a response was received and skips reconnection
if so. This prevents:
1. Unnecessary network round-trips
2. Race conditions with rapid stream cycling (which caused crashes in
   consumers like the inspector)

Adds test case to verify the correct behavior.

Author: felixweinberger

src/client/streamableHttp.test.ts

@@ -866,6 +866,61 @@ describe('StreamableHTTPClientTransport', () => {
             expect(reconnectHeaders.get('last-event-id')).toBe('event-123');
         });
 
+        it('should NOT reconnect a POST stream when response was received', async () => {
+            // ARRANGE
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
+                reconnectionOptions: {
+                    initialReconnectionDelay: 10,
+                    maxRetries: 1,
+                    maxReconnectionDelay: 1000,
+                    reconnectionDelayGrowFactor: 1
+                }
+            });
+
+            // Create a stream that sends:
+            // 1. Priming event with ID (enables potential reconnection)
+            // 2. The actual response (should prevent reconnection)
+            // 3. Then closes
+            const streamWithResponse = new ReadableStream({
+                start(controller) {
+                    // Priming event with ID
+                    controller.enqueue(new TextEncoder().encode('id: priming-123\ndata: \n\n'));
+                    // The actual response to the request
+                    controller.enqueue(
+                        new TextEncoder().encode('id: response-456\ndata: {"jsonrpc":"2.0","result":{"tools":[]},"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: streamWithResponse
+            });
+
+            const requestMessage: JSONRPCRequest = {
+                jsonrpc: '2.0',
+                method: 'tools/list',
+                id: 'request-1',
+                params: {}
+            };
+
+            // ACT
+            await transport.start();
+            await transport.send(requestMessage);
+            await vi.advanceTimersByTimeAsync(50);
+
+            // ASSERT
+            // THE KEY ASSERTION: Fetch was called ONCE only - no reconnection!
+            // The response was received, so no need to reconnect.
+            expect(fetchMock).toHaveBeenCalledTimes(1);
+            expect(fetchMock.mock.calls[0][1]?.method).toBe('POST');
+        });
+
         it('should not throw JSON parse error on priming events with empty data', async () => {
             transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'));
 

src/client/streamableHttp.ts

@@ -307,6 +307,9 @@ export class StreamableHTTPClientTransport implements Transport {
         // Track whether we've received a priming event (event with ID)
         // Per spec, server SHOULD send a priming event with ID before closing
         let hasPrimingEvent = false;
+        // Track whether we've received a response - if so, no need to reconnect
+        // Per SEP-1699, reconnection is for when server disconnects BEFORE sending response
+        let receivedResponse = false;
         const processStream = async () => {
             // this is the closest we can get to trying to catch network errors
             // if something happens reader will throw
@@ -346,8 +349,12 @@ export class StreamableHTTPClientTransport implements Transport {
                     if (!event.event || event.event === 'message') {
                         try {
                             const message = JSONRPCMessageSchema.parse(JSON.parse(event.data));
-                            if (replayMessageId !== undefined && isJSONRPCResponse(message)) {
-                                message.id = replayMessageId;
+                            if (isJSONRPCResponse(message)) {
+                                // Mark that we received a response - no need to reconnect for this request
+                                receivedResponse = true;
+                                if (replayMessageId !== undefined) {
+                                    message.id = replayMessageId;
+                                }
                             }
                             this.onmessage?.(message);
                         } catch (error) {
@@ -359,8 +366,10 @@ export class StreamableHTTPClientTransport implements Transport {
                 // Handle graceful server-side disconnect
                 // Server may close connection after sending event ID and retry field
                 // Reconnect if: already reconnectable (GET stream) OR received a priming event (POST stream with event ID)
+                // BUT don't reconnect if we already received a response - the request is complete
                 const canResume = isReconnectable || hasPrimingEvent;
-                if (canResume && this._abortController && !this._abortController.signal.aborted) {
+                const needsReconnect = canResume && !receivedResponse;
+                if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
                     this._scheduleReconnection(
                         {
                             resumptionToken: lastEventId,
@@ -376,8 +385,10 @@ export class StreamableHTTPClientTransport implements Transport {
 
                 // Attempt to reconnect if the stream disconnects unexpectedly and we aren't closing
                 // Reconnect if: already reconnectable (GET stream) OR received a priming event (POST stream with event ID)
+                // BUT don't reconnect if we already received a response - the request is complete
                 const canResume = isReconnectable || hasPrimingEvent;
-                if (canResume && this._abortController && !this._abortController.signal.aborted) {
+                const needsReconnect = canResume && !receivedResponse;
+                if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
                     // Use the exponential backoff reconnection strategy
                     try {
                         this._scheduleReconnection(