Skip to content

Commit 17277b3

Browse files
committed
Streamable HTTP: flush SSE headers early
Signed-off-by: Daniel Garnier-Moiroux <git@garnier.wf>
1 parent e0af8cd commit 17277b3

2 files changed

Lines changed: 118 additions & 35 deletions

File tree

‎mcp-core/src/main/java/io/modelcontextprotocol/server/transport/HttpServletStreamableServerTransportProvider.java‎

Lines changed: 71 additions & 19 deletions
Original file line numberDiff line numberDiff line change
@@ -425,14 +425,32 @@ protected void doGet(HttpServletRequest request, HttpServletResponse response)
425425

426426
McpTransportContext transportContext = this.contextExtractor.extract(request);
427427

428-
try {
429-
HttpServletResponseUtils.prepareSseResponse(response);
428+
// Before getWriter(): the character encoding is ignored once the writer is taken
429+
HttpServletResponseUtils.prepareSseResponse(response);
430430

431-
AsyncContext asyncContext = request.startAsync();
431+
PrintWriter writer;
432+
AsyncContext asyncContext;
433+
try {
434+
writer = response.getWriter();
435+
asyncContext = request.startAsync();
432436
asyncContext.setTimeout(0);
437+
}
438+
catch (Exception e) {
439+
// A deployment error, such as a servlet or filter not supporting async.
440+
// Nothing has been sent and async has not started, so an error status can
441+
// still be returned
442+
logger.error("Failed to start the GET stream for session {}: {}", sessionId, e.getMessage());
443+
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
444+
return;
445+
}
433446

434-
HttpServletStreamableMcpSessionTransport sessionTransport = new HttpServletStreamableMcpSessionTransport(
435-
sessionId, asyncContext, response.getWriter());
447+
// From here on the headers may already be sent: a failure can only end the stream
448+
HttpServletStreamableMcpSessionTransport sessionTransport = new HttpServletStreamableMcpSessionTransport(
449+
sessionId, asyncContext, writer);
450+
try {
451+
// Send the status line and headers now: the listening stream may stay idle
452+
// for a long time, and clients wait for the headers before reading events
453+
response.flushBuffer();
436454

437455
// Replay the messages the client missed while its stream was broken
438456
String lastEventId = request.getHeader(HttpHeaders.LAST_EVENT_ID);
@@ -450,9 +468,14 @@ protected void doGet(HttpServletRequest request, HttpServletResponse response)
450468

451469
registerAsyncLifecycle(asyncContext, sessionId, listeningStream::releaseTransport);
452470
}
471+
catch (IOException e) {
472+
// Only flushing the headers throws it: the client is gone
473+
logger.debug("Failed to send the GET stream headers for session {}: {}", sessionId, e.getMessage());
474+
sessionTransport.close();
475+
}
453476
catch (Exception e) {
454477
logger.error("Failed to handle GET request for session {}: {}", sessionId, e.getMessage());
455-
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
478+
sessionTransport.close();
456479
}
457480
}
458481

@@ -597,28 +620,57 @@ else if (message instanceof McpSchema.JSONRPCNotification jsonrpcNotification) {
597620
response.setStatus(HttpServletResponse.SC_ACCEPTED);
598621
}
599622
else if (message instanceof McpSchema.JSONRPCRequest jsonrpcRequest) {
600-
// For streaming responses, we need to return SSE
623+
// For streaming responses, we need to return SSE. Before getWriter(): the
624+
// character encoding is ignored once the writer is taken
601625
HttpServletResponseUtils.prepareSseResponse(response);
602626

603-
AsyncContext asyncContext = request.startAsync();
604-
asyncContext.setTimeout(0);
627+
PrintWriter writer;
628+
AsyncContext asyncContext;
629+
try {
630+
writer = response.getWriter();
631+
asyncContext = request.startAsync();
632+
asyncContext.setTimeout(0);
633+
}
634+
catch (Exception e) {
635+
// A deployment error, such as a servlet or filter not supporting
636+
// async. Nothing has been sent and async has not started, so an error
637+
// status can still be returned
638+
logger.error("Failed to start the request stream for session {}: {}", sessionId, e.getMessage());
639+
response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
640+
return;
641+
}
605642

643+
// From here on the headers may already be sent: a failure can only end
644+
// the stream
606645
HttpServletStreamableMcpSessionTransport sessionTransport = new HttpServletStreamableMcpSessionTransport(
607-
sessionId, asyncContext, response.getWriter());
608-
609-
// The listener is given the stream rather than its transport, so that the
610-
// end of the connection detaches the stream from the session instead of
611-
// only dropping the socket: a stream outliving its connection keeps the
612-
// session looking busy and spares it from the sweeper
613-
McpStreamableServerSession.McpStreamableServerSessionStream responseStream = session
614-
.responseStream(sessionTransport);
615-
registerAsyncLifecycle(asyncContext, sessionId, responseStream::releaseTransport);
616-
646+
sessionId, asyncContext, writer);
617647
try {
648+
// Send the status line and headers now: the request may take a long
649+
// time to answer, and clients wait for the headers before reading
650+
// events. Flush before the stream is registered with the session, so
651+
// that no other thread can close it while the headers are written
652+
response.flushBuffer();
653+
654+
// The listener is given the stream rather than its transport, so that
655+
// the end of the connection detaches the stream from the session
656+
// instead of only dropping the socket: a stream outliving its
657+
// connection keeps the session looking busy and spares it from the
658+
// sweeper
659+
McpStreamableServerSession.McpStreamableServerSessionStream responseStream = session
660+
.responseStream(sessionTransport);
661+
registerAsyncLifecycle(asyncContext, sessionId, responseStream::releaseTransport);
662+
618663
responseStream.handle(jsonrpcRequest)
619664
.contextWrite(ctx -> ctx.put(McpTransportContext.KEY, transportContext))
620665
.block();
621666
}
667+
catch (IOException e) {
668+
// Only flushing the headers throws it: the client is gone, and the
669+
// request is not handled
670+
logger.debug("Failed to send the request stream headers for session {}: {}", sessionId,
671+
e.getMessage());
672+
sessionTransport.close();
673+
}
622674
catch (Exception e) {
623675
logger.error("Failed to handle request stream: {}", e.getMessage());
624676
// The transport may already have completed the async context, when

‎mcp-test/src/test/java/io/modelcontextprotocol/server/HttpServletStreamableIntegrationTests.java‎

Lines changed: 47 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -19,9 +19,11 @@
1919
import java.util.Queue;
2020
import java.util.concurrent.CompletableFuture;
2121
import java.util.concurrent.ConcurrentLinkedQueue;
22+
import java.util.concurrent.TimeUnit;
2223
import java.util.concurrent.atomic.AtomicBoolean;
2324
import java.util.concurrent.atomic.AtomicReference;
2425
import java.util.function.Function;
26+
import java.util.function.UnaryOperator;
2527
import java.util.stream.Stream;
2628

2729
import ch.qos.logback.classic.Level;
@@ -39,6 +41,7 @@
3941
import io.modelcontextprotocol.spec.HttpHeaders;
4042
import io.modelcontextprotocol.spec.McpSchema;
4143
import io.modelcontextprotocol.util.KeepAliveScheduler;
44+
import io.modelcontextprotocol.util.ToolsUtils;
4245
import jakarta.servlet.http.HttpServletRequest;
4346
import jakarta.servlet.http.HttpServletResponse;
4447
import org.apache.catalina.LifecycleException;
@@ -57,6 +60,7 @@
5760
import org.slf4j.LoggerFactory;
5861
import reactor.core.publisher.Flux;
5962
import reactor.core.publisher.Mono;
63+
import reactor.core.publisher.Sinks;
6064
import reactor.core.scheduler.Schedulers;
6165
import reactor.test.StepVerifier;
6266
import reactor.test.scheduler.VirtualTimeScheduler;
@@ -214,8 +218,9 @@ void testMissingHandlerReturnsMethodNotFoundError() {
214218
}
215219

216220
@Test
217-
void listeningStreamHasStreamingHeaders() throws Exception {
218-
prepareAsyncServerBuilder().serverInfo("test-server", "1.0.0").build();
221+
void listeningStreamSendsHeadersBeforeFirstEvent() throws Exception {
222+
// No keep-alive, so the server never writes to the stream
223+
withTransportProvider(null, null);
219224
var sessionId = initializeSession(httpClient);
220225

221226
var get = HttpRequest.newBuilder()
@@ -225,8 +230,10 @@ void listeningStreamHasStreamingHeaders() throws Exception {
225230
.GET()
226231
.build();
227232

228-
var response = httpClient.send(get, HttpResponse.BodyHandlers.ofInputStream());
233+
// The response completes as soon as the headers are received
234+
var response = httpClient.sendAsync(get, HttpResponse.BodyHandlers.ofInputStream()).get(5, TimeUnit.SECONDS);
229235
try {
236+
assertThat(response.statusCode()).isEqualTo(HttpServletResponse.SC_OK);
230237
assertSseHeaders(response);
231238
}
232239
finally {
@@ -235,17 +242,29 @@ void listeningStreamHasStreamingHeaders() throws Exception {
235242
}
236243

237244
@Test
238-
void toolCallSseResponseHasStreamingHeaders() throws Exception {
239-
prepareAsyncServerBuilder().serverInfo("test-server", "1.0.0")
240-
.capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
245+
void toolCallSseResponseSendsHeadersBeforeResult() throws Exception {
246+
mcpServerTransportProvider.closeGracefully().block();
247+
mcpServerTransportProvider = HttpServletStreamableServerTransportProvider.builder()
248+
.contextExtractor(TEST_CONTEXT_EXTRACTOR)
249+
.mcpEndpoint(MESSAGE_ENDPOINT)
250+
// No keep-alive, so the server writes nothing until the tool returns
251+
.keepAliveInterval(null)
252+
// no sweeping: the session must survive every keep-alive round
253+
.sessionSweepInterval(null)
254+
.build();
255+
256+
MCP_SERVLET.setDelegate(mcpServerTransportProvider);
257+
258+
// Custom server with a tool that hangs
259+
Sinks.One<McpSchema.CallToolResult> toolResult = Sinks.one();
260+
prepareAsyncServerBuilder().capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
241261
.tools(McpServerFeatures.AsyncToolSpecification.builder()
242-
.tool(McpSchema.Tool.builder("echo", EMPTY_JSON_SCHEMA).description("returns immediately").build())
243-
.callHandler((exchange,
244-
request) -> Mono.just(McpSchema.CallToolResult.builder()
245-
.content(List.of(McpSchema.TextContent.builder("ok").build()))
246-
.isError(false)
247-
.build()))
262+
.tool(McpSchema.Tool.builder("slow", ToolsUtils.EMPTY_JSON_SCHEMA)
263+
.description("returns when released")
264+
.build())
265+
.callHandler((exchange, request) -> toolResult.asMono())
248266
.build())
267+
.serverInfo("test-server", "1.0.0")
249268
.build();
250269
var sessionId = initializeSession(httpClient);
251270

@@ -256,15 +275,27 @@ void toolCallSseResponseHasStreamingHeaders() throws Exception {
256275
.header(HttpHeaders.MCP_SESSION_ID, sessionId)
257276
.POST(HttpRequest.BodyPublishers
258277
.ofString("{\"jsonrpc\":\"2.0\",\"id\":\"call-1\",\"method\":\"tools/call\","
259-
+ "\"params\":{\"name\":\"echo\",\"arguments\":{}}}"))
278+
+ "\"params\":{\"name\":\"slow\",\"arguments\":{}}}"))
260279
.build();
261280

262-
var response = httpClient.send(post, HttpResponse.BodyHandlers.ofInputStream());
263281
try {
264-
assertSseHeaders(response);
282+
// The response completes as soon as the headers are received
283+
var response = httpClient.sendAsync(post, HttpResponse.BodyHandlers.ofInputStream())
284+
.get(5, TimeUnit.SECONDS);
285+
try {
286+
assertThat(response.statusCode()).isEqualTo(HttpServletResponse.SC_OK);
287+
assertSseHeaders(response);
288+
}
289+
finally {
290+
response.body().close();
291+
}
265292
}
266293
finally {
267-
response.body().close();
294+
// Release the Tomcat thread blocked in doPost until the tool returns
295+
toolResult.tryEmitValue(McpSchema.CallToolResult.builder()
296+
.content(List.of(McpSchema.TextContent.builder("done").build()))
297+
.isError(false)
298+
.build());
268299
}
269300
}
270301

0 commit comments

Comments
 (0)