fix(client): reset retry/upscoping state on close() and prevent stale reconnects after restart

- close() now resets _serverRetryMs and _lastUpscopingHeader so a restarted
  transport does not inherit the previous session's server-provided retry
  delay or upscoping-loop guard state.
- _scheduleReconnection and _handleSseStream capture the abort signal at
  schedule time instead of re-reading this._abortController. After
  close() + start() the field points at the new session's controller, so
  the previous read allowed a stale reconnect to fire into the restarted
  transport.
- Added tests for both cases.

Author: felixweinberger

packages/client/src/client/streamableHttp.ts

@@ -341,10 +341,16 @@ export class StreamableHTTPClientTransport implements Transport {
         // Calculate next delay based on current attempt count
         const delay = this._getNextReconnectionDelay(attemptCount);
 
+        // Capture the signal active when this reconnection was scheduled. close() + start()
+        // replaces this._abortController, so re-reading it later would see the new session's
+        // controller and allow a stale reconnect to fire into the restarted transport.
+        const signal = this._abortController?.signal;
+
         const reconnect = (): void => {
             this._cancelReconnection = undefined;
-            if (this._abortController?.signal.aborted) return;
+            if (signal?.aborted) return;
             this._startOrAuthSse(options).catch(error => {
+                if (signal?.aborted) return;
                 this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
                 try {
                     this._scheduleReconnection(options, attemptCount + 1);
@@ -369,6 +375,9 @@ export class StreamableHTTPClientTransport implements Transport {
         }
         const { onresumptiontoken, replayMessageId } = options;
 
+        // Capture the signal this stream is bound to so we don't reconnect into a restarted transport.
+        const signal = this._abortController?.signal;
+
         let lastEventId: string | undefined;
         // Track whether we've received a priming event (event with ID)
         // Per spec, server SHOULD send a priming event with ID before closing
@@ -436,7 +445,7 @@ export class StreamableHTTPClientTransport implements Transport {
                 // BUT don't reconnect if we already received a response - the request is complete
                 const canResume = isReconnectable || hasPrimingEvent;
                 const needsReconnect = canResume && !receivedResponse;
-                if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+                if (needsReconnect && signal && !signal.aborted) {
                     this._scheduleReconnection(
                         {
                             resumptionToken: lastEventId,
@@ -455,7 +464,7 @@ export class StreamableHTTPClientTransport implements Transport {
                 // BUT don't reconnect if we already received a response - the request is complete
                 const canResume = isReconnectable || hasPrimingEvent;
                 const needsReconnect = canResume && !receivedResponse;
-                if (needsReconnect && this._abortController && !this._abortController.signal.aborted) {
+                if (needsReconnect && signal && !signal.aborted) {
                     // Use the exponential backoff reconnection strategy
                     try {
                         this._scheduleReconnection(
@@ -512,6 +521,8 @@ export class StreamableHTTPClientTransport implements Transport {
             this._cancelReconnection = undefined;
             this._abortController?.abort();
             this._sessionId = undefined;
+            this._lastUpscopingHeader = undefined;
+            this._serverRetryMs = undefined;
             this.onclose?.();
         }
     }

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

@@ -1998,6 +1998,31 @@ describe('StreamableHTTPClientTransport', () => {
             expect(onerror).not.toHaveBeenCalled();
         });
 
+        it('ignores a late-firing reconnect after close() + start()', async () => {
+            let capturedReconnect: (() => void) | undefined;
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
+                reconnectionOptions,
+                reconnectionScheduler: reconnect => {
+                    capturedReconnect = reconnect;
+                }
+            });
+            const onerror = vi.fn();
+            transport.onerror = onerror;
+            const fetchMock = globalThis.fetch as Mock;
+
+            await transport.start();
+            triggerReconnection(transport);
+            await transport.close();
+            await transport.start();
+
+            fetchMock.mockClear();
+            capturedReconnect?.();
+            await vi.runAllTimersAsync();
+
+            expect(fetchMock).not.toHaveBeenCalled();
+            expect(onerror).not.toHaveBeenCalled();
+        });
+
         it('still aborts and fires onclose if the cancel function throws', async () => {
             transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
                 reconnectionOptions,
@@ -2059,5 +2084,19 @@ describe('StreamableHTTPClientTransport', () => {
             const postRestartHeaders = fetchMock.mock.calls[1]![1]?.headers as Headers;
             expect(postRestartHeaders.get('mcp-session-id')).toBeNull();
         });
+
+        it('should reset server-provided retry delay and upscoping header on close()', async () => {
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'));
+            await transport.start();
+
+            const internal = transport as unknown as { _serverRetryMs?: number; _lastUpscopingHeader?: string };
+            internal._serverRetryMs = 3000;
+            internal._lastUpscopingHeader = 'Bearer realm="x"';
+
+            await transport.close();
+
+            expect(internal._serverRetryMs).toBeUndefined();
+            expect(internal._lastUpscopingHeader).toBeUndefined();
+        });
     });
 });