simplify: remove retryInterval from closeSSEStream callback

Remove the optional retryInterval parameter from closeSSEStream
callback for simplicity. The transport's default retry interval
(from priming events) is sufficient. This aligns with Python SDK.

Author: felixweinberger

src/examples/server/ssePollingExample.ts

@@ -62,11 +62,11 @@ server.tool(
         await sleep(1000);
 
         // Server decides to disconnect the client to free resources
-        // Client will reconnect via GET with Last-Event-ID after retryInterval
+        // Client will reconnect via GET with Last-Event-ID after the transport's retryInterval
         // Use extra.closeSSEStream callback - available when eventStore is configured
         if (extra.closeSSEStream) {
             console.log(`[${extra.sessionId}] Closing SSE stream to trigger client polling...`);
-            extra.closeSSEStream({ retryInterval: 2000 });
+            extra.closeSSEStream();
         }
 
         // Continue processing while client is disconnected

src/server/streamableHttp.test.ts

@@ -1815,7 +1815,7 @@ describe.each(zodTestMatrix)('$zodVersionLabel', (entry: ZodMatrixEntry) => {
             mcpServer = result.mcpServer;
 
             // Track whether closeSSEStream callback was provided
-            let receivedCloseSSEStream: ((options?: { retryInterval?: number }) => void) | undefined;
+            let receivedCloseSSEStream: (() => void) | undefined;
 
             // Register a tool that captures the extra.closeSSEStream callback
             mcpServer.tool('test-callback-tool', 'Test tool', {}, async (_args, extra) => {
@@ -1872,7 +1872,7 @@ describe.each(zodTestMatrix)('$zodVersionLabel', (entry: ZodMatrixEntry) => {
             mcpServer = result.mcpServer;
 
             // Track whether closeSSEStream callback was provided
-            let receivedCloseSSEStream: ((options?: { retryInterval?: number }) => void) | undefined;
+            let receivedCloseSSEStream: (() => void) | undefined;
 
             // Register a tool that captures the extra.closeSSEStream callback
             mcpServer.tool('test-no-callback-tool', 'Test tool', {}, async (_args, extra) => {
@@ -1916,76 +1916,6 @@ describe.each(zodTestMatrix)('$zodVersionLabel', (entry: ZodMatrixEntry) => {
             // Verify closeSSEStream callback was NOT provided
             expect(receivedCloseSSEStream).toBeUndefined();
         });
-
-        it('should send custom retry interval when closeSSEStream is called with retryInterval', async () => {
-            const result = await createTestServer({
-                sessionIdGenerator: () => randomUUID(),
-                eventStore: createEventStore(),
-                retryInterval: 1000 // Default
-            });
-            server = result.server;
-            transport = result.transport;
-            baseUrl = result.baseUrl;
-            mcpServer = result.mcpServer;
-
-            // Track tool execution state
-            let toolResolve: () => void;
-            const toolPromise = new Promise<void>(resolve => {
-                toolResolve = resolve;
-            });
-
-            // Register a tool that uses closeSSEStream with custom retry interval
-            mcpServer.tool('custom-retry-tool', 'Test tool', {}, async (_args, extra) => {
-                // Use closeSSEStream with custom retry interval
-                extra.closeSSEStream?.({ retryInterval: 5000 });
-                await toolPromise;
-                return { content: [{ type: 'text', text: 'Done' }] };
-            });
-
-            // Initialize to get session ID
-            const initResponse = await sendPostRequest(baseUrl, TEST_MESSAGES.initialize);
-            sessionId = initResponse.headers.get('mcp-session-id') as string;
-            expect(sessionId).toBeDefined();
-
-            // Call the tool
-            const toolCallRequest: JSONRPCMessage = {
-                jsonrpc: '2.0',
-                id: 202,
-                method: 'tools/call',
-                params: { name: 'custom-retry-tool', arguments: {} }
-            };
-
-            const postResponse = await fetch(baseUrl, {
-                method: 'POST',
-                headers: {
-                    'Content-Type': 'application/json',
-                    Accept: 'text/event-stream, application/json',
-                    'mcp-session-id': sessionId,
-                    'mcp-protocol-version': '2025-03-26'
-                },
-                body: JSON.stringify(toolCallRequest)
-            });
-
-            expect(postResponse.status).toBe(200);
-
-            // Collect all SSE data
-            const reader = postResponse.body?.getReader();
-            let allText = '';
-            while (true) {
-                const { done, value } = await reader!.read();
-                if (value) {
-                    allText += new TextDecoder().decode(value);
-                }
-                if (done) break;
-            }
-
-            // Verify the custom retry interval was sent
-            // The stream should contain "retry: 5000" (the custom value)
-            expect(allText).toContain('retry: 5000');
-
-            // Clean up
-            toolResolve!();
-        });
     });
 
     // Test onsessionclosed callback

src/server/streamableHttp.ts

@@ -1,7 +1,6 @@
 import { IncomingMessage, ServerResponse } from 'node:http';
 import { Transport } from '../shared/transport.js';
 import {
-    CloseSSEStreamOptions,
     MessageExtraInfo,
     RequestInfo,
     isInitializeRequest,
@@ -651,10 +650,10 @@ export class StreamableHTTPServerTransport implements Transport {
                 // handle each message
                 for (const message of messages) {
                     // Build closeSSEStream callback for requests when eventStore is configured
-                    let closeSSEStream: ((options?: CloseSSEStreamOptions) => void) | undefined;
+                    let closeSSEStream: (() => void) | undefined;
                     if (isJSONRPCRequest(message) && this._eventStore) {
-                        closeSSEStream = (options?: CloseSSEStreamOptions) => {
-                            this.closeSSEStream(message.id, options?.retryInterval);
+                        closeSSEStream = () => {
+                            this.closeSSEStream(message.id);
                         };
                     }
 
@@ -803,22 +802,13 @@ export class StreamableHTTPServerTransport implements Transport {
      * Close an SSE stream for a specific request, triggering client reconnection.
      * Use this to implement polling behavior during long-running operations -
      * client will reconnect after the retry interval specified in the priming event.
-     *
-     * @param requestId - The request ID whose stream should be closed
-     * @param retryInterval - Optional retry interval in milliseconds to send before closing.
-     *                        If provided, sends a retry field to override the transport default.
      */
-    closeSSEStream(requestId: RequestId, retryInterval?: number): void {
+    closeSSEStream(requestId: RequestId): void {
         const streamId = this._requestToStreamMapping.get(requestId);
         if (!streamId) return;
 
         const stream = this._streamMapping.get(streamId);
         if (stream) {
-            // If a custom retry interval is provided, send it before closing
-            // Use single \n (not \n\n) to avoid triggering SSE event dispatch
-            if (retryInterval !== undefined) {
-                stream.write(`retry: ${retryInterval}\n`);
-            }
             stream.end();
             this._streamMapping.delete(streamId);
         }

src/shared/protocol.ts

@@ -2,7 +2,6 @@ import { AnySchema, AnyObjectSchema, SchemaOutput, safeParse } from '../server/z
 import {
     CancelledNotificationSchema,
     ClientCapabilities,
-    CloseSSEStreamOptions,
     ErrorCode,
     isJSONRPCError,
     isJSONRPCRequest,
@@ -160,11 +159,8 @@ export type RequestHandlerExtra<SendRequestT extends Request, SendNotificationT
      * Closes the SSE stream for this request, triggering client reconnection.
      * Only available when using StreamableHTTPServerTransport with eventStore configured.
      * Use this to implement polling behavior during long-running operations.
-     *
-     * @param options - Optional configuration for the close operation
-     * @param options.retryInterval - Retry interval in milliseconds to suggest to clients
      */
-    closeSSEStream?: (options?: CloseSSEStreamOptions) => void;
+    closeSSEStream?: () => void;
 };
 
 /**

src/types.ts

@@ -1841,17 +1841,6 @@ export interface RequestInfo {
     headers: IsomorphicHeaders;
 }
 
-/**
- * Options for closing an SSE stream.
- */
-export interface CloseSSEStreamOptions {
-    /**
-     * Retry interval in milliseconds to suggest to clients before closing.
-     * When set, sends an SSE retry field to override the transport's default.
-     */
-    retryInterval?: number;
-}
-
 /**
  * Extra information about a message.
  */
@@ -1870,7 +1859,7 @@ export interface MessageExtraInfo {
      * Callback to close the SSE stream for this request, triggering client reconnection.
      * Only available when using StreamableHTTPServerTransport with eventStore configured.
      */
-    closeSSEStream?: (options?: CloseSSEStreamOptions) => void;
+    closeSSEStream?: () => void;
 }
 
 /* JSON-RPC types */