feat: implement SEP-1699 SSE polling via server-side disconnect

Add support for SSE retry field to enable server-controlled client reconnection timing.

Client changes:
- Capture server-provided retry field from SSE events
- Use retry value for reconnection delay instead of exponential backoff
- Reconnect on graceful stream close with Last-Event-ID header

Server changes:
- Add retryInterval option to StreamableHTTPServerTransportOptions
- Send priming events with id/retry/empty-data when eventStore is configured
- Add closeSSEStream(requestId) API to close POST SSE streams for polling
- Priming events establish resumption capability before actual messages

Tests:
- Client: retry field capture, exponential backoff fallback, graceful reconnection
- Server: priming events, retry field, stream closure, POST SSE polling flow

Author: felixweinberger

src/client/streamableHttp.test.ts

@@ -1010,6 +1010,148 @@ describe('StreamableHTTPClientTransport', () => {
         });
     });
 
+    describe('SSE retry field handling', () => {
+        beforeEach(() => {
+            vi.useFakeTimers();
+            (global.fetch as Mock).mockReset();
+        });
+        afterEach(() => vi.useRealTimers());
+
+        it('should use server-provided retry value for reconnection delay', async () => {
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
+                reconnectionOptions: {
+                    initialReconnectionDelay: 100,
+                    maxReconnectionDelay: 5000,
+                    reconnectionDelayGrowFactor: 2,
+                    maxRetries: 3
+                }
+            });
+
+            // Create a stream that sends a retry field
+            const encoder = new TextEncoder();
+            const stream = new ReadableStream({
+                start(controller) {
+                    // Send SSE event with retry field
+                    const event =
+                        'retry: 3000\nevent: message\nid: evt-1\ndata: {"jsonrpc": "2.0", "method": "notification", "params": {}}\n\n';
+                    controller.enqueue(encoder.encode(event));
+                    // Close stream to trigger reconnection
+                    controller.close();
+                }
+            });
+
+            const fetchMock = global.fetch as Mock;
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                headers: new Headers({ 'content-type': 'text/event-stream' }),
+                body: stream
+            });
+
+            // Second request for reconnection
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                headers: new Headers({ 'content-type': 'text/event-stream' }),
+                body: new ReadableStream()
+            });
+
+            await transport.start();
+            await transport['_startOrAuthSse']({});
+
+            // Wait for stream to close and reconnection to be scheduled
+            await vi.advanceTimersByTimeAsync(100);
+
+            // Verify the server retry value was captured
+            const transportInternal = transport as unknown as { _serverRetryMs?: number };
+            expect(transportInternal._serverRetryMs).toBe(3000);
+
+            // Verify the delay calculation uses server retry value
+            const getDelay = transport['_getNextReconnectionDelay'].bind(transport);
+            expect(getDelay(0)).toBe(3000); // Should use server value, not 100ms initial
+            expect(getDelay(5)).toBe(3000); // Should still use server value for any attempt
+        });
+
+        it('should fall back to exponential backoff when no server retry value', () => {
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
+                reconnectionOptions: {
+                    initialReconnectionDelay: 100,
+                    maxReconnectionDelay: 5000,
+                    reconnectionDelayGrowFactor: 2,
+                    maxRetries: 3
+                }
+            });
+
+            // Without any SSE stream, _serverRetryMs should be undefined
+            const transportInternal = transport as unknown as { _serverRetryMs?: number };
+            expect(transportInternal._serverRetryMs).toBeUndefined();
+
+            // Should use exponential backoff
+            const getDelay = transport['_getNextReconnectionDelay'].bind(transport);
+            expect(getDelay(0)).toBe(100); // 100 * 2^0
+            expect(getDelay(1)).toBe(200); // 100 * 2^1
+            expect(getDelay(2)).toBe(400); // 100 * 2^2
+            expect(getDelay(10)).toBe(5000); // capped at max
+        });
+
+        it('should reconnect on graceful stream close', async () => {
+            transport = new StreamableHTTPClientTransport(new URL('http://localhost:1234/mcp'), {
+                reconnectionOptions: {
+                    initialReconnectionDelay: 10,
+                    maxReconnectionDelay: 1000,
+                    reconnectionDelayGrowFactor: 1,
+                    maxRetries: 1
+                }
+            });
+
+            // Create a stream that closes gracefully after sending an event with ID
+            const encoder = new TextEncoder();
+            const stream = new ReadableStream({
+                start(controller) {
+                    // Send priming event with ID and retry field
+                    const event = 'id: evt-1\nretry: 100\ndata: \n\n';
+                    controller.enqueue(encoder.encode(event));
+                    // Graceful close
+                    controller.close();
+                }
+            });
+
+            const fetchMock = global.fetch as Mock;
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                headers: new Headers({ 'content-type': 'text/event-stream' }),
+                body: stream
+            });
+
+            // Second request for reconnection
+            fetchMock.mockResolvedValueOnce({
+                ok: true,
+                status: 200,
+                headers: new Headers({ 'content-type': 'text/event-stream' }),
+                body: new ReadableStream()
+            });
+
+            await transport.start();
+            await transport['_startOrAuthSse']({});
+
+            // Wait for stream to process and close
+            await vi.advanceTimersByTimeAsync(50);
+
+            // Wait for reconnection delay (100ms from retry field)
+            await vi.advanceTimersByTimeAsync(150);
+
+            // Should have attempted reconnection
+            expect(fetchMock).toHaveBeenCalledTimes(2);
+            expect(fetchMock.mock.calls[0][1]?.method).toBe('GET');
+            expect(fetchMock.mock.calls[1][1]?.method).toBe('GET');
+
+            // Second call should include Last-Event-ID
+            const secondCallHeaders = fetchMock.mock.calls[1][1]?.headers;
+            expect(secondCallHeaders?.get('last-event-id')).toBe('evt-1');
+        });
+    });
+
     describe('prevent infinite recursion when server returns 401 after successful auth', () => {
         it('should throw error when server returns 401 after successful auth', async () => {
             const message: JSONRPCMessage = {

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
 
     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
+        // 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,14 @@ 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) => {
+                                // Capture server-provided retry value for reconnection timing
+                                this._serverRetryMs = retryMs;
+                            }
+                        })
+                    )
                     .getReader();
 
                 while (true) {
@@ -328,6 +342,19 @@ export class StreamableHTTPClientTransport implements Transport {
                         }
                     }
                 }
+
+                // 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}`));