Field noteNov 21, 20265 min read1 source

MCP Ruby SDK v1.11.0 adds resumable SSE streams to Streamable HTTP transport

In one minute

MCP Ruby SDK v1.11.0 adds resumable server-sent event streams to its Streamable HTTP transport. With an event store and Last-Event-ID, reconnecting clients can receive missed notifications and a final response from work that continued after a connection broke, giving Ruby MCP implementers a defined recovery path for long-running operations.

What happened

The MCP Ruby SDK v1.11.0 release page says the release adds support for resuming SSE streams during the handshake lifecycle of the Streamable HTTP transport, citing SEP-1699. The mechanism is opt-in through an event_store:. When one is configured, the server gives each event an ID. A client that reconnects and sends Last-Event-ID can receive the events it missed while disconnected.

The release says the replay can include remaining notifications and the response to a request that is still running. That distinction matters for an MCP interaction whose client connection ends before the underlying work finishes. Rather than treating an interrupted stream as proof that the work failed or that its result has disappeared, an implementation can retain emitted events and deliver them to an authenticated reconnecting client. The release describes replay of stored events; it does not say that a request itself is restarted, retried, or made idempotent by this feature.

The release also introduces server_context.close_sse_stream, which lets a handler close its SSE connection so a long operation does not need to hold that connection open. The SDK defines the event-store contract and points maintainers to examples/in_memory_event_store.rb as an implementation example. An in-memory store is useful for understanding the required interface, but the release page does not present it as a durable production store or describe persistence guarantees.

v1.11.0 includes several other changes. allowed_origins: :any accepts every Origin while retaining the Host check. Authorization-server selection now uses the stored issuer, and machine-to-machine provider issuers are validated as issuer URLs. The release also accepts localhost names in URLs published through Protected Resource Metadata, returns a 401 for a JWT whose header is not an object, validates required parameters for resources/read, and rejects integer request IDs beyond 128 bits. GitHub identifies the version as v1.11.0, shows it released by koic on November 19, and records six commits to main since the release.

What the archive adds

New Runtime's earlier coverage of an MCP server SSE session vulnerability examined a separate MoLing issue in which SSE mode could allow cross-origin session hijacking and tool calls. This is a new fact on the broader MCP transport story: a Ruby SDK now adds stream resumption, rather than fixing that earlier vulnerability.

Trend signal

This release supports agent protocols becoming an interoperability layer. An integration protocol becomes operationally useful not only when it can carry a tool request, but when its implementations define what happens as ordinary network conditions interrupt a client-server exchange. Event identifiers, replay, and reconnection semantics are small transport details with direct effects on whether an MCP client can safely recover an unfinished interaction. The evidence remains limited to one SDK and one transport capability, so it does not show broad adoption across MCP implementations.

Why it matters

A Ruby team operating MCP over Streamable HTTP can now build reconnect behavior around an SDK-level contract instead of inventing an application-specific way to recover output after a dropped stream. For work that takes long enough for networks, browser clients, proxies, or agent runtimes to disconnect, receiving the final response after reconnecting can reduce ambiguity about whether a request completed.

The useful unit here is not merely “SSE support,” but the combination of event identity, retained output, and a client cursor through Last-Event-ID. The ability to close an SSE stream separately also gives handlers a way to avoid tying one open connection to the full lifetime of long-running work. Those gains depend on a design that can associate a reconnecting client with the correct prior stream and preserve only the events it is authorized to receive.

Limits and uncertainty

The release page does not state the performance cost of recording events, the retention period for an event store, or durability guarantees after a process restart. It does not describe a production persistence implementation, eviction behavior when a requested event ID is unavailable, or a maximum reconnection window. The page also does not report measurements under concurrent requests, load, proxy timeouts, or deliberate network failures.

The new allowed_origins: :any option retains a Host check according to the release, but the page does not explain which deployment configurations are appropriate for accepting every Origin. Likewise, replay behavior is described at the SDK level, not independently verified across particular Ruby server frameworks or client implementations. Teams should test their own authorization, retention, failure, and reconnect paths before treating replayed streams as a production reliability guarantee.

Reader takeaway

MCP Ruby SDK v1.11.0 gives Streamable HTTP implementations a concrete SSE recovery mechanism: store events, assign IDs, and let a reconnecting client continue from Last-Event-ID. If you run a Ruby MCP server with long operations, inspect the event-store contract and example, then test retention, authorization, and reconnect behavior in your own deployment before depending on it.

Evidence / sources

  1. 1github.com/modelcontextprotocol/ruby-sdk/releases/tag/v1.11.0
All Field Notes

Next reads

Read next

Open the graph
  1. 01topicMcpExplore the mcp topic hub.
  2. 02archiveField NotesOpen the latest editorial analysis.
  3. 03sourcesSourcesSee the original sources this archive cites.
Who read this page?Machine requests, hidden until opened

Loading the privacy-safe route aggregate...

Open the JSON contract