1919import java .util .Queue ;
2020import java .util .concurrent .CompletableFuture ;
2121import java .util .concurrent .ConcurrentLinkedQueue ;
22+ import java .util .concurrent .TimeUnit ;
2223import java .util .concurrent .atomic .AtomicBoolean ;
2324import java .util .concurrent .atomic .AtomicReference ;
2425import java .util .function .Function ;
3940import io .modelcontextprotocol .spec .HttpHeaders ;
4041import io .modelcontextprotocol .spec .McpSchema ;
4142import io .modelcontextprotocol .util .KeepAliveScheduler ;
43+ import io .modelcontextprotocol .util .ToolsUtils ;
4244import jakarta .servlet .http .HttpServletRequest ;
4345import jakarta .servlet .http .HttpServletResponse ;
4446import org .apache .catalina .LifecycleException ;
5557import org .slf4j .LoggerFactory ;
5658import reactor .core .publisher .Flux ;
5759import reactor .core .publisher .Mono ;
60+ import reactor .core .publisher .Sinks ;
5861import reactor .core .scheduler .Schedulers ;
5962import reactor .test .StepVerifier ;
6063import reactor .test .scheduler .VirtualTimeScheduler ;
@@ -205,8 +208,9 @@ void testMissingHandlerReturnsMethodNotFoundError() {
205208 }
206209
207210 @ Test
208- void listeningStreamHasStreamingHeaders () throws Exception {
209- prepareAsyncServerBuilder ().serverInfo ("test-server" , "1.0.0" ).build ();
211+ void listeningStreamSendsHeadersBeforeFirstEvent () throws Exception {
212+ // Without keep-alive nothing is written, so only an early flush sends the headers
213+ withTransportProvider (null , null );
210214 var sessionId = initializeSession (httpClient );
211215
212216 var get = HttpRequest .newBuilder ()
@@ -216,8 +220,10 @@ void listeningStreamHasStreamingHeaders() throws Exception {
216220 .GET ()
217221 .build ();
218222
219- var response = httpClient .send (get , HttpResponse .BodyHandlers .ofInputStream ());
223+ // Completes once the headers arrive, before any event
224+ var response = httpClient .sendAsync (get , HttpResponse .BodyHandlers .ofInputStream ()).get (5 , TimeUnit .SECONDS );
220225 try {
226+ assertThat (response .statusCode ()).isEqualTo (HttpServletResponse .SC_OK );
221227 assertSseHeaders (response );
222228 }
223229 finally {
@@ -226,17 +232,28 @@ void listeningStreamHasStreamingHeaders() throws Exception {
226232 }
227233
228234 @ Test
229- void toolCallSseResponseHasStreamingHeaders () throws Exception {
230- prepareAsyncServerBuilder ().serverInfo ("test-server" , "1.0.0" )
231- .capabilities (McpSchema .ServerCapabilities .builder ().tools (true ).build ())
235+ void toolCallSseResponseSendsHeadersBeforeResult () throws Exception {
236+ mcpServerTransportProvider .closeGracefully ().block ();
237+ mcpServerTransportProvider = HttpServletStreamableServerTransportProvider .builder ()
238+ .contextExtractor (TEST_CONTEXT_EXTRACTOR )
239+ .mcpEndpoint (MESSAGE_ENDPOINT )
240+ // Without keep-alive nothing is written until the tool returns
241+ .keepAliveInterval (null )
242+ .sessionSweepInterval (null )
243+ .build ();
244+
245+ mcpServlet .setDelegate (mcpServerTransportProvider );
246+
247+ // Returns once the test completes toolResult
248+ Sinks .One <McpSchema .CallToolResult > toolResult = Sinks .one ();
249+ prepareAsyncServerBuilder ().capabilities (McpSchema .ServerCapabilities .builder ().tools (true ).build ())
232250 .tools (McpServerFeatures .AsyncToolSpecification .builder ()
233- .tool (McpSchema .Tool .builder ("echo" , EMPTY_JSON_SCHEMA ).description ("returns immediately" ).build ())
234- .callHandler ((exchange ,
235- request ) -> Mono .just (McpSchema .CallToolResult .builder ()
236- .content (List .of (McpSchema .TextContent .builder ("ok" ).build ()))
237- .isError (false )
238- .build ()))
251+ .tool (McpSchema .Tool .builder ("slow" , ToolsUtils .EMPTY_JSON_SCHEMA )
252+ .description ("returns when released" )
253+ .build ())
254+ .callHandler ((exchange , request ) -> toolResult .asMono ())
239255 .build ())
256+ .serverInfo ("test-server" , "1.0.0" )
240257 .build ();
241258 var sessionId = initializeSession (httpClient );
242259
@@ -247,15 +264,27 @@ void toolCallSseResponseHasStreamingHeaders() throws Exception {
247264 .header (HttpHeaders .MCP_SESSION_ID , sessionId )
248265 .POST (HttpRequest .BodyPublishers
249266 .ofString ("{\" jsonrpc\" :\" 2.0\" ,\" id\" :\" call-1\" ,\" method\" :\" tools/call\" ,"
250- + "\" params\" :{\" name\" :\" echo \" ,\" arguments\" :{}}}" ))
267+ + "\" params\" :{\" name\" :\" slow \" ,\" arguments\" :{}}}" ))
251268 .build ();
252269
253- var response = httpClient .send (post , HttpResponse .BodyHandlers .ofInputStream ());
254270 try {
255- assertSseHeaders (response );
271+ // Completes once the headers arrive, before any event
272+ var response = httpClient .sendAsync (post , HttpResponse .BodyHandlers .ofInputStream ())
273+ .get (5 , TimeUnit .SECONDS );
274+ try {
275+ assertThat (response .statusCode ()).isEqualTo (HttpServletResponse .SC_OK );
276+ assertSseHeaders (response );
277+ }
278+ finally {
279+ response .body ().close ();
280+ }
256281 }
257282 finally {
258- response .body ().close ();
283+ // Release the Tomcat thread blocked in doPost until the tool returns
284+ toolResult .tryEmitValue (McpSchema .CallToolResult .builder ()
285+ .content (List .of (McpSchema .TextContent .builder ("done" ).build ()))
286+ .isError (false )
287+ .build ());
259288 }
260289 }
261290
@@ -563,10 +592,6 @@ void sessionEvictionAfterReleasingStream() {
563592 var sessionId = initializeSession (httpClient );
564593 var clientStream = openListeningStream (httpClient , sessionId , null );
565594 awaitClientStreamEstablished ();
566- // "prep" the client so we can close the stream by sending data: the
567- // subscription
568- // in the clientStream is only present when the client has received data
569- awaitNotification (clientStream .events ());
570595 virtualTime .advanceTimeBy (SESSION_SWEEP_INTERVAL .multipliedBy (2 ));
571596 assertThat (postNotification (httpClient , sessionId )).as ("Session should be active when a stream is open" )
572597 .isEqualTo (HttpServletResponse .SC_ACCEPTED );
@@ -621,17 +646,22 @@ void sessionIsEvictedWhenTheClientAbortsAResponseStream() {
621646 try {
622647 withTransportProvider (null , SESSION_SWEEP_INTERVAL );
623648 var toolEmissionInterval = Duration .ofMillis (10 );
649+ var toolCalled = new AtomicBoolean ();
624650 prepareAsyncServerBuilder ().serverInfo ("test-server" , "1.0.0" )
625651 .capabilities (McpSchema .ServerCapabilities .builder ().tools (true ).build ())
626652 .tools (McpServerFeatures .AsyncToolSpecification .builder ()
627653 .tool (McpSchema .Tool .builder ("hangs" , EMPTY_JSON_SCHEMA ).description ("never returns" ).build ())
628- .callHandler ((exchange , request ) -> Flux
629- .interval (toolEmissionInterval , toolEmissionInterval , Schedulers .newSingle ("test-tool" ))
630- .flatMap (tick -> exchange .loggingNotification (McpSchema .LoggingMessageNotification .builder ()
631- .level (McpSchema .LoggingLevel .INFO )
632- .data ("x" .repeat (64 * 1024 ))
633- .build ()))
634- .then (Mono .<McpSchema .CallToolResult >never ()))
654+ .callHandler ((exchange , request ) -> {
655+ toolCalled .set (true );
656+ // Keep writing: a disconnect is only noticed on write
657+ return Flux
658+ .interval (toolEmissionInterval , toolEmissionInterval , Schedulers .newSingle ("test-tool" ))
659+ .flatMap (tick -> exchange .loggingNotification (McpSchema .LoggingMessageNotification .builder ()
660+ .level (McpSchema .LoggingLevel .INFO )
661+ .data ("x" .repeat (64 * 1024 ))
662+ .build ()))
663+ .then (Mono .<McpSchema .CallToolResult >never ());
664+ })
635665 .build ())
636666 .build ();
637667 var sessionId = initializeSession (httpClient );
@@ -640,18 +670,7 @@ void sessionIsEvictedWhenTheClientAbortsAResponseStream() {
640670 // stream for as long as the call is in flight
641671 var responseStream = postToolCall (httpClient , sessionId , "hangs" );
642672
643- await ().atMost (Duration .ofSeconds (5 ))
644- .pollDelay (Duration .ZERO )
645- .pollInterval (Duration .ofMillis (10 ))
646- .untilAsserted (() -> {
647- // We do this in a loop for the wire-side of the connection - data has
648- // to be buffered then flushed
649-
650- // Advance time so the tool emits some data
651- virtualTime .advanceTimeBy (toolEmissionInterval );
652- // Verify the data is received
653- assertThat (responseStream .events ()).anyMatch (line -> line .contains ("notifications/message" ));
654- });
673+ await ().atMost (Duration .ofSeconds (5 )).pollInterval (Duration .ofMillis (20 )).untilTrue (toolCalled );
655674 virtualTime .advanceTimeBy (SESSION_SWEEP_INTERVAL .multipliedBy (2 ));
656675 assertThat (postNotification (httpClient , sessionId )).as ("Session with POST stream is active" )
657676 .isEqualTo (HttpServletResponse .SC_ACCEPTED );
@@ -781,8 +800,7 @@ record StreamResponse(CompletableFuture<Void> streamFuture, Queue<String> events
781800 AtomicReference <InputStream > streamRef ) {
782801
783802 void closeStream () {
784- // Close listening stream. We retry a few times in case the stream was not
785- // established on the first try
803+ // streamRef is set asynchronously, once the headers arrive
786804 await ().pollDelay (Duration .ZERO ).atMost (Duration .ofSeconds (1 )).until (() -> {
787805 var stream = streamRef .get ();
788806 if (stream != null ) {
0 commit comments