fix(client): preserve triggering error when reconnection bails at maxRetries

- Thread lastError through _scheduleReconnection so the original disconnect
  error is surfaced (as message suffix and Error.cause) when maxRetries is
  exceeded. With maxRetries=0 the previous behavior dropped the diagnostic
  entirely.
- Align SSE-disconnected onerror message with adjacent pattern to avoid the
  doubled 'Error:' prefix from string-coercing an Error instance.
- Add test covering the maxRetries=0 + lastError surfacing path.

Author: felixweinberger

packages/client/src/client/streamableHttp.ts

@@ -327,14 +327,21 @@ export class StreamableHTTPClientTransport implements Transport {
      *
      * @param lastEventId The ID of the last received event for resumability
      * @param attemptCount Current reconnection attempt count for this specific stream
+     * @param lastError The error that triggered this reconnection attempt, surfaced if max retries is exceeded
      */
-    private _scheduleReconnection(options: StartSSEOptions, attemptCount = 0): void {
+    private _scheduleReconnection(options: StartSSEOptions, attemptCount = 0, lastError?: unknown): void {
         // Use provided options or default options
         const maxRetries = this._reconnectionOptions.maxRetries;
 
         // Check if we've exceeded maximum retry attempts
         if (attemptCount >= maxRetries) {
-            this.onerror?.(new Error(`Maximum reconnection attempts (${maxRetries}) exceeded.`));
+            const reason = lastError === undefined ? undefined : lastError instanceof Error ? lastError.message : String(lastError);
+            this.onerror?.(
+                new Error(
+                    `Maximum reconnection attempts (${maxRetries}) exceeded` + (reason ? `: ${reason}` : '.'),
+                    lastError === undefined ? undefined : { cause: lastError }
+                )
+            );
             return;
         }
 
@@ -347,7 +354,7 @@ export class StreamableHTTPClientTransport implements Transport {
             this._startOrAuthSse(options).catch(error => {
                 this.onerror?.(new Error(`Failed to reconnect SSE stream: ${error instanceof Error ? error.message : String(error)}`));
                 try {
-                    this._scheduleReconnection(options, attemptCount + 1);
+                    this._scheduleReconnection(options, attemptCount + 1, error);
                 } catch (scheduleError) {
                     this.onerror?.(scheduleError instanceof Error ? scheduleError : new Error(String(scheduleError)));
                 }
@@ -461,14 +468,15 @@ export class StreamableHTTPClientTransport implements Transport {
                                 onresumptiontoken,
                                 replayMessageId
                             },
-                            0
+                            0,
+                            error
                         );
                     } catch (error) {
                         this.onerror?.(new Error(`Failed to reconnect: ${error instanceof Error ? error.message : String(error)}`));
                     }
                 } else {
                     // Stream disconnected and reconnection will not happen; surface the error
-                    this.onerror?.(new Error(`SSE stream disconnected: ${error}`));
+                    this.onerror?.(new Error(`SSE stream disconnected: ${error instanceof Error ? error.message : String(error)}`));
                 }
             }
         };

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

@@ -1783,6 +1783,32 @@ describe('StreamableHTTPClientTransport', () => {
             expect(transport['_cancelReconnection']).toBeUndefined();
         });
 
+        it('should surface the triggering error when maxRetries is 0', async () => {
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
+                reconnectionOptions: {
+                    initialReconnectionDelay: 10,
+                    maxRetries: 0,
+                    maxReconnectionDelay: 1000,
+                    reconnectionDelayGrowFactor: 1
+                }
+            });
+
+            const errorSpy = vi.fn();
+            transport.onerror = errorSpy;
+
+            const triggeringError = new Error('socket hang up');
+            transport['_scheduleReconnection']({}, 0, triggeringError);
+
+            expect(errorSpy).toHaveBeenCalledTimes(1);
+            expect(errorSpy).toHaveBeenCalledWith(
+                expect.objectContaining({
+                    message: 'Maximum reconnection attempts (0) exceeded: socket hang up',
+                    cause: triggeringError
+                })
+            );
+            expect(transport['_cancelReconnection']).toBeUndefined();
+        });
+
         it('should schedule reconnection when maxRetries is greater than 0', async () => {
             // ARRANGE
             transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {