Minor fix on stream primer

Signed-off-by: Daniel Garnier-Moiroux <git@garnier.wf>

Author: Kehrlann

mcp-core/src/main/java/io/modelcontextprotocol/client/transport/HttpClientSseClientTransport.java

@@ -431,7 +431,13 @@ public Mono<Void> connect(Function<Mono<JSONRPCMessage>, Mono<JSONRPCMessage>> h
 							}
 						}
 						else if (MESSAGE_EVENT_TYPE.equals(sseEvent.event())) {
-							JSONRPCMessage message = McpSchema.deserializeJsonRpcMessage(jsonMapper, sseEvent.data());
+							String data = sseEvent.data();
+							if (data == null || data.isBlank()) {
+								logger.debug("Skipping SSE event with empty data (stream primer)");
+								sink.success();
+								return Flux.<McpSchema.JSONRPCMessage>empty();
+							}
+							JSONRPCMessage message = McpSchema.deserializeJsonRpcMessage(jsonMapper, data);
 							sink.success();
 							return Flux.just(message);
 						}

mcp-core/src/main/java/io/modelcontextprotocol/client/transport/ResponseSubscribers.java

@@ -355,7 +355,8 @@ private int indexOfLineTerminator(int from) {
 	 * Stateful SSE line parser. Accumulates {@code data:}, {@code id:} and {@code event:}
 	 * fields until a blank line dispatches the event. Per the SSE spec, {@code id} and
 	 * {@code event} persist across events until re-set; {@code data} is reset after each
-	 * dispatch.
+	 * dispatch, and a blank line dispatches only when a {@code data:} field was seen,
+	 * whether or not it carried a value.
 	 */
 	static final class SseEventParser {
 
@@ -390,18 +391,19 @@ Optional<SseEvent> feed(String line) {
 				return Optional.of(result);
 			}
 			if (line.startsWith("data:")) {
-				String rest = line.substring(5);
-				if (!rest.isEmpty()) {
-					String value = rest.trim();
-					// Measured before appending, so that an event carrying exactly
-					// maxSize of data is accepted: the trailing separator below is
-					// stripped again before the event is emitted.
-					if (data.length() + value.length() > this.maxSize) {
-						throw new McpTransportException(
-								"Inbound SSE event exceeds the maximum allowed size of " + this.maxSize + " bytes");
-					}
-					data.append(value).append('\n');
+				// Every data field appends its value followed by a separator, so a
+				// valueless `data:` line still marks the event as carrying data and gets
+				// dispatched with empty data. Servers send such an event to prime a
+				// stream, and dropping it leaves the request it answers hanging.
+				String value = line.substring(5).trim();
+				// Measured before appending, so that an event carrying exactly
+				// maxSize of data is accepted: the trailing separator below is
+				// stripped again before the event is emitted.
+				if (data.length() + value.length() > this.maxSize) {
+					throw new McpTransportException(
+							"Inbound SSE event exceeds the maximum allowed size of " + this.maxSize + " bytes");
 				}
+				data.append(value).append('\n');
 			}
 			else if (line.startsWith("id:")) {
 				String rest = line.substring(3);

mcp-core/src/test/java/io/modelcontextprotocol/client/transport/SseEventParserTests.java

@@ -108,13 +108,42 @@ void unknownFieldThrowsMcpTransportException() {
 	}
 
 	@Test
-	void dataFieldWithEmptyValueIsIgnored() {
-		// preserves the pre-refactor regex behavior where `^data:(.+)$` required at
-		// least one char after the colon — a lone `data:` line contributes nothing.
+	void dataFieldWithEmptyValueStillDispatchesAnEvent() {
+		// Per the SSE spec a data field appends its value plus a separator, so a lone
+		// `data:` line leaves the buffer non-empty and the event is dispatched carrying
+		// empty data. Servers send exactly this to prime a stream, and dropping it leaves
+		// the request the stream answers hanging.
 		SseEventParser p = new SseEventParser(Integer.MAX_VALUE);
 		assertThat(p.feed("data:")).isEmpty();
-		// no pending data → blank line dispatches nothing
+		Optional<SseEvent> event = p.feed("");
+		assertThat(event).isPresent();
+		assertThat(event.get().data()).isEmpty();
+	}
+
+	@Test
+	void dataFieldWithOnlyASpaceIsEquivalentToNoValue() {
+		SseEventParser p = new SseEventParser(Integer.MAX_VALUE);
+		assertThat(p.feed("data: ")).isEmpty();
+		Optional<SseEvent> event = p.feed("");
+		assertThat(event).isPresent();
+		assertThat(event.get().data()).isEmpty();
+	}
+
+	@Test
+	void blankLineWithNoDataFieldDispatchesNothing() {
+		// `event:` alone leaves the data buffer empty, which per the spec is not an event
+		SseEventParser p = new SseEventParser(Integer.MAX_VALUE);
+		assertThat(p.feed("event: message")).isEmpty();
 		assertThat(p.feed("")).isEmpty();
 	}
 
+	@Test
+	void valuelessDataFieldIsDispatchedOnFlush() {
+		SseEventParser p = new SseEventParser(Integer.MAX_VALUE);
+		assertThat(p.feed("data:")).isEmpty();
+		Optional<SseEvent> flushed = p.flush();
+		assertThat(flushed).isPresent();
+		assertThat(flushed.get().data()).isEmpty();
+	}
+
 }

…eHttpTransportEmptyJsonResponseTest.java …ableHttpTransportEmptyResponseTests.javamcp-test/src/test/java/io/modelcontextprotocol/client/transport/HttpClientStreamableHttpTransportEmptyJsonResponseTest.java renamed to mcp-test/src/test/java/io/modelcontextprotocol/client/transport/HttpClientStreamableHttpTransportEmptyResponseTests.java mcp-test/src/test/java/io/modelcontextprotocol/client/transport/HttpClientStreamableHttpTransportEmptyJsonResponseTest.java renamed to mcp-test/src/test/java/io/modelcontextprotocol/client/transport/HttpClientStreamableHttpTransportEmptyResponseTests.java

@@ -11,9 +11,12 @@
 import static org.mockito.Mockito.verify;
 
 import java.io.IOException;
+import java.io.OutputStream;
 import java.net.InetSocketAddress;
 import java.net.URI;
 import java.net.URISyntaxException;
+import java.nio.charset.StandardCharsets;
+import java.util.Map;
 
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.BeforeAll;
@@ -29,18 +32,33 @@
 import reactor.test.StepVerifier;
 
 /**
- * Handles emplty application/json response with 200 OK status code.
+ * Handles 200 OK responses that carry no usable body, either as an empty application/json
+ * document or as a text/event-stream containing nothing but a stream primer.
  *
  * @author codezkk
  */
-public class HttpClientStreamableHttpTransportEmptyJsonResponseTest {
+public class HttpClientStreamableHttpTransportEmptyResponseTests {
 
 	static int PORT = TomcatTestUtil.findAvailablePort();
 
 	static String host = "http://localhost:" + PORT;
 
 	static HttpServer server;
 
+	/**
+	 * An SSE event with an {@code event:} field but no data, which some servers send to
+	 * open the response stream before any JSON-RPC payload is available. Note the
+	 * valueless {@code data:} field: per the SSE spec this is identical to {@code data: }
+	 * with a trailing space.
+	 * @see <a href=
+	 * "https://github.com/modelcontextprotocol/modelcontextprotocol/pull/1699">SEP-1699</a>
+	 */
+	private static final byte[] SSE_PRIMER = """
+			event: message
+			data:
+
+			""".getBytes(StandardCharsets.UTF_8);
+
 	@BeforeAll
 	static void startContainer() throws IOException {
 
@@ -53,6 +71,24 @@ static void startContainer() throws IOException {
 			exchange.close();
 		});
 
+		// 200 OK text/event-stream carrying only a primer, for POSTs. The
+		// server-initiated GET stream is refused so that the transport falls back to
+		// request-response mode and the POST is the only thing under test.
+		server.createContext("/mcp-sse-primer", exchange -> {
+			try (exchange) {
+				if (!"POST".equals(exchange.getRequestMethod())) {
+					exchange.sendResponseHeaders(405, -1);
+					return;
+				}
+				exchange.getRequestBody().readAllBytes();
+				exchange.getResponseHeaders().set("Content-Type", "text/event-stream");
+				exchange.sendResponseHeaders(200, SSE_PRIMER.length);
+				try (OutputStream out = exchange.getResponseBody()) {
+					out.write(SSE_PRIMER);
+				}
+			}
+		});
+
 		server.setExecutor(null);
 		server.start();
 	}
@@ -91,4 +127,25 @@ void testNotificationInitialized() throws URISyntaxException {
 
 	}
 
+	/**
+	 * A POST answered with {@code 200 text/event-stream} whose body holds only a stream
+	 * primer must still complete, because the primer tells the client the stream is live
+	 * and the message has been accepted. The primer's {@code data:} field carries no
+	 * value, so this only holds as long as such a field still produces an event: a parser
+	 * that drops it leaves no event to fire the transport's first-message callback, and
+	 * {@code sendMessage} then never completes at all.
+	 */
+	@Test
+	@Timeout(5)
+	void testNotificationAnsweredWithSsePrimerOnly() {
+
+		var transport = HttpClientStreamableHttpTransport.builder(host).endpoint("/mcp-sse-primer").build();
+
+		var testMessage = new McpSchema.JSONRPCNotification(McpSchema.JSONRPC_VERSION, "notifications/initialized",
+				Map.of());
+
+		StepVerifier.create(transport.sendMessage(testMessage)).verifyComplete();
+
+	}
+
 }