gnodet-bot commented on code in PR #30343:
URL: https://github.com/apache/camel/pull/30343#discussion_r4614802006
##########
components/camel-ai/camel-mcp-server/src/main/java/org/apache/camel/component/mcp/server/vertx/VertxMcpStreamableServerTransportProvider.java:
##########
@@ -499,9 +532,142 @@ private void handlePost(RoutingContext ctx, Context
connection) throws Exception
badRequestErrors.add("application/json required in Accept header");
}
+ String body = ctx.body().asString();
+ if (!sessionsEnabled || protocolEra != McpProtocolEra.LEGACY) {
+ routePost(ctx, connection, body, badRequestErrors);
+ return;
+ }
+ handleSessionPost(ctx, connection, body, badRequestErrors);
+ }
+
+ /**
+ * Serves a POST when the endpoint does more than the legacy protocol
versions with sessions: protocol version
+ * 2026-07-28, or the legacy versions without sessions. The body decides
which protocol version a request belongs to
+ * (see {@link McpProtocolEraClassifier}).
+ */
+ private void routePost(RoutingContext ctx, Context connection, String
body, List<String> badRequestErrors)
+ throws Exception {
+ if (protocolEra == McpProtocolEra.MODERN) {
+ if (respondBadRequest(connection, ctx, badRequestErrors)) {
+ return;
+ }
+ // a legacy initialize is answered by the modern server with the
versions it supports
+ modernTransport.handle(body, new VertxHeaderAccessor(ctx),
toTransportContext(ctx), ctx.response(),
+ connection);
+ return;
+ }
+ Object tree;
+ try {
+ tree = jsonMapper.readValue(body, Object.class);
+ } catch (Exception e) {
+ LOG.debug("Invalid MCP message: {}", e.getMessage());
+ respondError(connection, ctx, 400,
McpSchema.ErrorCodes.PARSE_ERROR, "Invalid message format");
+ return;
+ }
+ McpProtocolEraClassifier.Verdict verdict
+ =
McpProtocolEraClassifier.classify(ctx.request().getHeader(PROTOCOL_VERSION),
tree);
+ if (verdict.rejected()) {
+ respondError(connection, ctx, 400,
McpProtocolEraClassifier.HEADER_MISMATCH, verdict.message());
+ return;
+ }
+ if (verdict.era() == McpProtocolEraClassifier.Era.MODERN) {
+ if (modernTransport == null) {
+ // the legacy era without sessions: never serve a 2026-07-28
request as a legacy one
+ respondUnsupportedVersion(connection, ctx, tree);
Review Comment:
⚠️ **JSON-RPC 2.0 §4.2 violation:** `respondUnsupportedVersion()` is called
here for any MODERN-era message, including notifications (messages without an
`id` field). JSON-RPC 2.0 §4.2: *"The Server MUST NOT reply to a Notification."*
Notifications are identified by the absence of the `id` member. Suggested
guard before this call:
```java
// Do not reply to JSON-RPC notifications
if (tree instanceof Map<?, ?> msg && !msg.containsKey("id")) {
// 202 Accepted with no body, per HTTP semantics for fire-and-forget
endWithStatus(connection, ctx, 202);
return;
}
respondUnsupportedVersion(connection, ctx, tree);
```
##########
components/camel-ai/camel-mcp-server/src/main/java/org/apache/camel/component/mcp/server/vertx/VertxMcpStreamableServerTransportProvider.java:
##########
@@ -499,9 +532,142 @@ private void handlePost(RoutingContext ctx, Context
connection) throws Exception
badRequestErrors.add("application/json required in Accept header");
}
+ String body = ctx.body().asString();
+ if (!sessionsEnabled || protocolEra != McpProtocolEra.LEGACY) {
+ routePost(ctx, connection, body, badRequestErrors);
+ return;
+ }
+ handleSessionPost(ctx, connection, body, badRequestErrors);
+ }
+
+ /**
+ * Serves a POST when the endpoint does more than the legacy protocol
versions with sessions: protocol version
+ * 2026-07-28, or the legacy versions without sessions. The body decides
which protocol version a request belongs to
+ * (see {@link McpProtocolEraClassifier}).
+ */
+ private void routePost(RoutingContext ctx, Context connection, String
body, List<String> badRequestErrors)
+ throws Exception {
+ if (protocolEra == McpProtocolEra.MODERN) {
+ if (respondBadRequest(connection, ctx, badRequestErrors)) {
+ return;
+ }
+ // a legacy initialize is answered by the modern server with the
versions it supports
+ modernTransport.handle(body, new VertxHeaderAccessor(ctx),
toTransportContext(ctx), ctx.response(),
+ connection);
+ return;
+ }
+ Object tree;
+ try {
+ tree = jsonMapper.readValue(body, Object.class);
+ } catch (Exception e) {
+ LOG.debug("Invalid MCP message: {}", e.getMessage());
+ respondError(connection, ctx, 400,
McpSchema.ErrorCodes.PARSE_ERROR, "Invalid message format");
+ return;
+ }
+ McpProtocolEraClassifier.Verdict verdict
+ =
McpProtocolEraClassifier.classify(ctx.request().getHeader(PROTOCOL_VERSION),
tree);
+ if (verdict.rejected()) {
+ respondError(connection, ctx, 400,
McpProtocolEraClassifier.HEADER_MISMATCH, verdict.message());
+ return;
+ }
+ if (verdict.era() == McpProtocolEraClassifier.Era.MODERN) {
+ if (modernTransport == null) {
+ // the legacy era without sessions: never serve a 2026-07-28
request as a legacy one
+ respondUnsupportedVersion(connection, ctx, tree);
+ return;
+ }
+ if (respondBadRequest(connection, ctx, badRequestErrors)) {
+ return;
+ }
+ modernTransport.handle(body, new VertxHeaderAccessor(ctx),
toTransportContext(ctx), ctx.response(),
+ connection);
+ return;
+ }
+ if (sessionsEnabled) {
+ // exactly as with the legacy era, including which messages need
the Accept header
+ handleSessionPost(ctx, connection, body, badRequestErrors);
+ return;
+ }
+ if (respondBadRequest(connection, ctx, badRequestErrors)) {
+ return;
+ }
+ handleStatelessPost(ctx, connection, body);
+ }
+
+ /**
+ * Serves a client of a legacy protocol version without a session.
+ */
+ private void handleStatelessPost(RoutingContext ctx, Context connection,
String body) throws Exception {
+ McpSchema.JSONRPCMessage message;
+ try {
+ message = McpSchema.deserializeJsonRpcMessage(jsonMapper, body);
+ } catch (Exception e) {
+ LOG.debug("Invalid MCP message: {}", e.getMessage());
+ respondError(connection, ctx, 400,
McpSchema.ErrorCodes.PARSE_ERROR, "Invalid message format");
+ return;
+ }
+ VertxMcpStatelessServerTransport.Answer answer =
statelessTransport.handle(toTransportContext(ctx), message);
+ if (answer == null) {
+ respondError(connection, ctx, 400,
McpSchema.ErrorCodes.INVALID_REQUEST,
+ "The server accepts either requests or notifications");
+ } else if (answer.body() == null) {
+ endWithStatus(connection, ctx, answer.status());
+ } else {
+ connection.runOnContext(v -> ctx.response()
+ .setStatusCode(answer.status())
+ .putHeader("Content-Type", APPLICATION_JSON)
+ .end(answer.body()));
+ }
+ }
+
+ /**
+ * Answers a request of a protocol version this endpoint does not serve
(2026-07-28 or an unknown one, on an
+ * endpoint that serves only the legacy versions without sessions) with
HTTP 400 and an UnsupportedProtocolVersion
+ * error naming the versions it supports, so a client that also speaks a
legacy version falls back to
+ * {@code initialize}.
+ */
+ private void respondUnsupportedVersion(Context connection, RoutingContext
ctx, Object tree) {
+ Object id = tree instanceof Map<?, ?> message ? message.get("id") :
null;
+ String requested = ctx.request().getHeader(PROTOCOL_VERSION);
+ if (tree instanceof Map<?, ?> message && message.get("params")
instanceof Map<?, ?> params
+ && params.get("_meta") instanceof Map<?, ?> meta
+ &&
meta.get(McpProtocolEraClassifier.PROTOCOL_VERSION_META_KEY) instanceof String
version) {
+ requested = version;
+ }
+ Map<String, Object> data = new LinkedHashMap<>();
+ data.put("supported", McpProtocolEraClassifier.LEGACY_VERSIONS);
+ data.put("requested", requested);
+ Map<String, Object> error = new LinkedHashMap<>();
+ error.put("code",
McpProtocolEraClassifier.UNSUPPORTED_PROTOCOL_VERSION);
+ error.put("message", "Unsupported protocol version");
+ error.put("data", data);
+ Map<String, Object> response = new LinkedHashMap<>();
+ response.put("jsonrpc", McpSchema.JSONRPC_VERSION);
+ if (id != null) {
Review Comment:
⚠️ **JSON-RPC 2.0 §5.1 violation:** when `id` is `null` (i.e. the message is
a notification), this guard omits the `id` field from the error response
entirely. The spec requires `"id": null` in error responses when the id cannot
be determined.
```suggestion
response.put("id", id);
```
Note that the outer caller should also guard against sending any response to
notifications at all (see general comment), but if a response is sent, the `id`
must be `null` rather than absent.
##########
components/camel-ai/camel-mcp-server/src/main/java/org/apache/camel/component/mcp/server/vertx/VertxMcpModernTransport.java:
##########
@@ -0,0 +1,422 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements. See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License. You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.apache.camel.component.mcp.server.vertx;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+
+import io.modelcontextprotocol.common.McpTransportContext;
+import io.modelcontextprotocol.json.McpJsonMapper;
+import io.modelcontextprotocol.modern.JsonRpc;
+import io.modelcontextprotocol.modern.JsonRpc.JSONRPCMessage;
+import io.modelcontextprotocol.modern.JsonRpc.JSONRPCNotification;
+import io.modelcontextprotocol.modern.JsonRpc.JSONRPCRequest;
+import io.modelcontextprotocol.modern.JsonRpc.JSONRPCResponse;
+import io.modelcontextprotocol.modern.JsonRpc.JSONRPCResponse.JSONRPCError;
+import io.modelcontextprotocol.modern.McpHttp;
+import io.modelcontextprotocol.modern.McpSchema;
+import io.modelcontextprotocol.modern.McpSchema.ErrorCodes;
+import io.modelcontextprotocol.modern.server.McpHeaders;
+import io.modelcontextprotocol.modern.server.McpRequestContext;
+import io.modelcontextprotocol.modern.server.McpRequestManager;
+import io.modelcontextprotocol.modern.server.McpServer;
+import io.modelcontextprotocol.modern.server.McpTransportResponse;
+import io.modelcontextprotocol.modern.server.RequestStateCodec;
+import io.modelcontextprotocol.modern.server.feature.McpChangeFeed;
+import io.modelcontextprotocol.modern.server.feature.PromptsFeature;
+import io.modelcontextprotocol.modern.server.feature.ResourcesFeature;
+import io.modelcontextprotocol.modern.server.feature.ToolsFeature;
+import io.modelcontextprotocol.modern.server.transport.McpHeaderDecoder;
+import io.modelcontextprotocol.server.transport.HeaderAccessor;
+import io.vertx.core.Context;
+import io.vertx.core.http.HttpServerResponse;
+import org.apache.camel.component.mcp.server.McpServerIcon;
+import org.apache.camel.component.mcp.server.McpServerInfo;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import reactor.core.Disposable;
+import reactor.core.Disposables;
+import reactor.core.publisher.Flux;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+
+/**
+ * Serves requests of MCP protocol version 2026-07-28 and later: stateless,
one self-contained request per POST,
+ * answered with a single JSON object or a Server-Sent Events stream scoped to
that request.
+ * <p>
+ * This is the Vert.x counterpart of the POST handling of the MCP SDK's {@code
HttpServletMcpTransport}; the HTTP
+ * concerns shared with the other protocol versions (routes, origin, host and
OAuth checks) stay in
+ * {@link VertxMcpStreamableServerTransportProvider}, which calls {@link
#handle} on a worker thread. A request's
+ * {@code Mcp-Method}, {@code MCP-Protocol-Version} and {@code Mcp-Name}
headers are checked against its body before it
+ * reaches the {@link McpRequestManager}; a mismatch is answered with HTTP 400
and error {@code -32020}. A
+ * {@code subscriptions/listen} stream does not hold a worker thread, and a
stream that the client closes is cancelled.
+ */
+final class VertxMcpModernTransport {
+
+ private static final Logger LOG =
LoggerFactory.getLogger(VertxMcpModernTransport.class);
+
+ static final Duration DEFAULT_KEEP_ALIVE_INTERVAL = Duration.ofSeconds(30);
+
+ private static final String APPLICATION_JSON = "application/json";
+ private static final String TEXT_EVENT_STREAM = "text/event-stream";
+ private static final String KEEP_ALIVE_FRAME = ":\n\n";
+ // the handshake of the protocol versions before 2026-07-28 (the SDK
constant is deprecated)
+ private static final String METHOD_INITIALIZE = "initialize";
+
+ /**
+ * The HTTP status of each JSON-RPC error code, as the MCP SDK's servlet
transport answers them; any other code is
+ * answered with HTTP 200.
+ */
+ private static final Map<Integer, Integer> ERROR_STATUSES = Map.of(
+ ErrorCodes.PARSE_ERROR, 400,
+ ErrorCodes.INVALID_REQUEST, 400,
+ ErrorCodes.INVALID_PARAMS, 400,
+ ErrorCodes.HEADER_MISMATCH, 400,
+ ErrorCodes.MISSING_REQUIRED_CLIENT_CAPABILITY, 400,
+ ErrorCodes.UNSUPPORTED_PROTOCOL_VERSION, 400,
+ ErrorCodes.METHOD_NOT_FOUND, 404);
+
+ /**
+ * Camel tools, resources and prompts never answer with an {@code
InputRequiredResult}, so no request state is ever
+ * sealed, and a request state sent by a client cannot have come from this
server. This also spares the
+ * multi-instance warning of the SDK's default codec, whose per-process
key Camel would never use.
+ */
+ private static final RequestStateCodec NO_REQUEST_STATE = new
RequestStateCodec() {
+ @Override
+ public String seal(McpRequestContext ctx, String state) {
+ throw new IllegalStateException("Camel MCP server never asks the
client for input");
+ }
+
+ @Override
+ public String open(McpRequestContext ctx, String sealed) {
+ return null;
+ }
+ };
+
+ private final McpRequestManager requestManager;
+ private final McpJsonMapper jsonMapper;
+ private final Duration keepAliveInterval;
+
+ VertxMcpModernTransport(McpRequestManager requestManager, McpJsonMapper
jsonMapper, Duration keepAliveInterval) {
+ this.requestManager = requestManager;
+ this.jsonMapper = jsonMapper;
+ this.keepAliveInterval = keepAliveInterval;
+ }
+
+ /**
+ * Builds the transport over an MCP SDK modern server that serves the
tools, resources and prompts of the catalog
+ * and tells listening clients when a list changes.
+ */
+ static VertxMcpModernTransport create(
+ McpServerInfo info, McpModernCatalog catalog, McpChangeFeed
changes, McpJsonMapper jsonMapper,
+ Duration keepAliveInterval) {
+ McpServer.Builder builder = McpServer.builder()
+ .serverInfo(buildServerInfo(info))
+ .jsonMapper(jsonMapper)
+ .feature(ToolsFeature.ofSync(catalog.toolRepository()))
+ .feature(ResourcesFeature.ofSync(catalog.resourceRepository()))
+ .feature(PromptsFeature.ofSync(catalog.promptRepository()))
+ .subscriptions(changes)
+ .requestStateCodec(NO_REQUEST_STATE);
+ if (info.instructions() != null && !info.instructions().isBlank()) {
+ builder.instructions(info.instructions());
+ }
+ return new VertxMcpModernTransport(builder.build(), jsonMapper,
keepAliveInterval);
+ }
+
+ private static McpSchema.Implementation buildServerInfo(McpServerInfo
info) {
+ McpSchema.Implementation.Builder builder =
McpSchema.Implementation.builder(info.serverName(), info.version());
+ if (info.title() != null && !info.title().isBlank()) {
+ builder.title(info.title());
+ }
+ if (info.description() != null && !info.description().isBlank()) {
+ builder.description(info.description());
+ }
+ if (info.websiteUrl() != null && !info.websiteUrl().isBlank()) {
+ builder.websiteUrl(info.websiteUrl());
+ }
+ if (info.icons() != null && !info.icons().isEmpty()) {
+
builder.icons(info.icons().stream().map(VertxMcpModernTransport::buildIcon).toList());
+ }
+ return builder.build();
+ }
+
+ private static McpSchema.Icon buildIcon(McpServerIcon icon) {
+ McpSchema.Icon.Builder builder = McpSchema.Icon.builder(icon.src());
+ if (icon.mimeType() != null && !icon.mimeType().isBlank()) {
+ builder.mimeType(icon.mimeType());
+ }
+ if (icon.sizes() != null && !icon.sizes().isEmpty()) {
+ builder.sizes(icon.sizes());
+ }
+ if (icon.theme() != null && !icon.theme().isBlank()) {
+ builder.theme(icon.theme());
+ }
+ return builder.build();
+ }
+
+ /**
+ * Ends the {@code subscriptions/listen} streams.
+ */
+ void closeGracefully() {
+ if (requestManager instanceof McpServer server) {
+ server.closeGracefully();
+ }
+ }
+
+ /**
+ * Handles one POST on the calling (worker) thread; every write goes
through the connection's event-loop context.
+ *
+ * @param body the request body
+ * @param headers the request headers
+ * @param transportContext the caller identity of the request
+ * @param response the HTTP response
+ * @param connection the event-loop context of the connection
+ */
+ void handle(
+ String body, HeaderAccessor headers, McpTransportContext
transportContext,
+ HttpServerResponse response, Context connection) {
+ JSONRPCMessage message;
+ try {
+ message = JsonRpc.deserializeMessage(jsonMapper, body);
Review Comment:
ℹ️ **Minor double-parse (informational):** In DUAL/LEGACY era, the caller's
`routePost()` already parsed `body` into `Object tree` for era classification
(`jsonMapper.readValue(body, Object.class)`), then discards `tree` and passes
the raw `body` string here, causing a second parse. Consider an overload that
accepts the pre-parsed object to avoid the redundant deserialization, though
this is not a correctness issue.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: [email protected]
For queries about this service, please contact Infrastructure at:
[email protected]