refactor: introduce session-based architecture for MCP server (#31)

This commit introduces a major refactoring of the MCP Java SDK to implement a session-based architecture
for server-side implementations. The changes improve the SDK's ability to handle multiple concurrent
client connections and provide an API better aligned with the MCP specification.

Key changes:

- Introduce McpServerTransportProvider interface to manage client connections
- Rename ClientMcpTransport to McpClientTransport and ServerMcpTransport to McpServerTransport
- Add exchange objects (McpAsyncServerExchange, McpSyncServerExchange) for client interaction
- Update handler signatures to include exchange parameter: (args) -> result to (exchange, args) -> result
- Rename Registration classes to Specification classes
- Update method names (e.g., rootsChangeConsumers to rootsChangeHandlers)
- Deprecate old interfaces and classes for removal in 0.9.0
- Add migration guide (migration-0.8.0.md)

Resolves #9, #15

Co-authored-by: Christian Tzolov <christian.tzolov@broadcom.com>
Signed-off-by: Christian Tzolov <christian.tzolov@broadcom.com>

mcp-spring/mcp-spring-webflux/src/main/java/io/modelcontextprotocol/client/transport/WebFluxSseClientTransport.java

@@ -9,7 +9,7 @@ import java.util.function.Function;
 
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import io.modelcontextprotocol.spec.ClientMcpTransport;
+import io.modelcontextprotocol.spec.McpClientTransport;
 import io.modelcontextprotocol.spec.McpError;
 import io.modelcontextprotocol.spec.McpSchema;
 import io.modelcontextprotocol.spec.McpSchema.JSONRPCMessage;
@@ -58,7 +58,7 @@ import org.springframework.web.reactive.function.client.WebClient;
  * "https://spec.modelcontextprotocol.io/specification/basic/transports/#http-with-sse">MCP
  * HTTP with SSE Transport Specification</a>
  */
-public class WebFluxSseClientTransport implements ClientMcpTransport {
+public class WebFluxSseClientTransport implements McpClientTransport {
 
 	private static final Logger logger = LoggerFactory.getLogger(WebFluxSseClientTransport.class);
 

mcp-spring/mcp-spring-webflux/src/main/java/io/modelcontextprotocol/server/transport/WebFluxSseServerTransport.java

@@ -60,7 +60,10 @@ import org.springframework.web.reactive.function.server.ServerResponse;
  * @author Alexandros Pappas
  * @see ServerMcpTransport
  * @see ServerSentEvent
+ * @deprecated This class will be removed in 0.9.0. Use
+ * {@link WebFluxSseServerTransportProvider}.
  */
+@Deprecated
 public class WebFluxSseServerTransport implements ServerMcpTransport {
 
 	private static final Logger logger = LoggerFactory.getLogger(WebFluxSseServerTransport.class);
@@ -182,16 +185,16 @@ public class WebFluxSseServerTransport implements ServerMcpTransport {
 			try {// @formatter:off
 				String jsonText = objectMapper.writeValueAsString(message);
 				ServerSentEvent<Object> event = ServerSentEvent.builder()
-					.event(MESSAGE_EVENT_TYPE)
-					.data(jsonText)
-					.build();
+				                                               .event(MESSAGE_EVENT_TYPE)
+				                                               .data(jsonText)
+				                                               .build();
 
 				logger.debug("Attempting to broadcast message to {} active sessions", sessions.size());
 
 				List<String> failedSessions = sessions.values().stream()
-					.filter(session -> session.messageSink.tryEmitNext(event).isFailure())
-					.map(session -> session.id)
-					.toList();
+				                                      .filter(session -> session.messageSink.tryEmitNext(event).isFailure())
+				                                      .map(session -> session.id)
+				                                      .toList();
 
 				if (failedSessions.isEmpty()) {
 					logger.debug("Successfully broadcast message to all sessions");
@@ -407,4 +410,4 @@ public class WebFluxSseServerTransport implements ServerMcpTransport {
 
 	}
 
-}
+}

mcp-spring/mcp-spring-webflux/src/main/java/io/modelcontextprotocol/server/transport/WebFluxSseServerTransportProvider.java

@@ -0,0 +1,351 @@
+package io.modelcontextprotocol.server.transport;
+
+import java.io.IOException;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.spec.McpError;
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpServerTransport;
+import io.modelcontextprotocol.spec.McpServerTransportProvider;
+import io.modelcontextprotocol.spec.McpServerSession;
+import io.modelcontextprotocol.spec.ServerMcpTransport;
+import io.modelcontextprotocol.util.Assert;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.Exceptions;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.FluxSink;
+import reactor.core.publisher.Mono;
+import reactor.core.publisher.Sinks;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.http.MediaType;
+import org.springframework.http.codec.ServerSentEvent;
+import org.springframework.web.reactive.function.server.RouterFunction;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+import org.springframework.web.reactive.function.server.ServerRequest;
+import org.springframework.web.reactive.function.server.ServerResponse;
+
+/**
+ * Server-side implementation of the MCP (Model Context Protocol) HTTP transport using
+ * Server-Sent Events (SSE). This implementation provides a bidirectional communication
+ * channel between MCP clients and servers using HTTP POST for client-to-server messages
+ * and SSE for server-to-client messages.
+ *
+ * <p>
+ * Key features:
+ * <ul>
+ * <li>Implements the {@link McpServerTransportProvider} interface that allows managing
+ * {@link McpServerSession} instances and enabling their communication with the
+ * {@link McpServerTransport} abstraction.</li>
+ * <li>Uses WebFlux for non-blocking request handling and SSE support</li>
+ * <li>Maintains client sessions for reliable message delivery</li>
+ * <li>Supports graceful shutdown with session cleanup</li>
+ * <li>Thread-safe message broadcasting to multiple clients</li>
+ * </ul>
+ *
+ * <p>
+ * The transport sets up two main endpoints:
+ * <ul>
+ * <li>SSE endpoint (/sse) - For establishing SSE connections with clients</li>
+ * <li>Message endpoint (configurable) - For receiving JSON-RPC messages from clients</li>
+ * </ul>
+ *
+ * <p>
+ * This implementation is thread-safe and can handle multiple concurrent client
+ * connections. It uses {@link ConcurrentHashMap} for session management and Project
+ * Reactor's non-blocking APIs for message processing and delivery.
+ *
+ * @author Christian Tzolov
+ * @author Alexandros Pappas
+ * @author Dariusz Jędrzejczyk
+ * @see McpServerTransport
+ * @see ServerSentEvent
+ */
+public class WebFluxSseServerTransportProvider implements McpServerTransportProvider {
+
+	private static final Logger logger = LoggerFactory.getLogger(WebFluxSseServerTransportProvider.class);
+
+	/**
+	 * Event type for JSON-RPC messages sent through the SSE connection.
+	 */
+	public static final String MESSAGE_EVENT_TYPE = "message";
+
+	/**
+	 * Event type for sending the message endpoint URI to clients.
+	 */
+	public static final String ENDPOINT_EVENT_TYPE = "endpoint";
+
+	/**
+	 * Default SSE endpoint path as specified by the MCP transport specification.
+	 */
+	public static final String DEFAULT_SSE_ENDPOINT = "/sse";
+
+	private final ObjectMapper objectMapper;
+
+	private final String messageEndpoint;
+
+	private final String sseEndpoint;
+
+	private final RouterFunction<?> routerFunction;
+
+	private McpServerSession.Factory sessionFactory;
+
+	/**
+	 * Map of active client sessions, keyed by session ID.
+	 */
+	private final ConcurrentHashMap<String, McpServerSession> sessions = new ConcurrentHashMap<>();
+
+	/**
+	 * Flag indicating if the transport is shutting down.
+	 */
+	private volatile boolean isClosing = false;
+
+	/**
+	 * Constructs a new WebFlux SSE server transport provider instance.
+	 * @param objectMapper The ObjectMapper to use for JSON serialization/deserialization
+	 * of MCP messages. Must not be null.
+	 * @param messageEndpoint The endpoint URI where clients should send their JSON-RPC
+	 * messages. This endpoint will be communicated to clients during SSE connection
+	 * setup. Must not be null.
+	 * @throws IllegalArgumentException if either parameter is null
+	 */
+	public WebFluxSseServerTransportProvider(ObjectMapper objectMapper, String messageEndpoint, String sseEndpoint) {
+		Assert.notNull(objectMapper, "ObjectMapper must not be null");
+		Assert.notNull(messageEndpoint, "Message endpoint must not be null");
+		Assert.notNull(sseEndpoint, "SSE endpoint must not be null");
+
+		this.objectMapper = objectMapper;
+		this.messageEndpoint = messageEndpoint;
+		this.sseEndpoint = sseEndpoint;
+		this.routerFunction = RouterFunctions.route()
+			.GET(this.sseEndpoint, this::handleSseConnection)
+			.POST(this.messageEndpoint, this::handleMessage)
+			.build();
+	}
+
+	/**
+	 * Constructs a new WebFlux SSE server transport provider instance with the default
+	 * SSE endpoint.
+	 * @param objectMapper The ObjectMapper to use for JSON serialization/deserialization
+	 * of MCP messages. Must not be null.
+	 * @param messageEndpoint The endpoint URI where clients should send their JSON-RPC
+	 * messages. This endpoint will be communicated to clients during SSE connection
+	 * setup. Must not be null.
+	 * @throws IllegalArgumentException if either parameter is null
+	 */
+	public WebFluxSseServerTransportProvider(ObjectMapper objectMapper, String messageEndpoint) {
+		this(objectMapper, messageEndpoint, DEFAULT_SSE_ENDPOINT);
+	}
+
+	@Override
+	public void setSessionFactory(McpServerSession.Factory sessionFactory) {
+		this.sessionFactory = sessionFactory;
+	}
+
+	/**
+	 * Broadcasts a JSON-RPC message to all connected clients through their SSE
+	 * connections. The message is serialized to JSON and sent as a server-sent event to
+	 * each active session.
+	 *
+	 * <p>
+	 * The method:
+	 * <ul>
+	 * <li>Serializes the message to JSON</li>
+	 * <li>Creates a server-sent event with the message data</li>
+	 * <li>Attempts to send the event to all active sessions</li>
+	 * <li>Tracks and reports any delivery failures</li>
+	 * </ul>
+	 * @param method The JSON-RPC method to send to clients
+	 * @param params The method parameters to send to clients
+	 * @return A Mono that completes when the message has been sent to all sessions, or
+	 * errors if any session fails to receive the message
+	 */
+	@Override
+	public Mono<Void> notifyClients(String method, Map<String, Object> params) {
+		if (sessions.isEmpty()) {
+			logger.debug("No active sessions to broadcast message to");
+			return Mono.empty();
+		}
+
+		logger.debug("Attempting to broadcast message to {} active sessions", sessions.size());
+
+		return Flux.fromStream(sessions.values().stream())
+			.flatMap(session -> session.sendNotification(method, params)
+				.doOnError(e -> logger.error("Failed to " + "send message to session " + "{}: {}", session.getId(),
+						e.getMessage()))
+				.onErrorComplete())
+			.then();
+	}
+
+	// FIXME: This javadoc makes claims about using isClosing flag but it's not actually
+	// doing that.
+	/**
+	 * Initiates a graceful shutdown of all the sessions. This method ensures all active
+	 * sessions are properly closed and cleaned up.
+	 *
+	 * <p>
+	 * The shutdown process:
+	 * <ul>
+	 * <li>Marks the transport as closing to prevent new connections</li>
+	 * <li>Closes each active session</li>
+	 * <li>Removes closed sessions from the sessions map</li>
+	 * <li>Times out after 5 seconds if shutdown takes too long</li>
+	 * </ul>
+	 * @return A Mono that completes when all sessions have been closed
+	 */
+	@Override
+	public Mono<Void> closeGracefully() {
+		return Flux.fromIterable(sessions.values())
+			.doFirst(() -> logger.debug("Initiating graceful shutdown with {} active sessions", sessions.size()))
+			.flatMap(McpServerSession::closeGracefully)
+			.then();
+	}
+
+	/**
+	 * Returns the WebFlux router function that defines the transport's HTTP endpoints.
+	 * This router function should be integrated into the application's web configuration.
+	 *
+	 * <p>
+	 * The router function defines two endpoints:
+	 * <ul>
+	 * <li>GET {sseEndpoint} - For establishing SSE connections</li>
+	 * <li>POST {messageEndpoint} - For receiving client messages</li>
+	 * </ul>
+	 * @return The configured {@link RouterFunction} for handling HTTP requests
+	 */
+	public RouterFunction<?> getRouterFunction() {
+		return this.routerFunction;
+	}
+
+	/**
+	 * Handles new SSE connection requests from clients. Creates a new session for each
+	 * connection and sets up the SSE event stream.
+	 * @param request The incoming server request
+	 * @return A Mono which emits a response with the SSE event stream
+	 */
+	private Mono<ServerResponse> handleSseConnection(ServerRequest request) {
+		if (isClosing) {
+			return ServerResponse.status(HttpStatus.SERVICE_UNAVAILABLE).bodyValue("Server is shutting down");
+		}
+
+		return ServerResponse.ok()
+			.contentType(MediaType.TEXT_EVENT_STREAM)
+			.body(Flux.<ServerSentEvent<?>>create(sink -> {
+				WebFluxMcpSessionTransport sessionTransport = new WebFluxMcpSessionTransport(sink);
+
+				McpServerSession session = sessionFactory.create(sessionTransport);
+				String sessionId = session.getId();
+
+				logger.debug("Created new SSE connection for session: {}", sessionId);
+				sessions.put(sessionId, session);
+
+				// Send initial endpoint event
+				logger.debug("Sending initial endpoint event to session: {}", sessionId);
+				sink.next(ServerSentEvent.builder()
+					.event(ENDPOINT_EVENT_TYPE)
+					.data(messageEndpoint + "?sessionId=" + sessionId)
+					.build());
+				sink.onCancel(() -> {
+					logger.debug("Session {} cancelled", sessionId);
+					sessions.remove(sessionId);
+				});
+			}), ServerSentEvent.class);
+	}
+
+	/**
+	 * Handles incoming JSON-RPC messages from clients. Deserializes the message and
+	 * processes it through the configured message handler.
+	 *
+	 * <p>
+	 * The handler:
+	 * <ul>
+	 * <li>Deserializes the incoming JSON-RPC message</li>
+	 * <li>Passes it through the message handler chain</li>
+	 * <li>Returns appropriate HTTP responses based on processing results</li>
+	 * <li>Handles various error conditions with appropriate error responses</li>
+	 * </ul>
+	 * @param request The incoming server request containing the JSON-RPC message
+	 * @return A Mono emitting the response indicating the message processing result
+	 */
+	private Mono<ServerResponse> handleMessage(ServerRequest request) {
+		if (isClosing) {
+			return ServerResponse.status(HttpStatus.SERVICE_UNAVAILABLE).bodyValue("Server is shutting down");
+		}
+
+		if (request.queryParam("sessionId").isEmpty()) {
+			return ServerResponse.badRequest().bodyValue(new McpError("Session ID missing in message endpoint"));
+		}
+
+		McpServerSession session = sessions.get(request.queryParam("sessionId").get());
+
+		return request.bodyToMono(String.class).flatMap(body -> {
+			try {
+				McpSchema.JSONRPCMessage message = McpSchema.deserializeJsonRpcMessage(objectMapper, body);
+				return session.handle(message).flatMap(response -> ServerResponse.ok().build()).onErrorResume(error -> {
+					logger.error("Error processing  message: {}", error.getMessage());
+					// TODO: instead of signalling the error, just respond with 200 OK
+					// - the error is signalled on the SSE connection
+					// return ServerResponse.ok().build();
+					return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR)
+						.bodyValue(new McpError(error.getMessage()));
+				});
+			}
+			catch (IllegalArgumentException | IOException e) {
+				logger.error("Failed to deserialize message: {}", e.getMessage());
+				return ServerResponse.badRequest().bodyValue(new McpError("Invalid message format"));
+			}
+		});
+	}
+
+	private class WebFluxMcpSessionTransport implements McpServerTransport {
+
+		private final FluxSink<ServerSentEvent<?>> sink;
+
+		public WebFluxMcpSessionTransport(FluxSink<ServerSentEvent<?>> sink) {
+			this.sink = sink;
+		}
+
+		@Override
+		public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+			return Mono.fromSupplier(() -> {
+				try {
+					return objectMapper.writeValueAsString(message);
+				}
+				catch (IOException e) {
+					throw Exceptions.propagate(e);
+				}
+			}).doOnNext(jsonText -> {
+				ServerSentEvent<Object> event = ServerSentEvent.builder()
+					.event(MESSAGE_EVENT_TYPE)
+					.data(jsonText)
+					.build();
+				sink.next(event);
+			}).doOnError(e -> {
+				// TODO log with sessionid
+				Throwable exception = Exceptions.unwrap(e);
+				sink.error(exception);
+			}).then();
+		}
+
+		@Override
+		public <T> T unmarshalFrom(Object data, TypeReference<T> typeRef) {
+			return objectMapper.convertValue(data, typeRef);
+		}
+
+		@Override
+		public Mono<Void> closeGracefully() {
+			return Mono.fromRunnable(sink::complete);
+		}
+
+		@Override
+		public void close() {
+			sink.complete();
+		}
+
+	}
+
+}

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/WebFluxSseIntegrationTests.java

@@ -16,7 +16,7 @@ import io.modelcontextprotocol.client.transport.HttpClientSseClientTransport;
 import io.modelcontextprotocol.client.transport.WebFluxSseClientTransport;
 import io.modelcontextprotocol.server.McpServer;
 import io.modelcontextprotocol.server.McpServerFeatures;
-import io.modelcontextprotocol.server.transport.WebFluxSseServerTransport;
+import io.modelcontextprotocol.server.transport.WebFluxSseServerTransportProvider;
 import io.modelcontextprotocol.spec.McpError;
 import io.modelcontextprotocol.spec.McpSchema;
 import io.modelcontextprotocol.spec.McpSchema.CallToolResult;
@@ -30,9 +30,9 @@ import io.modelcontextprotocol.spec.McpSchema.ServerCapabilities;
 import io.modelcontextprotocol.spec.McpSchema.Tool;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
-import org.junit.jupiter.api.Test;
 import org.junit.jupiter.params.ParameterizedTest;
 import org.junit.jupiter.params.provider.ValueSource;
+import reactor.core.publisher.Mono;
 import reactor.netty.DisposableServer;
 import reactor.netty.http.server.HttpServer;
 import reactor.test.StepVerifier;
@@ -44,8 +44,8 @@ import org.springframework.web.reactive.function.client.WebClient;
 import org.springframework.web.reactive.function.server.RouterFunctions;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.awaitility.Awaitility.await;
+import static org.mockito.Mockito.mock;
 
 public class WebFluxSseIntegrationTests {
 
@@ -55,16 +55,16 @@ public class WebFluxSseIntegrationTests {
 
 	private DisposableServer httpServer;
 
-	private WebFluxSseServerTransport mcpServerTransport;
+	private WebFluxSseServerTransportProvider mcpServerTransportProvider;
 
 	ConcurrentHashMap<String, McpClient.SyncSpec> clientBulders = new ConcurrentHashMap<>();
 
 	@BeforeEach
 	public void before() {
 
-		this.mcpServerTransport = new WebFluxSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		this.mcpServerTransportProvider = new WebFluxSseServerTransportProvider(new ObjectMapper(), MESSAGE_ENDPOINT);
 
-		HttpHandler httpHandler = RouterFunctions.toHttpHandler(mcpServerTransport.getRouterFunction());
+		HttpHandler httpHandler = RouterFunctions.toHttpHandler(mcpServerTransportProvider.getRouterFunction());
 		ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
 		this.httpServer = HttpServer.create().port(PORT).handle(adapter).bindNow();
 
@@ -84,57 +84,43 @@ public class WebFluxSseIntegrationTests {
 	// ---------------------------------------
 	// Sampling Tests
 	// ---------------------------------------
-	@Test
-	void testCreateMessageWithoutInitialization() {
-		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
-
-		var messages = List
-			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
-		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
-
-		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
-				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
-
-		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
-			assertThat(error).isInstanceOf(McpError.class)
-				.hasMessage("Client must be initialized. Call the initialize method first!");
-		});
-	}
-
 	@ParameterizedTest(name = "{0} : {displayName} ")
 	@ValueSource(strings = { "httpclient", "webflux" })
 	void testCreateMessageWithoutSamplingCapabilities(String clientType) {
 
-		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
-
 		var clientBuilder = clientBulders.get(clientType);
 
-		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0")).build();
+		McpServerFeatures.AsyncToolSpecification tool = new McpServerFeatures.AsyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
 
-		InitializeResult initResult = client.initialize();
-		assertThat(initResult).isNotNull();
+					exchange.createMessage(mock(McpSchema.CreateMessageRequest.class)).block();
 
-		var messages = List
-			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
-		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+					return Mono.just(mock(CallToolResult.class));
+				});
 
-		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
-				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+		McpServer.async(mcpServerTransportProvider).serverInfo("test-server", "1.0.0").tools(tool).build();
 
-		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
-			assertThat(error).isInstanceOf(McpError.class)
+		// Create client without sampling capabilities
+		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample " + "client", "0.0.0")).build();
+
+		assertThat(client.initialize()).isNotNull();
+
+		try {
+			client.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
+		}
+		catch (McpError e) {
+			assertThat(e).isInstanceOf(McpError.class)
 				.hasMessage("Client must be configured with sampling capabilities");
-		});
+		}
 	}
 
 	@ParameterizedTest(name = "{0} : {displayName} ")
 	@ValueSource(strings = { "httpclient", "webflux" })
 	void testCreateMessageSuccess(String clientType) throws InterruptedException {
 
+		// Client
 		var clientBuilder = clientBulders.get(clientType);
 
-		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
-
 		Function<CreateMessageRequest, CreateMessageResult> samplingHandler = request -> {
 			assertThat(request.messages()).hasSize(1);
 			assertThat(request.messages().get(0).content()).isInstanceOf(McpSchema.TextContent.class);
@@ -143,29 +129,54 @@ public class WebFluxSseIntegrationTests {
 					CreateMessageResult.StopReason.STOP_SEQUENCE);
 		};
 
-		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0"))
+		var mcpClient = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0"))
 			.capabilities(ClientCapabilities.builder().sampling().build())
 			.sampling(samplingHandler)
 			.build();
 
-		InitializeResult initResult = client.initialize();
+		// Server
+
+		CallToolResult callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")),
+				null);
+
+		McpServerFeatures.AsyncToolSpecification tool = new McpServerFeatures.AsyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
+
+					var messages = List.of(new McpSchema.SamplingMessage(McpSchema.Role.USER,
+							new McpSchema.TextContent("Test message")));
+					var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+					var craeteMessageRequest = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
+							McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(),
+							Map.of());
+
+					StepVerifier.create(exchange.createMessage(craeteMessageRequest)).consumeNextWith(result -> {
+						assertThat(result).isNotNull();
+						assertThat(result.role()).isEqualTo(Role.USER);
+						assertThat(result.content()).isInstanceOf(McpSchema.TextContent.class);
+						assertThat(((McpSchema.TextContent) result.content()).text()).isEqualTo("Test message");
+						assertThat(result.model()).isEqualTo("MockModelName");
+						assertThat(result.stopReason()).isEqualTo(CreateMessageResult.StopReason.STOP_SEQUENCE);
+					}).verifyComplete();
+
+					return Mono.just(callResponse);
+				});
+
+		var mcpServer = McpServer.async(mcpServerTransportProvider)
+			.serverInfo("test-server", "1.0.0")
+			.tools(tool)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
 		assertThat(initResult).isNotNull();
 
-		var messages = List
-			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
-		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+		CallToolResult response = mcpClient.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
 
-		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
-				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+		assertThat(response).isNotNull();
+		assertThat(response).isEqualTo(callResponse);
 
-		StepVerifier.create(mcpAsyncServer.createMessage(request)).consumeNextWith(result -> {
-			assertThat(result).isNotNull();
-			assertThat(result.role()).isEqualTo(Role.USER);
-			assertThat(result.content()).isInstanceOf(McpSchema.TextContent.class);
-			assertThat(((McpSchema.TextContent) result.content()).text()).isEqualTo("Test message");
-			assertThat(result.model()).isEqualTo("MockModelName");
-			assertThat(result.stopReason()).isEqualTo(CreateMessageResult.StopReason.STOP_SEQUENCE);
-		}).verifyComplete();
+		mcpClient.close();
+		mcpServer.close();
 	}
 
 	// ---------------------------------------
@@ -179,8 +190,8 @@ public class WebFluxSseIntegrationTests {
 		List<Root> roots = List.of(new Root("uri1://", "root1"), new Root("uri2://", "root2"));
 
 		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
@@ -192,8 +203,6 @@ public class WebFluxSseIntegrationTests {
 
 		assertThat(rootsRef.get()).isNull();
 
-		assertThat(mcpServer.listRoots().roots()).containsAll(roots);
-
 		mcpClient.rootsListChangedNotification();
 
 		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
@@ -222,23 +231,33 @@ public class WebFluxSseIntegrationTests {
 	@ParameterizedTest(name = "{0} : {displayName} ")
 	@ValueSource(strings = { "httpclient", "webflux" })
 	void testRootsWithoutCapability(String clientType) {
+
 		var clientBuilder = clientBulders.get(clientType);
 
-		var mcpServer = McpServer.sync(mcpServerTransport).rootsChangeConsumer(rootsUpdate -> {
-		}).build();
+		McpServerFeatures.SyncToolSpecification tool = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
+
+					exchange.listRoots(); // try to list roots
+
+					return mock(CallToolResult.class);
+				});
+
+		var mcpServer = McpServer.sync(mcpServerTransportProvider).rootsChangeHandler((exchange, rootsUpdate) -> {
+		}).tools(tool).build();
 
 		// Create client without roots capability
-		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().build()) // No
-																							// roots
-																							// capability
-			.build();
+		// No roots capability
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().build()).build();
 
-		InitializeResult initResult = mcpClient.initialize();
-		assertThat(initResult).isNotNull();
+		assertThat(mcpClient.initialize()).isNotNull();
 
 		// Attempt to list roots should fail
-		assertThatThrownBy(() -> mcpServer.listRoots().roots()).isInstanceOf(McpError.class)
-			.hasMessage("Roots not supported");
+		try {
+			mcpClient.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
+		}
+		catch (McpError e) {
+			assertThat(e).isInstanceOf(McpError.class).hasMessage("Roots not supported");
+		}
 
 		mcpClient.close();
 		mcpServer.close();
@@ -246,12 +265,12 @@ public class WebFluxSseIntegrationTests {
 
 	@ParameterizedTest(name = "{0} : {displayName} ")
 	@ValueSource(strings = { "httpclient", "webflux" })
-	void testRootsWithEmptyRootsList(String clientType) {
+	void testRootsNotifciationWithEmptyRootsList(String clientType) {
 		var clientBuilder = clientBulders.get(clientType);
 
 		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
@@ -273,7 +292,7 @@ public class WebFluxSseIntegrationTests {
 
 	@ParameterizedTest(name = "{0} : {displayName} ")
 	@ValueSource(strings = { "httpclient", "webflux" })
-	void testRootsWithMultipleConsumers(String clientType) {
+	void testRootsWithMultipleHandlers(String clientType) {
 		var clientBuilder = clientBulders.get(clientType);
 
 		List<Root> roots = List.of(new Root("uri1://", "root1"));
@@ -281,9 +300,9 @@ public class WebFluxSseIntegrationTests {
 		AtomicReference<List<Root>> rootsRef1 = new AtomicReference<>();
 		AtomicReference<List<Root>> rootsRef2 = new AtomicReference<>();
 
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef1.set(rootsUpdate))
-			.rootsChangeConsumer(rootsUpdate -> rootsRef2.set(rootsUpdate))
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef1.set(rootsUpdate))
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef2.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
@@ -313,8 +332,8 @@ public class WebFluxSseIntegrationTests {
 		List<Root> roots = List.of(new Root("uri1://", "root1"));
 
 		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
@@ -356,8 +375,8 @@ public class WebFluxSseIntegrationTests {
 		var clientBuilder = clientBulders.get(clientType);
 
 		var callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
-		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
-				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+		McpServerFeatures.SyncToolSpecification tool1 = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
 					// perform a blocking call to a remote service
 					String response = RestClient.create()
 						.get()
@@ -368,7 +387,7 @@ public class WebFluxSseIntegrationTests {
 					return callResponse;
 				});
 
-		var mcpServer = McpServer.sync(mcpServerTransport)
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
 			.capabilities(ServerCapabilities.builder().tools(true).build())
 			.tools(tool1)
 			.build();
@@ -396,8 +415,8 @@ public class WebFluxSseIntegrationTests {
 		var clientBuilder = clientBulders.get(clientType);
 
 		var callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
-		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
-				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+		McpServerFeatures.SyncToolSpecification tool1 = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
 					// perform a blocking call to a remote service
 					String response = RestClient.create()
 						.get()
@@ -408,7 +427,7 @@ public class WebFluxSseIntegrationTests {
 					return callResponse;
 				});
 
-		var mcpServer = McpServer.sync(mcpServerTransport)
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
 			.capabilities(ServerCapabilities.builder().tools(true).build())
 			.tools(tool1)
 			.build();
@@ -446,8 +465,8 @@ public class WebFluxSseIntegrationTests {
 		});
 
 		// Add a new tool
-		McpServerFeatures.SyncToolRegistration tool2 = new McpServerFeatures.SyncToolRegistration(
-				new McpSchema.Tool("tool2", "tool2 description", emptyJsonSchema), request -> callResponse);
+		McpServerFeatures.SyncToolSpecification tool2 = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool2", "tool2 description", emptyJsonSchema), (exchange, request) -> callResponse);
 
 		mcpServer.addTool(tool2);
 
@@ -459,4 +478,21 @@ public class WebFluxSseIntegrationTests {
 		mcpServer.close();
 	}
 
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testInitialize(String clientType) {
+
+		var clientBuilder = clientBulders.get(clientType);
+
+		var mcpServer = McpServer.sync(mcpServerTransportProvider).build();
+
+		var mcpClient = clientBuilder.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
 }

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/client/WebFluxSseMcpAsyncClientTests.java

@@ -7,7 +7,7 @@ package io.modelcontextprotocol.client;
 import java.time.Duration;
 
 import io.modelcontextprotocol.client.transport.WebFluxSseClientTransport;
-import io.modelcontextprotocol.spec.ClientMcpTransport;
+import io.modelcontextprotocol.spec.McpClientTransport;
 import org.junit.jupiter.api.Timeout;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.wait.strategy.Wait;
@@ -32,7 +32,7 @@ class WebFluxSseMcpAsyncClientTests extends AbstractMcpAsyncClientTests {
 		.waitingFor(Wait.forHttp("/").forStatusCode(404));
 
 	@Override
-	protected ClientMcpTransport createMcpTransport() {
+	protected McpClientTransport createMcpTransport() {
 		return new WebFluxSseClientTransport(WebClient.builder().baseUrl(host));
 	}
 

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/client/WebFluxSseMcpSyncClientTests.java

@@ -7,7 +7,7 @@ package io.modelcontextprotocol.client;
 import java.time.Duration;
 
 import io.modelcontextprotocol.client.transport.WebFluxSseClientTransport;
-import io.modelcontextprotocol.spec.ClientMcpTransport;
+import io.modelcontextprotocol.spec.McpClientTransport;
 import org.junit.jupiter.api.Timeout;
 import org.testcontainers.containers.GenericContainer;
 import org.testcontainers.containers.wait.strategy.Wait;
@@ -32,7 +32,7 @@ class WebFluxSseMcpSyncClientTests extends AbstractMcpSyncClientTests {
 		.waitingFor(Wait.forHttp("/").forStatusCode(404));
 
 	@Override
-	protected ClientMcpTransport createMcpTransport() {
+	protected McpClientTransport createMcpTransport() {
 		return new WebFluxSseClientTransport(WebClient.builder().baseUrl(host));
 	}
 

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/server/WebFluxSseMcpAsyncServerDeprecatedTests.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2024-2024 the original author or authors.
+ */
+
+package io.modelcontextprotocol.server;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.server.transport.WebFluxSseServerTransport;
+import io.modelcontextprotocol.spec.ServerMcpTransport;
+import org.junit.jupiter.api.Timeout;
+import reactor.netty.DisposableServer;
+import reactor.netty.http.server.HttpServer;
+
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+
+/**
+ * Tests for {@link McpAsyncServer} using {@link WebFluxSseServerTransport}.
+ *
+ * @author Christian Tzolov
+ */
+@Deprecated
+@Timeout(15) // Giving extra time beyond the client timeout
+class WebFluxSseMcpAsyncServerDeprecatedTests extends AbstractMcpAsyncServerDeprecatedTests {
+
+	private static final int PORT = 8181;
+
+	private static final String MESSAGE_ENDPOINT = "/mcp/message";
+
+	private DisposableServer httpServer;
+
+	@Override
+	protected ServerMcpTransport createMcpTransport() {
+		var transport = new WebFluxSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+
+		HttpHandler httpHandler = RouterFunctions.toHttpHandler(transport.getRouterFunction());
+		ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
+		httpServer = HttpServer.create().port(PORT).handle(adapter).bindNow();
+
+		return transport;
+	}
+
+	@Override
+	protected void onStart() {
+	}
+
+	@Override
+	protected void onClose() {
+		if (httpServer != null) {
+			httpServer.disposeNow();
+		}
+	}
+
+}

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/server/WebFluxSseMcpAsyncServerTests.java

@@ -5,8 +5,8 @@
 package io.modelcontextprotocol.server;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import io.modelcontextprotocol.server.transport.WebFluxSseServerTransport;
-import io.modelcontextprotocol.spec.ServerMcpTransport;
+import io.modelcontextprotocol.server.transport.WebFluxSseServerTransportProvider;
+import io.modelcontextprotocol.spec.McpServerTransportProvider;
 import org.junit.jupiter.api.Timeout;
 import reactor.netty.DisposableServer;
 import reactor.netty.http.server.HttpServer;
@@ -16,7 +16,7 @@ import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
 import org.springframework.web.reactive.function.server.RouterFunctions;
 
 /**
- * Tests for {@link McpAsyncServer} using {@link WebFluxSseServerTransport}.
+ * Tests for {@link McpAsyncServer} using {@link WebFluxSseServerTransportProvider}.
  *
  * @author Christian Tzolov
  */
@@ -30,14 +30,13 @@ class WebFluxSseMcpAsyncServerTests extends AbstractMcpAsyncServerTests {
 	private DisposableServer httpServer;
 
 	@Override
-	protected ServerMcpTransport createMcpTransport() {
-		var transport = new WebFluxSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+	protected McpServerTransportProvider createMcpTransportProvider() {
+		var transportProvider = new WebFluxSseServerTransportProvider(new ObjectMapper(), MESSAGE_ENDPOINT);
 
-		HttpHandler httpHandler = RouterFunctions.toHttpHandler(transport.getRouterFunction());
+		HttpHandler httpHandler = RouterFunctions.toHttpHandler(transportProvider.getRouterFunction());
 		ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
 		httpServer = HttpServer.create().port(PORT).handle(adapter).bindNow();
-
-		return transport;
+		return transportProvider;
 	}
 
 	@Override

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/server/WebFluxSseMcpSyncServerDeprecatecTests.java

@@ -0,0 +1,55 @@
+/*
+ * Copyright 2024-2024 the original author or authors.
+ */
+
+package io.modelcontextprotocol.server;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.server.transport.WebFluxSseServerTransport;
+import io.modelcontextprotocol.spec.ServerMcpTransport;
+import org.junit.jupiter.api.Timeout;
+import reactor.netty.DisposableServer;
+import reactor.netty.http.server.HttpServer;
+
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+
+/**
+ * Tests for {@link McpSyncServer} using {@link WebFluxSseServerTransport}.
+ *
+ * @author Christian Tzolov
+ */
+@Deprecated
+@Timeout(15) // Giving extra time beyond the client timeout
+class WebFluxSseMcpSyncServerDeprecatecTests extends AbstractMcpSyncServerDeprecatedTests {
+
+	private static final int PORT = 8182;
+
+	private static final String MESSAGE_ENDPOINT = "/mcp/message";
+
+	private DisposableServer httpServer;
+
+	private WebFluxSseServerTransport transport;
+
+	@Override
+	protected ServerMcpTransport createMcpTransport() {
+		transport = new WebFluxSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		return transport;
+	}
+
+	@Override
+	protected void onStart() {
+		HttpHandler httpHandler = RouterFunctions.toHttpHandler(transport.getRouterFunction());
+		ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
+		httpServer = HttpServer.create().port(PORT).handle(adapter).bindNow();
+	}
+
+	@Override
+	protected void onClose() {
+		if (httpServer != null) {
+			httpServer.disposeNow();
+		}
+	}
+
+}

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/server/WebFluxSseMcpSyncServerTests.java

@@ -5,8 +5,8 @@
 package io.modelcontextprotocol.server;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import io.modelcontextprotocol.server.transport.WebFluxSseServerTransport;
-import io.modelcontextprotocol.spec.ServerMcpTransport;
+import io.modelcontextprotocol.server.transport.WebFluxSseServerTransportProvider;
+import io.modelcontextprotocol.spec.McpServerTransportProvider;
 import org.junit.jupiter.api.Timeout;
 import reactor.netty.DisposableServer;
 import reactor.netty.http.server.HttpServer;
@@ -16,7 +16,7 @@ import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
 import org.springframework.web.reactive.function.server.RouterFunctions;
 
 /**
- * Tests for {@link McpSyncServer} using {@link WebFluxSseServerTransport}.
+ * Tests for {@link McpSyncServer} using {@link WebFluxSseServerTransportProvider}.
  *
  * @author Christian Tzolov
  */
@@ -29,17 +29,17 @@ class WebFluxSseMcpSyncServerTests extends AbstractMcpSyncServerTests {
 
 	private DisposableServer httpServer;
 
-	private WebFluxSseServerTransport transport;
+	private WebFluxSseServerTransportProvider transportProvider;
 
 	@Override
-	protected ServerMcpTransport createMcpTransport() {
-		transport = new WebFluxSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
-		return transport;
+	protected McpServerTransportProvider createMcpTransportProvider() {
+		transportProvider = new WebFluxSseServerTransportProvider(new ObjectMapper(), MESSAGE_ENDPOINT);
+		return transportProvider;
 	}
 
 	@Override
 	protected void onStart() {
-		HttpHandler httpHandler = RouterFunctions.toHttpHandler(transport.getRouterFunction());
+		HttpHandler httpHandler = RouterFunctions.toHttpHandler(transportProvider.getRouterFunction());
 		ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
 		httpServer = HttpServer.create().port(PORT).handle(adapter).bindNow();
 	}

mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/server/legacy/WebFluxSseIntegrationTests.java

@@ -0,0 +1,459 @@
+/*
+ * Copyright 2024 - 2024 the original author or authors.
+ */
+package io.modelcontextprotocol.server.legacy;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.client.McpClient;
+import io.modelcontextprotocol.client.transport.HttpClientSseClientTransport;
+import io.modelcontextprotocol.client.transport.WebFluxSseClientTransport;
+import io.modelcontextprotocol.server.McpServer;
+import io.modelcontextprotocol.server.McpServerFeatures;
+import io.modelcontextprotocol.server.transport.WebFluxSseServerTransport;
+import io.modelcontextprotocol.spec.McpError;
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpSchema.CallToolResult;
+import io.modelcontextprotocol.spec.McpSchema.ClientCapabilities;
+import io.modelcontextprotocol.spec.McpSchema.CreateMessageRequest;
+import io.modelcontextprotocol.spec.McpSchema.CreateMessageResult;
+import io.modelcontextprotocol.spec.McpSchema.InitializeResult;
+import io.modelcontextprotocol.spec.McpSchema.Role;
+import io.modelcontextprotocol.spec.McpSchema.Root;
+import io.modelcontextprotocol.spec.McpSchema.ServerCapabilities;
+import io.modelcontextprotocol.spec.McpSchema.Tool;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+import reactor.netty.DisposableServer;
+import reactor.netty.http.server.HttpServer;
+import reactor.test.StepVerifier;
+
+import org.springframework.http.server.reactive.HttpHandler;
+import org.springframework.http.server.reactive.ReactorHttpHandlerAdapter;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.reactive.function.client.WebClient;
+import org.springframework.web.reactive.function.server.RouterFunctions;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.awaitility.Awaitility.await;
+
+public class WebFluxSseIntegrationTests {
+
+	private static final int PORT = 8182;
+
+	private static final String MESSAGE_ENDPOINT = "/mcp/message";
+
+	private DisposableServer httpServer;
+
+	private WebFluxSseServerTransport mcpServerTransport;
+
+	ConcurrentHashMap<String, McpClient.SyncSpec> clientBulders = new ConcurrentHashMap<>();
+
+	@BeforeEach
+	public void before() {
+
+		this.mcpServerTransport = new WebFluxSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+
+		HttpHandler httpHandler = RouterFunctions.toHttpHandler(mcpServerTransport.getRouterFunction());
+		ReactorHttpHandlerAdapter adapter = new ReactorHttpHandlerAdapter(httpHandler);
+		this.httpServer = HttpServer.create().port(PORT).handle(adapter).bindNow();
+
+		clientBulders.put("httpclient", McpClient.sync(new HttpClientSseClientTransport("http://localhost:" + PORT)));
+		clientBulders.put("webflux",
+				McpClient.sync(new WebFluxSseClientTransport(WebClient.builder().baseUrl("http://localhost:" + PORT))));
+
+	}
+
+	@AfterEach
+	public void after() {
+		if (httpServer != null) {
+			httpServer.disposeNow();
+		}
+	}
+
+	// ---------------------------------------
+	// Sampling Tests
+	// ---------------------------------------
+	@Test
+	void testCreateMessageWithoutInitialization() {
+		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+
+		var messages = List.of(new McpSchema.SamplingMessage(Role.USER, new McpSchema.TextContent("Test message")));
+		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+		var request = new CreateMessageRequest(messages, modelPrefs, null,
+				CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+
+		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
+			assertThat(error).isInstanceOf(McpError.class)
+				.hasMessage("Client must be initialized. Call the initialize method first!");
+		});
+	}
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testCreateMessageWithoutSamplingCapabilities(String clientType) {
+
+		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+
+		var clientBuilder = clientBulders.get(clientType);
+
+		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0")).build();
+
+		InitializeResult initResult = client.initialize();
+		assertThat(initResult).isNotNull();
+
+		var messages = List.of(new McpSchema.SamplingMessage(Role.USER, new McpSchema.TextContent("Test message")));
+		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+		var request = new CreateMessageRequest(messages, modelPrefs, null,
+				CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+
+		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
+			assertThat(error).isInstanceOf(McpError.class)
+				.hasMessage("Client must be configured with sampling capabilities");
+		});
+	}
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testCreateMessageSuccess(String clientType) throws InterruptedException {
+
+		var clientBuilder = clientBulders.get(clientType);
+
+		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+
+		Function<CreateMessageRequest, CreateMessageResult> samplingHandler = request -> {
+			assertThat(request.messages()).hasSize(1);
+			assertThat(request.messages().get(0).content()).isInstanceOf(McpSchema.TextContent.class);
+
+			return new CreateMessageResult(Role.USER, new McpSchema.TextContent("Test message"), "MockModelName",
+					CreateMessageResult.StopReason.STOP_SEQUENCE);
+		};
+
+		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0"))
+			.capabilities(ClientCapabilities.builder().sampling().build())
+			.sampling(samplingHandler)
+			.build();
+
+		InitializeResult initResult = client.initialize();
+		assertThat(initResult).isNotNull();
+
+		var messages = List.of(new McpSchema.SamplingMessage(Role.USER, new McpSchema.TextContent("Test message")));
+		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+		var request = new CreateMessageRequest(messages, modelPrefs, null,
+				CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+
+		StepVerifier.create(mcpAsyncServer.createMessage(request)).consumeNextWith(result -> {
+			assertThat(result).isNotNull();
+			assertThat(result.role()).isEqualTo(Role.USER);
+			assertThat(result.content()).isInstanceOf(McpSchema.TextContent.class);
+			assertThat(((McpSchema.TextContent) result.content()).text()).isEqualTo("Test message");
+			assertThat(result.model()).isEqualTo("MockModelName");
+			assertThat(result.stopReason()).isEqualTo(CreateMessageResult.StopReason.STOP_SEQUENCE);
+		}).verifyComplete();
+	}
+
+	// ---------------------------------------
+	// Roots Tests
+	// ---------------------------------------
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testRootsSuccess(String clientType) {
+		var clientBuilder = clientBulders.get(clientType);
+
+		List<Root> roots = List.of(new Root("uri1://", "root1"), new Root("uri2://", "root2"));
+
+		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(roots)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		assertThat(rootsRef.get()).isNull();
+
+		assertThat(mcpServer.listRoots().roots()).containsAll(roots);
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(roots);
+		});
+
+		// Remove a root
+		mcpClient.removeRoot(roots.get(0).uri());
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(roots.get(1)));
+		});
+
+		// Add a new root
+		var root3 = new Root("uri3://", "root3");
+		mcpClient.addRoot(root3);
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(roots.get(1), root3));
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testRootsWithoutCapability(String clientType) {
+		var clientBuilder = clientBulders.get(clientType);
+
+		var mcpServer = McpServer.sync(mcpServerTransport).rootsChangeConsumer(rootsUpdate -> {
+		}).build();
+
+		// Create client without roots capability
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().build()) // No
+																							// roots
+																							// capability
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		// Attempt to list roots should fail
+		assertThatThrownBy(() -> mcpServer.listRoots().roots()).isInstanceOf(McpError.class)
+			.hasMessage("Roots not supported");
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testRootsWithEmptyRootsList(String clientType) {
+		var clientBuilder = clientBulders.get(clientType);
+
+		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(List.of()) // Empty roots list
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).isEmpty();
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testRootsWithMultipleConsumers(String clientType) {
+		var clientBuilder = clientBulders.get(clientType);
+
+		List<Root> roots = List.of(new Root("uri1://", "root1"));
+
+		AtomicReference<List<Root>> rootsRef1 = new AtomicReference<>();
+		AtomicReference<List<Root>> rootsRef2 = new AtomicReference<>();
+
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef1.set(rootsUpdate))
+			.rootsChangeConsumer(rootsUpdate -> rootsRef2.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(roots)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef1.get()).containsAll(roots);
+			assertThat(rootsRef2.get()).containsAll(roots);
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testRootsServerCloseWithActiveSubscription(String clientType) {
+
+		var clientBuilder = clientBulders.get(clientType);
+
+		List<Root> roots = List.of(new Root("uri1://", "root1"));
+
+		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(roots)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(roots);
+		});
+
+		// Close server while subscription is active
+		mcpServer.close();
+
+		// Verify client can handle server closure gracefully
+		mcpClient.close();
+	}
+
+	// ---------------------------------------
+	// Tools Tests
+	// ---------------------------------------
+
+	String emptyJsonSchema = """
+			{
+				"$schema": "http://json-schema.org/draft-07/schema#",
+				"type": "object",
+				"properties": {}
+			}
+			""";
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testToolCallSuccess(String clientType) {
+
+		var clientBuilder = clientBulders.get(clientType);
+
+		var callResponse = new CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
+		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
+				new Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+					// perform a blocking call to a remote service
+					String response = RestClient.create()
+						.get()
+						.uri("https://github.com/modelcontextprotocol/specification/blob/main/README.md")
+						.retrieve()
+						.body(String.class);
+					assertThat(response).isNotBlank();
+					return callResponse;
+				});
+
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.capabilities(ServerCapabilities.builder().tools(true).build())
+			.tools(tool1)
+			.build();
+
+		var mcpClient = clientBuilder.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		assertThat(mcpClient.listTools().tools()).contains(tool1.tool());
+
+		CallToolResult response = mcpClient.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
+
+		assertThat(response).isNotNull();
+		assertThat(response).isEqualTo(callResponse);
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@ParameterizedTest(name = "{0} : {displayName} ")
+	@ValueSource(strings = { "httpclient", "webflux" })
+	void testToolListChangeHandlingSuccess(String clientType) {
+
+		var clientBuilder = clientBulders.get(clientType);
+
+		var callResponse = new CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
+		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
+				new Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+					// perform a blocking call to a remote service
+					String response = RestClient.create()
+						.get()
+						.uri("https://github.com/modelcontextprotocol/specification/blob/main/README.md")
+						.retrieve()
+						.body(String.class);
+					assertThat(response).isNotBlank();
+					return callResponse;
+				});
+
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.capabilities(ServerCapabilities.builder().tools(true).build())
+			.tools(tool1)
+			.build();
+
+		AtomicReference<List<Tool>> rootsRef = new AtomicReference<>();
+		var mcpClient = clientBuilder.toolsChangeConsumer(toolsUpdate -> {
+			// perform a blocking call to a remote service
+			String response = RestClient.create()
+				.get()
+				.uri("https://github.com/modelcontextprotocol/specification/blob/main/README.md")
+				.retrieve()
+				.body(String.class);
+			assertThat(response).isNotBlank();
+			rootsRef.set(toolsUpdate);
+		}).build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		assertThat(rootsRef.get()).isNull();
+
+		assertThat(mcpClient.listTools().tools()).contains(tool1.tool());
+
+		mcpServer.notifyToolsListChanged();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(tool1.tool()));
+		});
+
+		// Remove a tool
+		mcpServer.removeTool("tool1");
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).isEmpty();
+		});
+
+		// Add a new tool
+		McpServerFeatures.SyncToolRegistration tool2 = new McpServerFeatures.SyncToolRegistration(
+				new Tool("tool2", "tool2 description", emptyJsonSchema), request -> callResponse);
+
+		mcpServer.addTool(tool2);
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(tool2.tool()));
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+}

mcp-spring/mcp-spring-webmvc/src/main/java/io/modelcontextprotocol/server/transport/WebMvcSseServerTransport.java

@@ -33,6 +33,9 @@ import org.springframework.web.servlet.function.ServerResponse.SseBuilder;
  * a bridge between synchronous WebMVC operations and reactive programming patterns to
  * maintain compatibility with the reactive transport interface.
  *
+ * @deprecated This class will be removed in 0.9.0. Use
+ * {@link WebMvcSseServerTransportProvider}.
+ *
  * <p>
  * Key features:
  * <ul>
@@ -57,12 +60,12 @@ import org.springframework.web.servlet.function.ServerResponse.SseBuilder;
  * This implementation uses {@link ConcurrentHashMap} to safely manage multiple client
  * sessions in a thread-safe manner. Each client session is assigned a unique ID and
  * maintains its own SSE connection.
- *
  * @author Christian Tzolov
  * @author Alexandros Pappas
  * @see ServerMcpTransport
  * @see RouterFunction
  */
+@Deprecated
 public class WebMvcSseServerTransport implements ServerMcpTransport {
 
 	private static final Logger logger = LoggerFactory.getLogger(WebMvcSseServerTransport.class);

mcp-spring/mcp-spring-webmvc/src/main/java/io/modelcontextprotocol/server/transport/WebMvcSseServerTransportProvider.java

@@ -0,0 +1,399 @@
+/*
+ * Copyright 2024-2024 the original author or authors.
+ */
+
+package io.modelcontextprotocol.server.transport;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.Map;
+import java.util.UUID;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.fasterxml.jackson.core.type.TypeReference;
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.spec.McpError;
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpServerTransport;
+import io.modelcontextprotocol.spec.McpServerTransportProvider;
+import io.modelcontextprotocol.spec.McpServerSession;
+import io.modelcontextprotocol.util.Assert;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+
+import org.springframework.http.HttpStatus;
+import org.springframework.web.servlet.function.RouterFunction;
+import org.springframework.web.servlet.function.RouterFunctions;
+import org.springframework.web.servlet.function.ServerRequest;
+import org.springframework.web.servlet.function.ServerResponse;
+import org.springframework.web.servlet.function.ServerResponse.SseBuilder;
+
+/**
+ * Server-side implementation of the Model Context Protocol (MCP) transport layer using
+ * HTTP with Server-Sent Events (SSE) through Spring WebMVC. This implementation provides
+ * a bridge between synchronous WebMVC operations and reactive programming patterns to
+ * maintain compatibility with the reactive transport interface.
+ *
+ * <p>
+ * Key features:
+ * <ul>
+ * <li>Implements bidirectional communication using HTTP POST for client-to-server
+ * messages and SSE for server-to-client messages</li>
+ * <li>Manages client sessions with unique IDs for reliable message delivery</li>
+ * <li>Supports graceful shutdown with proper session cleanup</li>
+ * <li>Provides JSON-RPC message handling through configured endpoints</li>
+ * <li>Includes built-in error handling and logging</li>
+ * </ul>
+ *
+ * <p>
+ * The transport operates on two main endpoints:
+ * <ul>
+ * <li>{@code /sse} - The SSE endpoint where clients establish their event stream
+ * connection</li>
+ * <li>A configurable message endpoint where clients send their JSON-RPC messages via HTTP
+ * POST</li>
+ * </ul>
+ *
+ * <p>
+ * This implementation uses {@link ConcurrentHashMap} to safely manage multiple client
+ * sessions in a thread-safe manner. Each client session is assigned a unique ID and
+ * maintains its own SSE connection.
+ *
+ * @author Christian Tzolov
+ * @author Alexandros Pappas
+ * @see McpServerTransportProvider
+ * @see RouterFunction
+ */
+public class WebMvcSseServerTransportProvider implements McpServerTransportProvider {
+
+	private static final Logger logger = LoggerFactory.getLogger(WebMvcSseServerTransportProvider.class);
+
+	/**
+	 * Event type for JSON-RPC messages sent through the SSE connection.
+	 */
+	public static final String MESSAGE_EVENT_TYPE = "message";
+
+	/**
+	 * Event type for sending the message endpoint URI to clients.
+	 */
+	public static final String ENDPOINT_EVENT_TYPE = "endpoint";
+
+	/**
+	 * Default SSE endpoint path as specified by the MCP transport specification.
+	 */
+	public static final String DEFAULT_SSE_ENDPOINT = "/sse";
+
+	private final ObjectMapper objectMapper;
+
+	private final String messageEndpoint;
+
+	private final String sseEndpoint;
+
+	private final RouterFunction<ServerResponse> routerFunction;
+
+	private McpServerSession.Factory sessionFactory;
+
+	/**
+	 * Map of active client sessions, keyed by session ID.
+	 */
+	private final ConcurrentHashMap<String, McpServerSession> sessions = new ConcurrentHashMap<>();
+
+	/**
+	 * Flag indicating if the transport is shutting down.
+	 */
+	private volatile boolean isClosing = false;
+
+	/**
+	 * Constructs a new WebMvcSseServerTransportProvider instance.
+	 * @param objectMapper The ObjectMapper to use for JSON serialization/deserialization
+	 * of messages.
+	 * @param messageEndpoint The endpoint URI where clients should send their JSON-RPC
+	 * messages via HTTP POST. This endpoint will be communicated to clients through the
+	 * SSE connection's initial endpoint event.
+	 * @param sseEndpoint The endpoint URI where clients establish their SSE connections.
+	 * @throws IllegalArgumentException if any parameter is null
+	 */
+	public WebMvcSseServerTransportProvider(ObjectMapper objectMapper, String messageEndpoint, String sseEndpoint) {
+		Assert.notNull(objectMapper, "ObjectMapper must not be null");
+		Assert.notNull(messageEndpoint, "Message endpoint must not be null");
+		Assert.notNull(sseEndpoint, "SSE endpoint must not be null");
+
+		this.objectMapper = objectMapper;
+		this.messageEndpoint = messageEndpoint;
+		this.sseEndpoint = sseEndpoint;
+		this.routerFunction = RouterFunctions.route()
+			.GET(this.sseEndpoint, this::handleSseConnection)
+			.POST(this.messageEndpoint, this::handleMessage)
+			.build();
+	}
+
+	/**
+	 * Constructs a new WebMvcSseServerTransportProvider instance with the default SSE
+	 * endpoint.
+	 * @param objectMapper The ObjectMapper to use for JSON serialization/deserialization
+	 * of messages.
+	 * @param messageEndpoint The endpoint URI where clients should send their JSON-RPC
+	 * messages via HTTP POST. This endpoint will be communicated to clients through the
+	 * SSE connection's initial endpoint event.
+	 * @throws IllegalArgumentException if either objectMapper or messageEndpoint is null
+	 */
+	public WebMvcSseServerTransportProvider(ObjectMapper objectMapper, String messageEndpoint) {
+		this(objectMapper, messageEndpoint, DEFAULT_SSE_ENDPOINT);
+	}
+
+	@Override
+	public void setSessionFactory(McpServerSession.Factory sessionFactory) {
+		this.sessionFactory = sessionFactory;
+	}
+
+	/**
+	 * Broadcasts a notification to all connected clients through their SSE connections.
+	 * The message is serialized to JSON and sent as an SSE event with type "message". If
+	 * any errors occur during sending to a particular client, they are logged but don't
+	 * prevent sending to other clients.
+	 * @param method The method name for the notification
+	 * @param params The parameters for the notification
+	 * @return A Mono that completes when the broadcast attempt is finished
+	 */
+	@Override
+	public Mono<Void> notifyClients(String method, Map<String, Object> params) {
+		if (sessions.isEmpty()) {
+			logger.debug("No active sessions to broadcast message to");
+			return Mono.empty();
+		}
+
+		logger.debug("Attempting to broadcast message to {} active sessions", sessions.size());
+
+		return Flux.fromIterable(sessions.values())
+			.flatMap(session -> session.sendNotification(method, params)
+				.doOnError(
+						e -> logger.error("Failed to send message to session {}: {}", session.getId(), e.getMessage()))
+				.onErrorComplete())
+			.then();
+	}
+
+	/**
+	 * Initiates a graceful shutdown of the transport. This method:
+	 * <ul>
+	 * <li>Sets the closing flag to prevent new connections</li>
+	 * <li>Closes all active SSE connections</li>
+	 * <li>Removes all session records</li>
+	 * </ul>
+	 * @return A Mono that completes when all cleanup operations are finished
+	 */
+	@Override
+	public Mono<Void> closeGracefully() {
+		return Flux.fromIterable(sessions.values()).doFirst(() -> {
+			this.isClosing = true;
+			logger.debug("Initiating graceful shutdown with {} active sessions", sessions.size());
+		})
+			.flatMap(McpServerSession::closeGracefully)
+			.then()
+			.doOnSuccess(v -> logger.debug("Graceful shutdown completed"));
+	}
+
+	/**
+	 * Returns the RouterFunction that defines the HTTP endpoints for this transport. The
+	 * router function handles two endpoints:
+	 * <ul>
+	 * <li>GET /sse - For establishing SSE connections</li>
+	 * <li>POST [messageEndpoint] - For receiving JSON-RPC messages from clients</li>
+	 * </ul>
+	 * @return The configured RouterFunction for handling HTTP requests
+	 */
+	public RouterFunction<ServerResponse> getRouterFunction() {
+		return this.routerFunction;
+	}
+
+	/**
+	 * Handles new SSE connection requests from clients by creating a new session and
+	 * establishing an SSE connection. This method:
+	 * <ul>
+	 * <li>Generates a unique session ID</li>
+	 * <li>Creates a new session with a WebMvcMcpSessionTransport</li>
+	 * <li>Sends an initial endpoint event to inform the client where to send
+	 * messages</li>
+	 * <li>Maintains the session in the sessions map</li>
+	 * </ul>
+	 * @param request The incoming server request
+	 * @return A ServerResponse configured for SSE communication, or an error response if
+	 * the server is shutting down or the connection fails
+	 */
+	private ServerResponse handleSseConnection(ServerRequest request) {
+		if (this.isClosing) {
+			return ServerResponse.status(HttpStatus.SERVICE_UNAVAILABLE).body("Server is shutting down");
+		}
+
+		String sessionId = UUID.randomUUID().toString();
+		logger.debug("Creating new SSE connection for session: {}", sessionId);
+
+		// Send initial endpoint event
+		try {
+			return ServerResponse.sse(sseBuilder -> {
+				sseBuilder.onComplete(() -> {
+					logger.debug("SSE connection completed for session: {}", sessionId);
+					sessions.remove(sessionId);
+				});
+				sseBuilder.onTimeout(() -> {
+					logger.debug("SSE connection timed out for session: {}", sessionId);
+					sessions.remove(sessionId);
+				});
+
+				WebMvcMcpSessionTransport sessionTransport = new WebMvcMcpSessionTransport(sessionId, sseBuilder);
+				McpServerSession session = sessionFactory.create(sessionTransport);
+				this.sessions.put(sessionId, session);
+
+				try {
+					sseBuilder.id(sessionId)
+						.event(ENDPOINT_EVENT_TYPE)
+						.data(messageEndpoint + "?sessionId=" + sessionId);
+				}
+				catch (Exception e) {
+					logger.error("Failed to send initial endpoint event: {}", e.getMessage());
+					sseBuilder.error(e);
+				}
+			}, Duration.ZERO);
+		}
+		catch (Exception e) {
+			logger.error("Failed to send initial endpoint event to session {}: {}", sessionId, e.getMessage());
+			sessions.remove(sessionId);
+			return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).build();
+		}
+	}
+
+	/**
+	 * Handles incoming JSON-RPC messages from clients. This method:
+	 * <ul>
+	 * <li>Deserializes the request body into a JSON-RPC message</li>
+	 * <li>Processes the message through the session's handle method</li>
+	 * <li>Returns appropriate HTTP responses based on the processing result</li>
+	 * </ul>
+	 * @param request The incoming server request containing the JSON-RPC message
+	 * @return A ServerResponse indicating success (200 OK) or appropriate error status
+	 * with error details in case of failures
+	 */
+	private ServerResponse handleMessage(ServerRequest request) {
+		if (this.isClosing) {
+			return ServerResponse.status(HttpStatus.SERVICE_UNAVAILABLE).body("Server is shutting down");
+		}
+
+		if (!request.param("sessionId").isPresent()) {
+			return ServerResponse.badRequest().body(new McpError("Session ID missing in message endpoint"));
+		}
+
+		String sessionId = request.param("sessionId").get();
+		McpServerSession session = sessions.get(sessionId);
+
+		if (session == null) {
+			return ServerResponse.status(HttpStatus.NOT_FOUND).body(new McpError("Session not found: " + sessionId));
+		}
+
+		try {
+			String body = request.body(String.class);
+			McpSchema.JSONRPCMessage message = McpSchema.deserializeJsonRpcMessage(objectMapper, body);
+
+			// Process the message through the session's handle method
+			session.handle(message).block(); // Block for WebMVC compatibility
+
+			return ServerResponse.ok().build();
+		}
+		catch (IllegalArgumentException | IOException e) {
+			logger.error("Failed to deserialize message: {}", e.getMessage());
+			return ServerResponse.badRequest().body(new McpError("Invalid message format"));
+		}
+		catch (Exception e) {
+			logger.error("Error handling message: {}", e.getMessage());
+			return ServerResponse.status(HttpStatus.INTERNAL_SERVER_ERROR).body(new McpError(e.getMessage()));
+		}
+	}
+
+	/**
+	 * Implementation of McpServerTransport for WebMVC SSE sessions. This class handles
+	 * the transport-level communication for a specific client session.
+	 */
+	private class WebMvcMcpSessionTransport implements McpServerTransport {
+
+		private final String sessionId;
+
+		private final SseBuilder sseBuilder;
+
+		/**
+		 * Creates a new session transport with the specified ID and SSE builder.
+		 * @param sessionId The unique identifier for this session
+		 * @param sseBuilder The SSE builder for sending server events to the client
+		 */
+		WebMvcMcpSessionTransport(String sessionId, SseBuilder sseBuilder) {
+			this.sessionId = sessionId;
+			this.sseBuilder = sseBuilder;
+			logger.debug("Session transport {} initialized with SSE builder", sessionId);
+		}
+
+		/**
+		 * Sends a JSON-RPC message to the client through the SSE connection.
+		 * @param message The JSON-RPC message to send
+		 * @return A Mono that completes when the message has been sent
+		 */
+		@Override
+		public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+			return Mono.fromRunnable(() -> {
+				try {
+					String jsonText = objectMapper.writeValueAsString(message);
+					sseBuilder.id(sessionId).event(MESSAGE_EVENT_TYPE).data(jsonText);
+					logger.debug("Message sent to session {}", sessionId);
+				}
+				catch (Exception e) {
+					logger.error("Failed to send message to session {}: {}", sessionId, e.getMessage());
+					sseBuilder.error(e);
+				}
+			});
+		}
+
+		/**
+		 * Converts data from one type to another using the configured ObjectMapper.
+		 * @param data The source data object to convert
+		 * @param typeRef The target type reference
+		 * @return The converted object of type T
+		 * @param <T> The target type
+		 */
+		@Override
+		public <T> T unmarshalFrom(Object data, TypeReference<T> typeRef) {
+			return objectMapper.convertValue(data, typeRef);
+		}
+
+		/**
+		 * Initiates a graceful shutdown of the transport.
+		 * @return A Mono that completes when the shutdown is complete
+		 */
+		@Override
+		public Mono<Void> closeGracefully() {
+			return Mono.fromRunnable(() -> {
+				logger.debug("Closing session transport: {}", sessionId);
+				try {
+					sseBuilder.complete();
+					logger.debug("Successfully completed SSE builder for session {}", sessionId);
+				}
+				catch (Exception e) {
+					logger.warn("Failed to complete SSE builder for session {}: {}", sessionId, e.getMessage());
+				}
+			});
+		}
+
+		/**
+		 * Closes the transport immediately.
+		 */
+		@Override
+		public void close() {
+			try {
+				sseBuilder.complete();
+				logger.debug("Successfully completed SSE builder for session {}", sessionId);
+			}
+			catch (Exception e) {
+				logger.warn("Failed to complete SSE builder for session {}: {}", sessionId, e.getMessage());
+			}
+		}
+
+	}
+
+}

mcp-spring/mcp-spring-webmvc/src/test/java/io/modelcontextprotocol/server/WebMvcSseAsyncServerTransportDeprecatedTests.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2024-2024 the original author or authors.
+ */
+
+package io.modelcontextprotocol.server;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.server.transport.WebMvcSseServerTransport;
+import io.modelcontextprotocol.spec.ServerMcpTransport;
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.startup.Tomcat;
+import org.junit.jupiter.api.Timeout;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+import org.springframework.web.servlet.DispatcherServlet;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.function.RouterFunction;
+import org.springframework.web.servlet.function.ServerResponse;
+
+@Deprecated
+@Timeout(15)
+class WebMvcSseAsyncServerTransportDeprecatedTests extends AbstractMcpAsyncServerDeprecatedTests {
+
+	private static final String MESSAGE_ENDPOINT = "/mcp/message";
+
+	private static final int PORT = 8181;
+
+	private Tomcat tomcat;
+
+	private WebMvcSseServerTransport transport;
+
+	@Configuration
+	@EnableWebMvc
+	static class TestConfig {
+
+		@Bean
+		public WebMvcSseServerTransport webMvcSseServerTransport() {
+			return new WebMvcSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		}
+
+		@Bean
+		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransport transport) {
+			return transport.getRouterFunction();
+		}
+
+	}
+
+	private AnnotationConfigWebApplicationContext appContext;
+
+	@Override
+	protected ServerMcpTransport createMcpTransport() {
+		// Set up Tomcat first
+		tomcat = new Tomcat();
+		tomcat.setPort(PORT);
+
+		// Set Tomcat base directory to java.io.tmpdir to avoid permission issues
+		String baseDir = System.getProperty("java.io.tmpdir");
+		tomcat.setBaseDir(baseDir);
+
+		// Use the same directory for document base
+		Context context = tomcat.addContext("", baseDir);
+
+		// Create and configure Spring WebMvc context
+		appContext = new AnnotationConfigWebApplicationContext();
+		appContext.register(TestConfig.class);
+		appContext.setServletContext(context.getServletContext());
+		appContext.refresh();
+
+		// Get the transport from Spring context
+		transport = appContext.getBean(WebMvcSseServerTransport.class);
+
+		// Create DispatcherServlet with our Spring context
+		DispatcherServlet dispatcherServlet = new DispatcherServlet(appContext);
+		// dispatcherServlet.setThrowExceptionIfNoHandlerFound(true);
+
+		// Add servlet to Tomcat and get the wrapper
+		var wrapper = Tomcat.addServlet(context, "dispatcherServlet", dispatcherServlet);
+		wrapper.setLoadOnStartup(1);
+		context.addServletMappingDecoded("/*", "dispatcherServlet");
+
+		try {
+			tomcat.start();
+			tomcat.getConnector(); // Create and start the connector
+		}
+		catch (LifecycleException e) {
+			throw new RuntimeException("Failed to start Tomcat", e);
+		}
+
+		return transport;
+	}
+
+	@Override
+	protected void onStart() {
+	}
+
+	@Override
+	protected void onClose() {
+		if (transport != null) {
+			transport.closeGracefully().block();
+		}
+		if (appContext != null) {
+			appContext.close();
+		}
+		if (tomcat != null) {
+			try {
+				tomcat.stop();
+				tomcat.destroy();
+			}
+			catch (LifecycleException e) {
+				throw new RuntimeException("Failed to stop Tomcat", e);
+			}
+		}
+	}
+
+}

mcp-spring/mcp-spring-webmvc/src/test/java/io/modelcontextprotocol/server/WebMvcSseAsyncServerTransportTests.java

@@ -5,8 +5,8 @@
 package io.modelcontextprotocol.server;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import io.modelcontextprotocol.server.transport.WebMvcSseServerTransport;
-import io.modelcontextprotocol.spec.ServerMcpTransport;
+import io.modelcontextprotocol.server.transport.WebMvcSseServerTransportProvider;
+import io.modelcontextprotocol.spec.McpServerTransportProvider;
 import org.apache.catalina.Context;
 import org.apache.catalina.LifecycleException;
 import org.apache.catalina.startup.Tomcat;
@@ -29,20 +29,20 @@ class WebMvcSseAsyncServerTransportTests extends AbstractMcpAsyncServerTests {
 
 	private Tomcat tomcat;
 
-	private WebMvcSseServerTransport transport;
+	private McpServerTransportProvider transportProvider;
 
 	@Configuration
 	@EnableWebMvc
 	static class TestConfig {
 
 		@Bean
-		public WebMvcSseServerTransport webMvcSseServerTransport() {
-			return new WebMvcSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		public WebMvcSseServerTransportProvider webMvcSseServerTransportProvider() {
+			return new WebMvcSseServerTransportProvider(new ObjectMapper(), MESSAGE_ENDPOINT);
 		}
 
 		@Bean
-		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransport transport) {
-			return transport.getRouterFunction();
+		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransportProvider transportProvider) {
+			return transportProvider.getRouterFunction();
 		}
 
 	}
@@ -50,7 +50,7 @@ class WebMvcSseAsyncServerTransportTests extends AbstractMcpAsyncServerTests {
 	private AnnotationConfigWebApplicationContext appContext;
 
 	@Override
-	protected ServerMcpTransport createMcpTransport() {
+	protected McpServerTransportProvider createMcpTransportProvider() {
 		// Set up Tomcat first
 		tomcat = new Tomcat();
 		tomcat.setPort(PORT);
@@ -69,7 +69,7 @@ class WebMvcSseAsyncServerTransportTests extends AbstractMcpAsyncServerTests {
 		appContext.refresh();
 
 		// Get the transport from Spring context
-		transport = appContext.getBean(WebMvcSseServerTransport.class);
+		transportProvider = appContext.getBean(WebMvcSseServerTransportProvider.class);
 
 		// Create DispatcherServlet with our Spring context
 		DispatcherServlet dispatcherServlet = new DispatcherServlet(appContext);
@@ -88,7 +88,7 @@ class WebMvcSseAsyncServerTransportTests extends AbstractMcpAsyncServerTests {
 			throw new RuntimeException("Failed to start Tomcat", e);
 		}
 
-		return transport;
+		return transportProvider;
 	}
 
 	@Override
@@ -97,8 +97,8 @@ class WebMvcSseAsyncServerTransportTests extends AbstractMcpAsyncServerTests {
 
 	@Override
 	protected void onClose() {
-		if (transport != null) {
-			transport.closeGracefully().block();
+		if (transportProvider != null) {
+			transportProvider.closeGracefully().block();
 		}
 		if (appContext != null) {
 			appContext.close();

mcp-spring/mcp-spring-webmvc/src/test/java/io/modelcontextprotocol/server/WebMvcSseIntegrationDeprecatedTests.java

@@ -0,0 +1,508 @@
+/*
+ * Copyright 2024 - 2024 the original author or authors.
+ */
+package io.modelcontextprotocol.server;
+
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.function.Function;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.client.McpClient;
+import io.modelcontextprotocol.client.transport.HttpClientSseClientTransport;
+import io.modelcontextprotocol.server.transport.WebMvcSseServerTransport;
+import io.modelcontextprotocol.spec.McpError;
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpSchema.CallToolResult;
+import io.modelcontextprotocol.spec.McpSchema.ClientCapabilities;
+import io.modelcontextprotocol.spec.McpSchema.CreateMessageRequest;
+import io.modelcontextprotocol.spec.McpSchema.CreateMessageResult;
+import io.modelcontextprotocol.spec.McpSchema.InitializeResult;
+import io.modelcontextprotocol.spec.McpSchema.Role;
+import io.modelcontextprotocol.spec.McpSchema.Root;
+import io.modelcontextprotocol.spec.McpSchema.ServerCapabilities;
+import io.modelcontextprotocol.spec.McpSchema.Tool;
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.LifecycleState;
+import org.apache.catalina.startup.Tomcat;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import reactor.test.StepVerifier;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.client.RestClient;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+import org.springframework.web.servlet.DispatcherServlet;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.function.RouterFunction;
+import org.springframework.web.servlet.function.ServerResponse;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.assertj.core.api.Assertions.assertThatThrownBy;
+import static org.awaitility.Awaitility.await;
+
+@Deprecated
+public class WebMvcSseIntegrationDeprecatedTests {
+
+	private static final int PORT = 8183;
+
+	private static final String MESSAGE_ENDPOINT = "/mcp/message";
+
+	private WebMvcSseServerTransport mcpServerTransport;
+
+	McpClient.SyncSpec clientBuilder;
+
+	@Configuration
+	@EnableWebMvc
+	static class TestConfig {
+
+		@Bean
+		public WebMvcSseServerTransport webMvcSseServerTransport() {
+			return new WebMvcSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		}
+
+		@Bean
+		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransport transport) {
+			return transport.getRouterFunction();
+		}
+
+	}
+
+	private Tomcat tomcat;
+
+	private AnnotationConfigWebApplicationContext appContext;
+
+	@BeforeEach
+	public void before() {
+
+		// Set up Tomcat first
+		tomcat = new Tomcat();
+		tomcat.setPort(PORT);
+
+		// Set Tomcat base directory to java.io.tmpdir to avoid permission issues
+		String baseDir = System.getProperty("java.io.tmpdir");
+		tomcat.setBaseDir(baseDir);
+
+		// Use the same directory for document base
+		Context context = tomcat.addContext("", baseDir);
+
+		// Create and configure Spring WebMvc context
+		appContext = new AnnotationConfigWebApplicationContext();
+		appContext.register(TestConfig.class);
+		appContext.setServletContext(context.getServletContext());
+		appContext.refresh();
+
+		// Get the transport from Spring context
+		mcpServerTransport = appContext.getBean(WebMvcSseServerTransport.class);
+
+		// Create DispatcherServlet with our Spring context
+		DispatcherServlet dispatcherServlet = new DispatcherServlet(appContext);
+		// dispatcherServlet.setThrowExceptionIfNoHandlerFound(true);
+
+		// Add servlet to Tomcat and get the wrapper
+		var wrapper = Tomcat.addServlet(context, "dispatcherServlet", dispatcherServlet);
+		wrapper.setLoadOnStartup(1);
+		wrapper.setAsyncSupported(true);
+		context.addServletMappingDecoded("/*", "dispatcherServlet");
+
+		try {
+			// Configure and start the connector with async support
+			var connector = tomcat.getConnector();
+			connector.setAsyncTimeout(3000); // 3 seconds timeout for async requests
+			tomcat.start();
+			assertThat(tomcat.getServer().getState() == LifecycleState.STARTED);
+		}
+		catch (Exception e) {
+			throw new RuntimeException("Failed to start Tomcat", e);
+		}
+
+		this.clientBuilder = McpClient.sync(new HttpClientSseClientTransport("http://localhost:" + PORT));
+	}
+
+	@AfterEach
+	public void after() {
+		if (mcpServerTransport != null) {
+			mcpServerTransport.closeGracefully().block();
+		}
+		if (appContext != null) {
+			appContext.close();
+		}
+		if (tomcat != null) {
+			try {
+				tomcat.stop();
+				tomcat.destroy();
+			}
+			catch (LifecycleException e) {
+				throw new RuntimeException("Failed to stop Tomcat", e);
+			}
+		}
+	}
+
+	// ---------------------------------------
+	// Sampling Tests
+	// ---------------------------------------
+	@Test
+	void testCreateMessageWithoutInitialization() {
+		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+
+		var messages = List
+			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
+		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
+				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+
+		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
+			assertThat(error).isInstanceOf(McpError.class)
+				.hasMessage("Client must be initialized. Call the initialize method first!");
+		});
+	}
+
+	@Test
+	void testCreateMessageWithoutSamplingCapabilities() {
+
+		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+
+		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample " + "client", "0.0.0")).build();
+
+		InitializeResult initResult = client.initialize();
+		assertThat(initResult).isNotNull();
+
+		var messages = List
+			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
+		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
+				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+
+		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
+			assertThat(error).isInstanceOf(McpError.class)
+				.hasMessage("Client must be configured with sampling capabilities");
+		});
+	}
+
+	@Test
+	void testCreateMessageSuccess() throws InterruptedException {
+
+		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+
+		Function<CreateMessageRequest, CreateMessageResult> samplingHandler = request -> {
+			assertThat(request.messages()).hasSize(1);
+			assertThat(request.messages().get(0).content()).isInstanceOf(McpSchema.TextContent.class);
+
+			return new CreateMessageResult(Role.USER, new McpSchema.TextContent("Test message"), "MockModelName",
+					CreateMessageResult.StopReason.STOP_SEQUENCE);
+		};
+
+		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0"))
+			.capabilities(ClientCapabilities.builder().sampling().build())
+			.sampling(samplingHandler)
+			.build();
+
+		InitializeResult initResult = client.initialize();
+		assertThat(initResult).isNotNull();
+
+		var messages = List
+			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
+		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
+				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+
+		StepVerifier.create(mcpAsyncServer.createMessage(request)).consumeNextWith(result -> {
+			assertThat(result).isNotNull();
+			assertThat(result.role()).isEqualTo(Role.USER);
+			assertThat(result.content()).isInstanceOf(McpSchema.TextContent.class);
+			assertThat(((McpSchema.TextContent) result.content()).text()).isEqualTo("Test message");
+			assertThat(result.model()).isEqualTo("MockModelName");
+			assertThat(result.stopReason()).isEqualTo(CreateMessageResult.StopReason.STOP_SEQUENCE);
+		}).verifyComplete();
+	}
+
+	// ---------------------------------------
+	// Roots Tests
+	// ---------------------------------------
+	@Test
+	void testRootsSuccess() {
+		List<Root> roots = List.of(new Root("uri1://", "root1"), new Root("uri2://", "root2"));
+
+		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(roots)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		assertThat(rootsRef.get()).isNull();
+
+		assertThat(mcpServer.listRoots().roots()).containsAll(roots);
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(roots);
+		});
+
+		// Remove a root
+		mcpClient.removeRoot(roots.get(0).uri());
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(roots.get(1)));
+		});
+
+		// Add a new root
+		var root3 = new Root("uri3://", "root3");
+		mcpClient.addRoot(root3);
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(roots.get(1), root3));
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@Test
+	void testRootsWithoutCapability() {
+		var mcpServer = McpServer.sync(mcpServerTransport).rootsChangeConsumer(rootsUpdate -> {
+		}).build();
+
+		// Create client without roots capability
+		// No roots capability
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().build()).build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		// Attempt to list roots should fail
+		assertThatThrownBy(() -> mcpServer.listRoots().roots()).isInstanceOf(McpError.class)
+			.hasMessage("Roots not supported");
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@Test
+	void testRootsWithEmptyRootsList() {
+		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(List.of()) // Empty roots list
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).isEmpty();
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@Test
+	void testRootsWithMultipleConsumers() {
+		List<Root> roots = List.of(new Root("uri1://", "root1"));
+
+		AtomicReference<List<Root>> rootsRef1 = new AtomicReference<>();
+		AtomicReference<List<Root>> rootsRef2 = new AtomicReference<>();
+
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef1.set(rootsUpdate))
+			.rootsChangeConsumer(rootsUpdate -> rootsRef2.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(roots)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef1.get()).containsAll(roots);
+			assertThat(rootsRef2.get()).containsAll(roots);
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@Test
+	void testRootsServerCloseWithActiveSubscription() {
+		List<Root> roots = List.of(new Root("uri1://", "root1"));
+
+		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+			.build();
+
+		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
+			.roots(roots)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.rootsListChangedNotification();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(roots);
+		});
+
+		// Close server while subscription is active
+		mcpServer.close();
+
+		// Verify client can handle server closure gracefully
+		mcpClient.close();
+	}
+
+	// ---------------------------------------
+	// Tools Tests
+	// ---------------------------------------
+
+	String emptyJsonSchema = """
+			{
+				"$schema": "http://json-schema.org/draft-07/schema#",
+				"type": "object",
+				"properties": {}
+			}
+			""";
+
+	@Test
+	void testToolCallSuccess() {
+
+		var callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
+		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+					// perform a blocking call to a remote service
+					String response = RestClient.create()
+						.get()
+						.uri("https://github.com/modelcontextprotocol/specification/blob/main/README.md")
+						.retrieve()
+						.body(String.class);
+					assertThat(response).isNotBlank();
+					return callResponse;
+				});
+
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.capabilities(ServerCapabilities.builder().tools(true).build())
+			.tools(tool1)
+			.build();
+
+		var mcpClient = clientBuilder.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		assertThat(mcpClient.listTools().tools()).contains(tool1.tool());
+
+		CallToolResult response = mcpClient.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
+
+		assertThat(response).isNotNull();
+		assertThat(response).isEqualTo(callResponse);
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@Test
+	void testToolListChangeHandlingSuccess() {
+
+		var callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
+		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+					// perform a blocking call to a remote service
+					String response = RestClient.create()
+						.get()
+						.uri("https://github.com/modelcontextprotocol/specification/blob/main/README.md")
+						.retrieve()
+						.body(String.class);
+					assertThat(response).isNotBlank();
+					return callResponse;
+				});
+
+		var mcpServer = McpServer.sync(mcpServerTransport)
+			.capabilities(ServerCapabilities.builder().tools(true).build())
+			.tools(tool1)
+			.build();
+
+		AtomicReference<List<Tool>> rootsRef = new AtomicReference<>();
+		var mcpClient = clientBuilder.toolsChangeConsumer(toolsUpdate -> {
+			// perform a blocking call to a remote service
+			String response = RestClient.create()
+				.get()
+				.uri("https://github.com/modelcontextprotocol/specification/blob/main/README.md")
+				.retrieve()
+				.body(String.class);
+			assertThat(response).isNotBlank();
+			rootsRef.set(toolsUpdate);
+		}).build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		assertThat(rootsRef.get()).isNull();
+
+		assertThat(mcpClient.listTools().tools()).contains(tool1.tool());
+
+		mcpServer.notifyToolsListChanged();
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(tool1.tool()));
+		});
+
+		// Remove a tool
+		mcpServer.removeTool("tool1");
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).isEmpty();
+		});
+
+		// Add a new tool
+		McpServerFeatures.SyncToolRegistration tool2 = new McpServerFeatures.SyncToolRegistration(
+				new McpSchema.Tool("tool2", "tool2 description", emptyJsonSchema), request -> callResponse);
+
+		mcpServer.addTool(tool2);
+
+		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
+			assertThat(rootsRef.get()).containsAll(List.of(tool2.tool()));
+		});
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+	@Test
+	void testInitialize() {
+
+		var mcpServer = McpServer.sync(mcpServerTransport).build();
+
+		var mcpClient = clientBuilder.build();
+
+		InitializeResult initResult = mcpClient.initialize();
+		assertThat(initResult).isNotNull();
+
+		mcpClient.close();
+		mcpServer.close();
+	}
+
+}

mcp-spring/mcp-spring-webmvc/src/test/java/io/modelcontextprotocol/server/WebMvcSseIntegrationTests.java

@@ -12,7 +12,7 @@ import java.util.function.Function;
 import com.fasterxml.jackson.databind.ObjectMapper;
 import io.modelcontextprotocol.client.McpClient;
 import io.modelcontextprotocol.client.transport.HttpClientSseClientTransport;
-import io.modelcontextprotocol.server.transport.WebMvcSseServerTransport;
+import io.modelcontextprotocol.server.transport.WebMvcSseServerTransportProvider;
 import io.modelcontextprotocol.spec.McpError;
 import io.modelcontextprotocol.spec.McpSchema;
 import io.modelcontextprotocol.spec.McpSchema.CallToolResult;
@@ -31,6 +31,7 @@ import org.apache.catalina.startup.Tomcat;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import reactor.core.publisher.Mono;
 import reactor.test.StepVerifier;
 
 import org.springframework.context.annotation.Bean;
@@ -43,8 +44,8 @@ import org.springframework.web.servlet.function.RouterFunction;
 import org.springframework.web.servlet.function.ServerResponse;
 
 import static org.assertj.core.api.Assertions.assertThat;
-import static org.assertj.core.api.Assertions.assertThatThrownBy;
 import static org.awaitility.Awaitility.await;
+import static org.mockito.Mockito.mock;
 
 public class WebMvcSseIntegrationTests {
 
@@ -52,7 +53,7 @@ public class WebMvcSseIntegrationTests {
 
 	private static final String MESSAGE_ENDPOINT = "/mcp/message";
 
-	private WebMvcSseServerTransport mcpServerTransport;
+	private WebMvcSseServerTransportProvider mcpServerTransportProvider;
 
 	McpClient.SyncSpec clientBuilder;
 
@@ -61,13 +62,13 @@ public class WebMvcSseIntegrationTests {
 	static class TestConfig {
 
 		@Bean
-		public WebMvcSseServerTransport webMvcSseServerTransport() {
-			return new WebMvcSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		public WebMvcSseServerTransportProvider webMvcSseServerTransportProvider() {
+			return new WebMvcSseServerTransportProvider(new ObjectMapper(), MESSAGE_ENDPOINT);
 		}
 
 		@Bean
-		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransport transport) {
-			return transport.getRouterFunction();
+		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransportProvider transportProvider) {
+			return transportProvider.getRouterFunction();
 		}
 
 	}
@@ -97,7 +98,7 @@ public class WebMvcSseIntegrationTests {
 		appContext.refresh();
 
 		// Get the transport from Spring context
-		mcpServerTransport = appContext.getBean(WebMvcSseServerTransport.class);
+		mcpServerTransportProvider = appContext.getBean(WebMvcSseServerTransportProvider.class);
 
 		// Create DispatcherServlet with our Spring context
 		DispatcherServlet dispatcherServlet = new DispatcherServlet(appContext);
@@ -125,8 +126,8 @@ public class WebMvcSseIntegrationTests {
 
 	@AfterEach
 	public void after() {
-		if (mcpServerTransport != null) {
-			mcpServerTransport.closeGracefully().block();
+		if (mcpServerTransportProvider != null) {
+			mcpServerTransportProvider.closeGracefully().block();
 		}
 		if (appContext != null) {
 			appContext.close();
@@ -145,50 +146,37 @@ public class WebMvcSseIntegrationTests {
 	// ---------------------------------------
 	// Sampling Tests
 	// ---------------------------------------
-	@Test
-	void testCreateMessageWithoutInitialization() {
-		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
-
-		var messages = List
-			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
-		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
-
-		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
-				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
-
-		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
-			assertThat(error).isInstanceOf(McpError.class)
-				.hasMessage("Client must be initialized. Call the initialize method first!");
-		});
-	}
-
 	@Test
 	void testCreateMessageWithoutSamplingCapabilities() {
 
-		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+		McpServerFeatures.AsyncToolSpecification tool = new McpServerFeatures.AsyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
 
+					exchange.createMessage(mock(McpSchema.CreateMessageRequest.class)).block();
+
+					return Mono.just(mock(CallToolResult.class));
+				});
+
+		McpServer.async(mcpServerTransportProvider).serverInfo("test-server", "1.0.0").tools(tool).build();
+
+		// Create client without sampling capabilities
 		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample " + "client", "0.0.0")).build();
 
-		InitializeResult initResult = client.initialize();
-		assertThat(initResult).isNotNull();
+		assertThat(client.initialize()).isNotNull();
 
-		var messages = List
-			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
-		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
-
-		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
-				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
-
-		StepVerifier.create(mcpAsyncServer.createMessage(request)).verifyErrorSatisfies(error -> {
-			assertThat(error).isInstanceOf(McpError.class)
+		try {
+			client.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
+		}
+		catch (McpError e) {
+			assertThat(e).isInstanceOf(McpError.class)
 				.hasMessage("Client must be configured with sampling capabilities");
-		});
+		}
 	}
 
 	@Test
 	void testCreateMessageSuccess() throws InterruptedException {
 
-		var mcpAsyncServer = McpServer.async(mcpServerTransport).serverInfo("test-server", "1.0.0").build();
+		// Client
 
 		Function<CreateMessageRequest, CreateMessageResult> samplingHandler = request -> {
 			assertThat(request.messages()).hasSize(1);
@@ -198,29 +186,54 @@ public class WebMvcSseIntegrationTests {
 					CreateMessageResult.StopReason.STOP_SEQUENCE);
 		};
 
-		var client = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0"))
+		var mcpClient = clientBuilder.clientInfo(new McpSchema.Implementation("Sample client", "0.0.0"))
 			.capabilities(ClientCapabilities.builder().sampling().build())
 			.sampling(samplingHandler)
 			.build();
 
-		InitializeResult initResult = client.initialize();
+		// Server
+
+		CallToolResult callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")),
+				null);
+
+		McpServerFeatures.AsyncToolSpecification tool = new McpServerFeatures.AsyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
+
+					var messages = List.of(new McpSchema.SamplingMessage(McpSchema.Role.USER,
+							new McpSchema.TextContent("Test message")));
+					var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+
+					var craeteMessageRequest = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
+							McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(),
+							Map.of());
+
+					StepVerifier.create(exchange.createMessage(craeteMessageRequest)).consumeNextWith(result -> {
+						assertThat(result).isNotNull();
+						assertThat(result.role()).isEqualTo(Role.USER);
+						assertThat(result.content()).isInstanceOf(McpSchema.TextContent.class);
+						assertThat(((McpSchema.TextContent) result.content()).text()).isEqualTo("Test message");
+						assertThat(result.model()).isEqualTo("MockModelName");
+						assertThat(result.stopReason()).isEqualTo(CreateMessageResult.StopReason.STOP_SEQUENCE);
+					}).verifyComplete();
+
+					return Mono.just(callResponse);
+				});
+
+		var mcpServer = McpServer.async(mcpServerTransportProvider)
+			.serverInfo("test-server", "1.0.0")
+			.tools(tool)
+			.build();
+
+		InitializeResult initResult = mcpClient.initialize();
 		assertThat(initResult).isNotNull();
 
-		var messages = List
-			.of(new McpSchema.SamplingMessage(McpSchema.Role.USER, new McpSchema.TextContent("Test message")));
-		var modelPrefs = new McpSchema.ModelPreferences(List.of(), 1.0, 1.0, 1.0);
+		CallToolResult response = mcpClient.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
 
-		var request = new McpSchema.CreateMessageRequest(messages, modelPrefs, null,
-				McpSchema.CreateMessageRequest.ContextInclusionStrategy.NONE, null, 100, List.of(), Map.of());
+		assertThat(response).isNotNull();
+		assertThat(response).isEqualTo(callResponse);
 
-		StepVerifier.create(mcpAsyncServer.createMessage(request)).consumeNextWith(result -> {
-			assertThat(result).isNotNull();
-			assertThat(result.role()).isEqualTo(Role.USER);
-			assertThat(result.content()).isInstanceOf(McpSchema.TextContent.class);
-			assertThat(((McpSchema.TextContent) result.content()).text()).isEqualTo("Test message");
-			assertThat(result.model()).isEqualTo("MockModelName");
-			assertThat(result.stopReason()).isEqualTo(CreateMessageResult.StopReason.STOP_SEQUENCE);
-		}).verifyComplete();
+		mcpClient.close();
+		mcpServer.close();
 	}
 
 	// ---------------------------------------
@@ -231,8 +244,8 @@ public class WebMvcSseIntegrationTests {
 		List<Root> roots = List.of(new Root("uri1://", "root1"), new Root("uri2://", "root2"));
 
 		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
@@ -244,8 +257,6 @@ public class WebMvcSseIntegrationTests {
 
 		assertThat(rootsRef.get()).isNull();
 
-		assertThat(mcpServer.listRoots().roots()).containsAll(roots);
-
 		mcpClient.rootsListChangedNotification();
 
 		await().atMost(Duration.ofSeconds(5)).untilAsserted(() -> {
@@ -273,29 +284,42 @@ public class WebMvcSseIntegrationTests {
 
 	@Test
 	void testRootsWithoutCapability() {
-		var mcpServer = McpServer.sync(mcpServerTransport).rootsChangeConsumer(rootsUpdate -> {
-		}).build();
+
+		McpServerFeatures.SyncToolSpecification tool = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
+
+					exchange.listRoots(); // try to list roots
+
+					return mock(CallToolResult.class);
+				});
+
+		var mcpServer = McpServer.sync(mcpServerTransportProvider).rootsChangeHandler((exchange, rootsUpdate) -> {
+		}).tools(tool).build();
 
 		// Create client without roots capability
 		// No roots capability
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().build()).build();
 
-		InitializeResult initResult = mcpClient.initialize();
-		assertThat(initResult).isNotNull();
+		assertThat(mcpClient.initialize()).isNotNull();
 
 		// Attempt to list roots should fail
-		assertThatThrownBy(() -> mcpServer.listRoots().roots()).isInstanceOf(McpError.class)
-			.hasMessage("Roots not supported");
+		try {
+			mcpClient.callTool(new McpSchema.CallToolRequest("tool1", Map.of()));
+		}
+		catch (McpError e) {
+			assertThat(e).isInstanceOf(McpError.class).hasMessage("Roots not supported");
+		}
 
 		mcpClient.close();
 		mcpServer.close();
 	}
 
 	@Test
-	void testRootsWithEmptyRootsList() {
+	void testRootsNotifciationWithEmptyRootsList() {
 		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
@@ -316,23 +340,22 @@ public class WebMvcSseIntegrationTests {
 	}
 
 	@Test
-	void testRootsWithMultipleConsumers() {
+	void testRootsWithMultipleHandlers() {
 		List<Root> roots = List.of(new Root("uri1://", "root1"));
 
 		AtomicReference<List<Root>> rootsRef1 = new AtomicReference<>();
 		AtomicReference<List<Root>> rootsRef2 = new AtomicReference<>();
 
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef1.set(rootsUpdate))
-			.rootsChangeConsumer(rootsUpdate -> rootsRef2.set(rootsUpdate))
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef1.set(rootsUpdate))
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef2.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
 			.roots(roots)
 			.build();
 
-		InitializeResult initResult = mcpClient.initialize();
-		assertThat(initResult).isNotNull();
+		assertThat(mcpClient.initialize()).isNotNull();
 
 		mcpClient.rootsListChangedNotification();
 
@@ -350,8 +373,8 @@ public class WebMvcSseIntegrationTests {
 		List<Root> roots = List.of(new Root("uri1://", "root1"));
 
 		AtomicReference<List<Root>> rootsRef = new AtomicReference<>();
-		var mcpServer = McpServer.sync(mcpServerTransport)
-			.rootsChangeConsumer(rootsUpdate -> rootsRef.set(rootsUpdate))
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
+			.rootsChangeHandler((exchange, rootsUpdate) -> rootsRef.set(rootsUpdate))
 			.build();
 
 		var mcpClient = clientBuilder.capabilities(ClientCapabilities.builder().roots(true).build())
@@ -390,8 +413,8 @@ public class WebMvcSseIntegrationTests {
 	void testToolCallSuccess() {
 
 		var callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
-		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
-				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+		McpServerFeatures.SyncToolSpecification tool1 = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
 					// perform a blocking call to a remote service
 					String response = RestClient.create()
 						.get()
@@ -402,7 +425,7 @@ public class WebMvcSseIntegrationTests {
 					return callResponse;
 				});
 
-		var mcpServer = McpServer.sync(mcpServerTransport)
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
 			.capabilities(ServerCapabilities.builder().tools(true).build())
 			.tools(tool1)
 			.build();
@@ -427,8 +450,8 @@ public class WebMvcSseIntegrationTests {
 	void testToolListChangeHandlingSuccess() {
 
 		var callResponse = new McpSchema.CallToolResult(List.of(new McpSchema.TextContent("CALL RESPONSE")), null);
-		McpServerFeatures.SyncToolRegistration tool1 = new McpServerFeatures.SyncToolRegistration(
-				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), request -> {
+		McpServerFeatures.SyncToolSpecification tool1 = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool1", "tool1 description", emptyJsonSchema), (exchange, request) -> {
 					// perform a blocking call to a remote service
 					String response = RestClient.create()
 						.get()
@@ -439,7 +462,7 @@ public class WebMvcSseIntegrationTests {
 					return callResponse;
 				});
 
-		var mcpServer = McpServer.sync(mcpServerTransport)
+		var mcpServer = McpServer.sync(mcpServerTransportProvider)
 			.capabilities(ServerCapabilities.builder().tools(true).build())
 			.tools(tool1)
 			.build();
@@ -477,8 +500,8 @@ public class WebMvcSseIntegrationTests {
 		});
 
 		// Add a new tool
-		McpServerFeatures.SyncToolRegistration tool2 = new McpServerFeatures.SyncToolRegistration(
-				new McpSchema.Tool("tool2", "tool2 description", emptyJsonSchema), request -> callResponse);
+		McpServerFeatures.SyncToolSpecification tool2 = new McpServerFeatures.SyncToolSpecification(
+				new McpSchema.Tool("tool2", "tool2 description", emptyJsonSchema), (exchange, request) -> callResponse);
 
 		mcpServer.addTool(tool2);
 
@@ -493,7 +516,7 @@ public class WebMvcSseIntegrationTests {
 	@Test
 	void testInitialize() {
 
-		var mcpServer = McpServer.sync(mcpServerTransport).build();
+		var mcpServer = McpServer.sync(mcpServerTransportProvider).build();
 
 		var mcpClient = clientBuilder.build();
 

mcp-spring/mcp-spring-webmvc/src/test/java/io/modelcontextprotocol/server/WebMvcSseSyncServerTransportDeprecatedTests.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2024-2024 the original author or authors.
+ */
+
+package io.modelcontextprotocol.server;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import io.modelcontextprotocol.server.transport.WebMvcSseServerTransport;
+import io.modelcontextprotocol.spec.ServerMcpTransport;
+import org.apache.catalina.Context;
+import org.apache.catalina.LifecycleException;
+import org.apache.catalina.startup.Tomcat;
+import org.junit.jupiter.api.Timeout;
+
+import org.springframework.context.annotation.Bean;
+import org.springframework.context.annotation.Configuration;
+import org.springframework.web.context.support.AnnotationConfigWebApplicationContext;
+import org.springframework.web.servlet.DispatcherServlet;
+import org.springframework.web.servlet.config.annotation.EnableWebMvc;
+import org.springframework.web.servlet.function.RouterFunction;
+import org.springframework.web.servlet.function.ServerResponse;
+
+@Deprecated
+@Timeout(15)
+class WebMvcSseSyncServerTransportDeprecatedTests extends AbstractMcpSyncServerDeprecatedTests {
+
+	private static final String MESSAGE_ENDPOINT = "/mcp/message";
+
+	private static final int PORT = 8181;
+
+	private Tomcat tomcat;
+
+	private WebMvcSseServerTransport transport;
+
+	@Configuration
+	@EnableWebMvc
+	static class TestConfig {
+
+		@Bean
+		public WebMvcSseServerTransport webMvcSseServerTransport() {
+			return new WebMvcSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		}
+
+		@Bean
+		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransport transport) {
+			return transport.getRouterFunction();
+		}
+
+	}
+
+	private AnnotationConfigWebApplicationContext appContext;
+
+	@Override
+	protected ServerMcpTransport createMcpTransport() {
+		// Set up Tomcat first
+		tomcat = new Tomcat();
+		tomcat.setPort(PORT);
+
+		// Set Tomcat base directory to java.io.tmpdir to avoid permission issues
+		String baseDir = System.getProperty("java.io.tmpdir");
+		tomcat.setBaseDir(baseDir);
+
+		// Use the same directory for document base
+		Context context = tomcat.addContext("", baseDir);
+
+		// Create and configure Spring WebMvc context
+		appContext = new AnnotationConfigWebApplicationContext();
+		appContext.register(TestConfig.class);
+		appContext.setServletContext(context.getServletContext());
+		appContext.refresh();
+
+		// Get the transport from Spring context
+		transport = appContext.getBean(WebMvcSseServerTransport.class);
+
+		// Create DispatcherServlet with our Spring context
+		DispatcherServlet dispatcherServlet = new DispatcherServlet(appContext);
+		// dispatcherServlet.setThrowExceptionIfNoHandlerFound(true);
+
+		// Add servlet to Tomcat and get the wrapper
+		var wrapper = Tomcat.addServlet(context, "dispatcherServlet", dispatcherServlet);
+		wrapper.setLoadOnStartup(1);
+		context.addServletMappingDecoded("/*", "dispatcherServlet");
+
+		try {
+			tomcat.start();
+			tomcat.getConnector(); // Create and start the connector
+		}
+		catch (LifecycleException e) {
+			throw new RuntimeException("Failed to start Tomcat", e);
+		}
+
+		return transport;
+	}
+
+	@Override
+	protected void onStart() {
+	}
+
+	@Override
+	protected void onClose() {
+		if (transport != null) {
+			transport.closeGracefully().block();
+		}
+		if (appContext != null) {
+			appContext.close();
+		}
+		if (tomcat != null) {
+			try {
+				tomcat.stop();
+				tomcat.destroy();
+			}
+			catch (LifecycleException e) {
+				throw new RuntimeException("Failed to stop Tomcat", e);
+			}
+		}
+	}
+
+}

mcp-spring/mcp-spring-webmvc/src/test/java/io/modelcontextprotocol/server/WebMvcSseSyncServerTransportTests.java

@@ -5,8 +5,7 @@
 package io.modelcontextprotocol.server;
 
 import com.fasterxml.jackson.databind.ObjectMapper;
-import io.modelcontextprotocol.server.transport.WebMvcSseServerTransport;
-import io.modelcontextprotocol.spec.ServerMcpTransport;
+import io.modelcontextprotocol.server.transport.WebMvcSseServerTransportProvider;
 import org.apache.catalina.Context;
 import org.apache.catalina.LifecycleException;
 import org.apache.catalina.startup.Tomcat;
@@ -29,20 +28,20 @@ class WebMvcSseSyncServerTransportTests extends AbstractMcpSyncServerTests {
 
 	private Tomcat tomcat;
 
-	private WebMvcSseServerTransport transport;
+	private WebMvcSseServerTransportProvider transportProvider;
 
 	@Configuration
 	@EnableWebMvc
 	static class TestConfig {
 
 		@Bean
-		public WebMvcSseServerTransport webMvcSseServerTransport() {
-			return new WebMvcSseServerTransport(new ObjectMapper(), MESSAGE_ENDPOINT);
+		public WebMvcSseServerTransportProvider webMvcSseServerTransportProvider() {
+			return new WebMvcSseServerTransportProvider(new ObjectMapper(), MESSAGE_ENDPOINT);
 		}
 
 		@Bean
-		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransport transport) {
-			return transport.getRouterFunction();
+		public RouterFunction<ServerResponse> routerFunction(WebMvcSseServerTransportProvider transportProvider) {
+			return transportProvider.getRouterFunction();
 		}
 
 	}
@@ -50,7 +49,7 @@ class WebMvcSseSyncServerTransportTests extends AbstractMcpSyncServerTests {
 	private AnnotationConfigWebApplicationContext appContext;
 
 	@Override
-	protected ServerMcpTransport createMcpTransport() {
+	protected WebMvcSseServerTransportProvider createMcpTransportProvider() {
 		// Set up Tomcat first
 		tomcat = new Tomcat();
 		tomcat.setPort(PORT);
@@ -69,7 +68,7 @@ class WebMvcSseSyncServerTransportTests extends AbstractMcpSyncServerTests {
 		appContext.refresh();
 
 		// Get the transport from Spring context
-		transport = appContext.getBean(WebMvcSseServerTransport.class);
+		transportProvider = appContext.getBean(WebMvcSseServerTransportProvider.class);
 
 		// Create DispatcherServlet with our Spring context
 		DispatcherServlet dispatcherServlet = new DispatcherServlet(appContext);
@@ -88,7 +87,7 @@ class WebMvcSseSyncServerTransportTests extends AbstractMcpSyncServerTests {
 			throw new RuntimeException("Failed to start Tomcat", e);
 		}
 
-		return transport;
+		return transportProvider;
 	}
 
 	@Override
@@ -97,8 +96,8 @@ class WebMvcSseSyncServerTransportTests extends AbstractMcpSyncServerTests {
 
 	@Override
 	protected void onClose() {
-		if (transport != null) {
-			transport.closeGracefully().block();
+		if (transportProvider != null) {
+			transportProvider.closeGracefully().block();
 		}
 		if (appContext != null) {
 			appContext.close();

mcp-test/src/main/java/io/modelcontextprotocol/MockMcpTransport.java

@@ -11,19 +11,19 @@ import java.util.function.Function;
 
 import com.fasterxml.jackson.core.type.TypeReference;
 import com.fasterxml.jackson.databind.ObjectMapper;
-import io.modelcontextprotocol.spec.ClientMcpTransport;
+import io.modelcontextprotocol.spec.McpClientTransport;
 import io.modelcontextprotocol.spec.McpSchema;
-import io.modelcontextprotocol.spec.ServerMcpTransport;
 import io.modelcontextprotocol.spec.McpSchema.JSONRPCNotification;
 import io.modelcontextprotocol.spec.McpSchema.JSONRPCRequest;
+import io.modelcontextprotocol.spec.ServerMcpTransport;
 import reactor.core.publisher.Mono;
 import reactor.core.publisher.Sinks;
 
 /**
- * A mock implementation of the {@link ClientMcpTransport} and {@link ServerMcpTransport}
+ * A mock implementation of the {@link McpClientTransport} and {@link ServerMcpTransport}
  * interfaces.
  */
-public class MockMcpTransport implements ClientMcpTransport, ServerMcpTransport {
+public class MockMcpTransport implements McpClientTransport, ServerMcpTransport {
 
 	private final Sinks.Many<McpSchema.JSONRPCMessage> inbound = Sinks.many().unicast().onBackpressureBuffer();