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]

Reply via email to