fix(server): streamableHttp stores request-related events when stream is disconnected

The standalone-SSE path stores to eventStore first, then writes if connected.
The request-related path only stored when the stream was live, so a
notification sent after closeSSE() (SEP-1699 polling) was silently dropped
instead of being persisted for replay on reconnect.

Exposed by the ctx.mcpReq.log request-related change against the new
sse-polling example story; the gap pre-exists on main for any
request-related notification (progress, ctx.mcpReq.notify) emitted after
closeSSE().

Author: felixweinberger

.changeset/server-streamablehttp-store-first.md

@@ -0,0 +1,5 @@
+---
+'@modelcontextprotocol/server': patch
+---
+
+`WebStandardStreamableHTTPServerTransport`: request-related events (progress, `ctx.mcpReq.notify`, handler-emitted log) sent while the per-request SSE stream is intentionally closed (e.g. after `closeSSE()` for SEP-1699 polling) are now persisted to the configured `eventStore` so they replay on reconnect. Previously they were silently dropped. Events sent after the per-request stream entry is fully torn down are not persisted.

packages/server/src/server/streamableHttp.ts

@@ -1002,15 +1002,24 @@ export class WebStandardStreamableHTTPServerTransport implements Transport {
 
         const stream = this._streamMapping.get(streamId);
 
-        if (!this._enableJsonResponse && stream?.controller && stream?.encoder) {
-            // For SSE responses, generate event ID if event store is provided
+        if (!this._enableJsonResponse) {
+            // Store FIRST so request-related events emitted while the per-request
+            // stream is disconnected (e.g. after `closeSSE()`) are replayed on
+            // reconnect — same store-first semantics as the standalone path above.
+            // Gated on `stream !== undefined`: when the per-request stream entry
+            // has been torn down entirely (the streamId is no longer in
+            // `_streamMapping`), the request was abandoned — do not persist for a
+            // replay that will never be requested. `closeSSE()` only nulls the
+            // controller/encoder, so the entry stays present and the store still
+            // runs in that intentional poll-and-replay case.
             let eventId: string | undefined;
-
-            if (this._eventStore) {
+            if (this._eventStore && stream !== undefined) {
                 eventId = await this._eventStore.storeEvent(streamId, message);
             }
-            // Write the event to the response stream
-            this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+            if (stream?.controller && stream?.encoder) {
+                // Write the event to the response stream
+                this.writeSSEEvent(stream.controller, stream.encoder, message, eventId);
+            }
         }
 
         if (isJSONRPCResultResponse(message) || isJSONRPCErrorResponse(message)) {