@@ -425,14 +425,32 @@ protected void doGet(HttpServletRequest request, HttpServletResponse response)
 
 		McpTransportContext transportContext = this.contextExtractor.extract(request);
 
-		try {
-			HttpServletResponseUtils.prepareSseResponse(response);
+		// Before getWriter(): the character encoding is ignored once the writer is taken
+		HttpServletResponseUtils.prepareSseResponse(response);
 
-			AsyncContext asyncContext = request.startAsync();
+		PrintWriter writer;
+		AsyncContext asyncContext;
+		try {
+			writer = response.getWriter();
+			asyncContext = request.startAsync();
 			asyncContext.setTimeout(0);
+		}
+		catch (Exception e) {
+			// A deployment error, such as a servlet or filter not supporting async.
+			// Nothing has been sent and async has not started, so an error status can
+			// still be returned
+			logger.error("Failed to start the GET stream for session {}: {}", sessionId, e.getMessage());
+			response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+			return;
+		}
 
-			HttpServletStreamableMcpSessionTransport sessionTransport = new HttpServletStreamableMcpSessionTransport(
-					sessionId, asyncContext, response.getWriter());
+		// From here on the headers may already be sent: a failure can only end the stream
+		HttpServletStreamableMcpSessionTransport sessionTransport = new HttpServletStreamableMcpSessionTransport(
+				sessionId, asyncContext, writer);
+		try {
+			// Send the status line and headers now: the listening stream may stay idle
+			// for a long time, and clients wait for the headers before reading events
+			response.flushBuffer();
 
 			// Replay the messages the client missed while its stream was broken
 			String lastEventId = request.getHeader(HttpHeaders.LAST_EVENT_ID);
@@ -450,9 +468,14 @@ protected void doGet(HttpServletRequest request, HttpServletResponse response)
 
 			registerAsyncLifecycle(asyncContext, sessionId, listeningStream::releaseTransport);
 		}
+		catch (IOException e) {
+			// Only flushing the headers throws it: the client is gone
+			logger.debug("Failed to send the GET stream headers for session {}: {}", sessionId, e.getMessage());
+			sessionTransport.close();
+		}
 		catch (Exception e) {
 			logger.error("Failed to handle GET request for session {}: {}", sessionId, e.getMessage());
-			response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+			sessionTransport.close();
 		}
 	}
 
@@ -597,28 +620,57 @@ else if (message instanceof McpSchema.JSONRPCNotification jsonrpcNotification) {
 				response.setStatus(HttpServletResponse.SC_ACCEPTED);
 			}
 			else if (message instanceof McpSchema.JSONRPCRequest jsonrpcRequest) {
-				// For streaming responses, we need to return SSE
+				// For streaming responses, we need to return SSE. Before getWriter(): the
+				// character encoding is ignored once the writer is taken
 				HttpServletResponseUtils.prepareSseResponse(response);
 
-				AsyncContext asyncContext = request.startAsync();
-				asyncContext.setTimeout(0);
+				PrintWriter writer;
+				AsyncContext asyncContext;
+				try {
+					writer = response.getWriter();
+					asyncContext = request.startAsync();
+					asyncContext.setTimeout(0);
+				}
+				catch (Exception e) {
+					// A deployment error, such as a servlet or filter not supporting
+					// async. Nothing has been sent and async has not started, so an error
+					// status can still be returned
+					logger.error("Failed to start the request stream for session {}: {}", sessionId, e.getMessage());
+					response.sendError(HttpServletResponse.SC_INTERNAL_SERVER_ERROR);
+					return;
+				}
 
+				// From here on the headers may already be sent: a failure can only end
+				// the stream
 				HttpServletStreamableMcpSessionTransport sessionTransport = new HttpServletStreamableMcpSessionTransport(
-						sessionId, asyncContext, response.getWriter());
-
-				// The listener is given the stream rather than its transport, so that the
-				// end of the connection detaches the stream from the session instead of
-				// only dropping the socket: a stream outliving its connection keeps the
-				// session looking busy and spares it from the sweeper
-				McpStreamableServerSession.McpStreamableServerSessionStream responseStream = session
-					.responseStream(sessionTransport);
-				registerAsyncLifecycle(asyncContext, sessionId, responseStream::releaseTransport);
-
+						sessionId, asyncContext, writer);
 				try {
+					// Send the status line and headers now: the request may take a long
+					// time to answer, and clients wait for the headers before reading
+					// events. Flush before the stream is registered with the session, so
+					// that no other thread can close it while the headers are written
+					response.flushBuffer();
+
+					// The listener is given the stream rather than its transport, so that
+					// the end of the connection detaches the stream from the session
+					// instead of only dropping the socket: a stream outliving its
+					// connection keeps the session looking busy and spares it from the
+					// sweeper
+					McpStreamableServerSession.McpStreamableServerSessionStream responseStream = session
+						.responseStream(sessionTransport);
+					registerAsyncLifecycle(asyncContext, sessionId, responseStream::releaseTransport);
+
 					responseStream.handle(jsonrpcRequest)
 						.contextWrite(ctx -> ctx.put(McpTransportContext.KEY, transportContext))
 						.block();
 				}
+				catch (IOException e) {
+					// Only flushing the headers throws it: the client is gone, and the
+					// request is not handled
+					logger.debug("Failed to send the request stream headers for session {}: {}", sessionId,
+							e.getMessage());
+					sessionTransport.close();
+				}
 				catch (Exception e) {
 					logger.error("Failed to handle request stream: {}", e.getMessage());
 					// The transport may already have completed the async context, when
 
@@ -19,6 +19,7 @@
 import java.util.Queue;
 import java.util.concurrent.CompletableFuture;
 import java.util.concurrent.ConcurrentLinkedQueue;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicBoolean;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.function.Function;
@@ -39,6 +40,7 @@
 import io.modelcontextprotocol.spec.HttpHeaders;
 import io.modelcontextprotocol.spec.McpSchema;
 import io.modelcontextprotocol.util.KeepAliveScheduler;
+import io.modelcontextprotocol.util.ToolsUtils;
 import jakarta.servlet.http.HttpServletRequest;
 import jakarta.servlet.http.HttpServletResponse;
 import org.apache.catalina.LifecycleException;
@@ -55,6 +57,7 @@
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
+import reactor.core.publisher.Sinks;
 import reactor.core.scheduler.Schedulers;
 import reactor.test.StepVerifier;
 import reactor.test.scheduler.VirtualTimeScheduler;
@@ -205,8 +208,9 @@ void testMissingHandlerReturnsMethodNotFoundError() {
 	}
 
 	@Test
-	void listeningStreamHasStreamingHeaders() throws Exception {
-		prepareAsyncServerBuilder().serverInfo("test-server", "1.0.0").build();
+	void listeningStreamSendsHeadersBeforeFirstEvent() throws Exception {
+		// No keep-alive, so the server never writes to the stream
+		withTransportProvider(null, null);
 		var sessionId = initializeSession(httpClient);
 
 		var get = HttpRequest.newBuilder()
@@ -216,8 +220,10 @@ void listeningStreamHasStreamingHeaders() throws Exception {
 			.GET()
 			.build();
 
-		var response = httpClient.send(get, HttpResponse.BodyHandlers.ofInputStream());
+		// The response completes as soon as the headers are received
+		var response = httpClient.sendAsync(get, HttpResponse.BodyHandlers.ofInputStream()).get(5, TimeUnit.SECONDS);
 		try {
+			assertThat(response.statusCode()).isEqualTo(HttpServletResponse.SC_OK);
 			assertSseHeaders(response);
 		}
 		finally {
@@ -226,17 +232,29 @@ void listeningStreamHasStreamingHeaders() throws Exception {
 	}
 
 	@Test
-	void toolCallSseResponseHasStreamingHeaders() throws Exception {
-		prepareAsyncServerBuilder().serverInfo("test-server", "1.0.0")
-			.capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
+	void toolCallSseResponseSendsHeadersBeforeResult() throws Exception {
+		mcpServerTransportProvider.closeGracefully().block();
+		mcpServerTransportProvider = HttpServletStreamableServerTransportProvider.builder()
+			.contextExtractor(TEST_CONTEXT_EXTRACTOR)
+			.mcpEndpoint(MESSAGE_ENDPOINT)
+			// No keep-alive, so the server writes nothing until the tool returns
+			.keepAliveInterval(null)
+			// no sweeping: the session must survive every keep-alive round
+			.sessionSweepInterval(null)
+			.build();
+
+		MCP_SERVLET.setDelegate(mcpServerTransportProvider);
+
+		// Custom server with a tool that hangs
+		Sinks.One<McpSchema.CallToolResult> toolResult = Sinks.one();
+		prepareAsyncServerBuilder().capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
 			.tools(McpServerFeatures.AsyncToolSpecification.builder()
-				.tool(McpSchema.Tool.builder("echo", EMPTY_JSON_SCHEMA).description("returns immediately").build())
-				.callHandler((exchange,
-						request) -> Mono.just(McpSchema.CallToolResult.builder()
-							.content(List.of(McpSchema.TextContent.builder("ok").build()))
-							.isError(false)
-							.build()))
+				.tool(McpSchema.Tool.builder("slow", ToolsUtils.EMPTY_JSON_SCHEMA)
+					.description("returns when released")
+					.build())
+				.callHandler((exchange, request) -> toolResult.asMono())
 				.build())
+			.serverInfo("test-server", "1.0.0")
 			.build();
 		var sessionId = initializeSession(httpClient);
 
@@ -247,15 +265,27 @@ void toolCallSseResponseHasStreamingHeaders() throws Exception {
 			.header(HttpHeaders.MCP_SESSION_ID, sessionId)
 			.POST(HttpRequest.BodyPublishers
 				.ofString("{\"jsonrpc\":\"2.0\",\"id\":\"call-1\",\"method\":\"tools/call\","
-						+ "\"params\":{\"name\":\"echo\",\"arguments\":{}}}"))
+						+ "\"params\":{\"name\":\"slow\",\"arguments\":{}}}"))
 			.build();
 
-		var response = httpClient.send(post, HttpResponse.BodyHandlers.ofInputStream());
 		try {
-			assertSseHeaders(response);
+			// The response completes as soon as the headers are received
+			var response = httpClient.sendAsync(post, HttpResponse.BodyHandlers.ofInputStream())
+				.get(5, TimeUnit.SECONDS);
+			try {
+				assertThat(response.statusCode()).isEqualTo(HttpServletResponse.SC_OK);
+				assertSseHeaders(response);
+			}
+			finally {
+				response.body().close();
+			}
 		}
 		finally {
-			response.body().close();
+			// Release the Tomcat thread blocked in doPost until the tool returns
+			toolResult.tryEmitValue(McpSchema.CallToolResult.builder()
+				.content(List.of(McpSchema.TextContent.builder("done").build()))
+				.isError(false)
+				.build());
 		}
 	}
 
@@ -563,10 +593,6 @@ void sessionEvictionAfterReleasingStream() {
 			var sessionId = initializeSession(httpClient);
 			var clientStream = openListeningStream(httpClient, sessionId, null);
 			awaitClientStreamEstablished();
-			// "prep" the client so we can close the stream by sending data: the
-			// subscription
-			// in the clientStream is only present when the client has received data
-			awaitNotification(clientStream.events());
 			virtualTime.advanceTimeBy(SESSION_SWEEP_INTERVAL.multipliedBy(2));
 			assertThat(postNotification(httpClient, sessionId)).as("Session should be active when a stream is open")
 				.isEqualTo(HttpServletResponse.SC_ACCEPTED);
@@ -621,17 +647,22 @@ void sessionIsEvictedWhenTheClientAbortsAResponseStream() {
 		try {
 			withTransportProvider(null, SESSION_SWEEP_INTERVAL);
 			var toolEmissionInterval = Duration.ofMillis(10);
+			var toolCalled = new AtomicBoolean();
 			prepareAsyncServerBuilder().serverInfo("test-server", "1.0.0")
 				.capabilities(McpSchema.ServerCapabilities.builder().tools(true).build())
 				.tools(McpServerFeatures.AsyncToolSpecification.builder()
 					.tool(McpSchema.Tool.builder("hangs", EMPTY_JSON_SCHEMA).description("never returns").build())
-					.callHandler((exchange, request) -> Flux
-						.interval(toolEmissionInterval, toolEmissionInterval, Schedulers.newSingle("test-tool"))
-						.flatMap(tick -> exchange.loggingNotification(McpSchema.LoggingMessageNotification.builder()
-							.level(McpSchema.LoggingLevel.INFO)
-							.data("x".repeat(64 * 1024))
-							.build()))
-						.then(Mono.<McpSchema.CallToolResult>never()))
+					.callHandler((exchange, request) -> {
+						toolCalled.set(true);
+						// Write until the server notices the client is gone
+						return Flux
+							.interval(toolEmissionInterval, toolEmissionInterval, Schedulers.newSingle("test-tool"))
+							.flatMap(tick -> exchange.loggingNotification(McpSchema.LoggingMessageNotification.builder()
+								.level(McpSchema.LoggingLevel.INFO)
+								.data("x".repeat(64 * 1024))
+								.build()))
+							.then(Mono.<McpSchema.CallToolResult>never());
+					})
 					.build())
 				.build();
 			var sessionId = initializeSession(httpClient);
@@ -640,18 +671,7 @@ void sessionIsEvictedWhenTheClientAbortsAResponseStream() {
 			// stream for as long as the call is in flight
 			var responseStream = postToolCall(httpClient, sessionId, "hangs");
 
-			await().atMost(Duration.ofSeconds(5))
-				.pollDelay(Duration.ZERO)
-				.pollInterval(Duration.ofMillis(10))
-				.untilAsserted(() -> {
-					// We do this in a loop for the wire-side of the connection - data has
-					// to be buffered then flushed
-
-					// Advance time so the tool emits some data
-					virtualTime.advanceTimeBy(toolEmissionInterval);
-					// Verify the data is received
-					assertThat(responseStream.events()).anyMatch(line -> line.contains("notifications/message"));
-				});
+			await().atMost(Duration.ofSeconds(5)).pollInterval(Duration.ofMillis(20)).untilTrue(toolCalled);
 			virtualTime.advanceTimeBy(SESSION_SWEEP_INTERVAL.multipliedBy(2));
 			assertThat(postNotification(httpClient, sessionId)).as("Session with POST stream is active")
 				.isEqualTo(HttpServletResponse.SC_ACCEPTED);
@@ -781,8 +801,8 @@ record StreamResponse(CompletableFuture<Void> streamFuture, Queue<String> events
 			AtomicReference<InputStream> streamRef) {
 
 		void closeStream() {
-			// Close listening stream. We retry a few times in case the stream was not
-			// established on the first try
+			// Close the stream. The response headers arrive asynchronously, so wait
+			// until the client has received them
 			await().pollDelay(Duration.ZERO).atMost(Duration.ofSeconds(1)).until(() -> {
 				var stream = streamRef.get();
 				if (stream != null) {