fix: revert GET stream event storage, add POST SSE polling test

- Revert send() changes for GET streams: only store events when stream
  is active (not part of SEP-1699 scope)
- Add POST SSE polling test that demonstrates full reconnection flow:
  client sends POST, gets priming event, server closes stream,
  client reconnects with Last-Event-ID, events are replayed

Author: felixweinberger

src/server/streamableHttp.test.ts

@@ -1771,6 +1771,107 @@ describe('StreamableHTTPServerTransport POST SSE priming events', () => {
         // Clean up - resolve the tool promise
         toolResolve!();
     });
+
+    it('should support POST SSE polling with client reconnection', async () => {
+        const result = await createTestServer({
+            sessionIdGenerator: () => randomUUID(),
+            eventStore: createEventStore(),
+            retryInterval: 1000
+        });
+        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 sends progress and then completes
+        mcpServer.tool('polling-tool', 'A tool for polling test', {}, async () => {
+            // Wait for test to signal completion
+            await toolPromise;
+            return { content: [{ type: 'text', text: 'Final result' }] };
+        });
+
+        // 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();
+
+        // Send a POST request for the tool
+        const toolCallRequest: JSONRPCMessage = {
+            jsonrpc: '2.0',
+            id: 100,
+            method: 'tools/call',
+            params: { name: 'polling-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);
+        expect(postResponse.headers.get('content-type')).toBe('text/event-stream');
+
+        const reader = postResponse.body?.getReader();
+
+        // Read the priming event and extract event ID
+        const { value: primingValue } = await reader!.read();
+        const primingText = new TextDecoder().decode(primingValue);
+        expect(primingText).toContain('id: ');
+        expect(primingText).toContain('retry: 1000');
+
+        // Extract the priming event ID
+        const primingIdMatch = primingText.match(/id: ([^\n]+)/);
+        expect(primingIdMatch).toBeTruthy();
+        const primingEventId = primingIdMatch![1];
+
+        // Server closes the stream to trigger polling
+        transport.closeSSEStream(100);
+
+        // Verify stream is closed
+        const { done } = await reader!.read();
+        expect(done).toBe(true);
+
+        // Now complete the tool - this will store the result event
+        toolResolve!();
+
+        // Give the tool time to complete and store the result
+        await new Promise(resolve => setTimeout(resolve, 50));
+
+        // Client reconnects with Last-Event-ID to get missed events
+        const reconnectResponse = await fetch(baseUrl, {
+            method: 'GET',
+            headers: {
+                Accept: 'text/event-stream',
+                'mcp-session-id': sessionId,
+                'mcp-protocol-version': '2025-03-26',
+                'last-event-id': primingEventId
+            }
+        });
+
+        expect(reconnectResponse.status).toBe(200);
+        expect(reconnectResponse.headers.get('content-type')).toBe('text/event-stream');
+
+        // Read the replayed events
+        const reconnectReader = reconnectResponse.body?.getReader();
+        const { value: replayValue } = await reconnectReader!.read();
+        const replayText = new TextDecoder().decode(replayValue);
+
+        // Should receive the tool result that was stored after stream was closed
+        expect(replayText).toContain('Final result');
+        expect(replayText).toContain('"id":100');
+    });
 });
 
 // Test onsessionclosed callback

src/server/streamableHttp.ts

@@ -774,19 +774,18 @@ export class StreamableHTTPServerTransport implements Transport {
                 throw new Error('Cannot send a response on a standalone SSE stream unless resuming a previous client request');
             }
 
+            const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
+            if (standaloneSse === undefined) {
+                // No active stream - nothing to do
+                return;
+            }
+
             // Generate and store event ID if event store is provided
-            // Store even if no active stream - events will be replayed on reconnection
             let eventId: string | undefined;
             if (this._eventStore) {
                 eventId = await this._eventStore.storeEvent(this._standaloneSseStreamId, message);
             }
 
-            const standaloneSse = this._streamMapping.get(this._standaloneSseStreamId);
-            if (standaloneSse === undefined) {
-                // No active stream - message stored for replay, nothing more to do
-                return;
-            }
-
             // Send the message to the standalone SSE stream
             this.writeSSEEvent(standaloneSse, message, eventId);
             return;