feat: support SSE retry field for reconnection timing (SEP-1699)

Add support for the SSE retry field to control client reconnection timing.
When a server sends a retry field in an SSE event, the client now uses
that value instead of exponential backoff for scheduling reconnections.

Also adds support for reconnecting on graceful stream close, allowing
servers to implement polling behavior by closing connections after
sending event IDs.

Changes:
- Capture retry field via EventSourceParserStream onRetry callback
- Use server-provided retry value in _getNextReconnectionDelay
- Schedule reconnection on graceful stream end (not just errors)

Author: felixweinberger

src/client/streamableHttp.ts

@@ -134,6 +134,7 @@ export class StreamableHTTPClientTransport implements Transport {
     private _reconnectionOptions: StreamableHTTPReconnectionOptions;
     private _protocolVersion?: string;
     private _hasCompletedAuthFlow = false; // Circuit breaker: detect auth success followed by immediate 401
+    private _serverRetryMs?: number; // Server-provided retry delay from SSE retry field (SEP-1699)
 
     onclose?: () => void;
     onerror?: (error: Error) => void;
@@ -202,6 +203,7 @@ export class StreamableHTTPClientTransport implements Transport {
 
     private async _startOrAuthSse(options: StartSSEOptions): Promise<void> {
         const { resumptionToken } = options;
+
         try {
             // Try to open an initial SSE stream with GET to listen for server messages
             // This is optional according to the spec - server may not support it
@@ -248,7 +250,12 @@ export class StreamableHTTPClientTransport implements Transport {
      * @returns Time to wait in milliseconds before next reconnection attempt
      */
     private _getNextReconnectionDelay(attempt: number): number {
-        // Access default values directly, ensuring they're never undefined
+        // SEP-1699: Use server-provided retry value if available
+        if (this._serverRetryMs !== undefined) {
+            return this._serverRetryMs;
+        }
+
+        // Fall back to exponential backoff
         const initialDelay = this._reconnectionOptions.initialReconnectionDelay;
         const growFactor = this._reconnectionOptions.reconnectionDelayGrowFactor;
         const maxDelay = this._reconnectionOptions.maxReconnectionDelay;
@@ -301,7 +308,12 @@ export class StreamableHTTPClientTransport implements Transport {
                 // Create a pipeline: binary stream -> text decoder -> SSE parser
                 const reader = stream
                     .pipeThrough(new TextDecoderStream() as ReadableWritablePair<string, Uint8Array>)
-                    .pipeThrough(new EventSourceParserStream())
+                    .pipeThrough(new EventSourceParserStream({
+                        onRetry: (retryMs: number) => {
+                            // SEP-1699: Capture server-provided retry value for reconnection timing
+                            this._serverRetryMs = retryMs;
+                        }
+                    }))
                     .getReader();
 
                 while (true) {
@@ -328,6 +340,19 @@ export class StreamableHTTPClientTransport implements Transport {
                         }
                     }
                 }
+
+                // SEP-1699: Handle graceful server-side disconnect
+                // Server may close connection after sending event ID and retry field
+                if (isReconnectable && this._abortController && !this._abortController.signal.aborted) {
+                    this._scheduleReconnection(
+                        {
+                            resumptionToken: lastEventId,
+                            onresumptiontoken,
+                            replayMessageId
+                        },
+                        0
+                    );
+                }
             } catch (error) {
                 // Handle stream errors - likely a network disconnect
                 this.onerror?.(new Error(`SSE stream disconnected: ${error}`));