From 7fab07710b3cb046c861eb428c6568513af9a6a2 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Tue, 20 Oct 2026 19:06:22 -0400
Subject: [PATCH 01/18] Add R0 protocol SDK interoperability spikes

Pin MCP and grpc-java SDKs in test scope and add bounded interoperability probes over the Restlet HTTP/2 engine. The gRPC prototype exercises the grpc-core client transport SPI and a socket-less Restlet server host for unary exchanges.

R0 remains a draft pending streaming, lifecycle, MCP SSE/STDIO, and profile compatibility gates.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Signed-off-by: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
---
 org.restlet/pom.xml                           |  38 +
 .../GrpcSdkTransportSpikeTestCase.java        | 939 ++++++++++++++++++
 .../McpSdkTransportSpikeTestCase.java         | 336 +++++++
 3 files changed, 1313 insertions(+)
 create mode 100644 org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
 create mode 100644 org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java

diff --git a/org.restlet/pom.xml b/org.restlet/pom.xml
index c9017eb4be..5f2ad34ae7 100644
--- a/org.restlet/pom.xml
+++ b/org.restlet/pom.xml
@@ -14,6 +14,8 @@
     <description>Restlet API and Engine</description>
 
     <properties>
+        <grpc.version>1.85.1</grpc.version>
+        <mcp.version>2.1.0</mcp.version>
         <!-- Known high-priority SpotBugs findings, to be fixed (see Engine, Resource, ...) -->
         <spotbugs.max.violations>9</spotbugs.max.violations>
         <!-- Native QUIC library for the HTTP/3 tests, overridden per platform by the profiles
@@ -76,6 +78,42 @@
             <version>${lib-hamcrest-version}</version>
             <scope>test</scope>
         </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-core</artifactId>
+            <version>${grpc.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-protobuf</artifactId>
+            <version>${grpc.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-stub</artifactId>
+            <version>${grpc.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.grpc</groupId>
+            <artifactId>grpc-netty-shaded</artifactId>
+            <version>${grpc.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.modelcontextprotocol.sdk</groupId>
+            <artifactId>mcp-core</artifactId>
+            <version>${mcp.version}</version>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.modelcontextprotocol.sdk</groupId>
+            <artifactId>mcp-json-jackson2</artifactId>
+            <version>${mcp.version}</version>
+            <scope>test</scope>
+        </dependency>
     </dependencies>
     <build>
         <testResources>
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
new file mode 100644
index 0000000000..e48e28e3ce
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -0,0 +1,939 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+package org.restlet.engine.connector;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.protobuf.StringValue;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.ChannelLogger;
+import io.grpc.Deadline;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalLogId;
+import io.grpc.ManagedChannel;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerCall;
+import io.grpc.ServerMethodDefinition;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.ClientStream;
+import io.grpc.internal.ClientStreamListener;
+import io.grpc.internal.ClientTransportFactory;
+import io.grpc.internal.ConnectionClientTransport;
+import io.grpc.internal.InsightBuilder;
+import io.grpc.internal.ManagedChannelImplBuilder;
+import io.grpc.internal.StreamListener;
+import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
+import io.grpc.netty.shaded.io.grpc.netty.NettyServerBuilder;
+import io.grpc.protobuf.ProtoUtils;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.ServerCalls;
+import java.io.ByteArrayInputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.SocketAddress;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.charset.StandardCharsets;
+import java.util.Base64;
+import java.util.Collection;
+import java.util.Set;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.restlet.Client;
+import org.restlet.Context;
+import org.restlet.Request;
+import org.restlet.Response;
+import org.restlet.Server;
+import org.restlet.data.Header;
+import org.restlet.data.MediaType;
+import org.restlet.data.Method;
+import org.restlet.data.Protocol;
+import org.restlet.engine.Engine;
+import org.restlet.engine.header.HeaderConstants;
+import org.restlet.representation.ByteArrayRepresentation;
+import org.restlet.util.Series;
+
+class GrpcSdkTransportSpikeTestCase {
+
+    private static final int MAX_MESSAGE_BYTES = 1024 * 1024;
+
+    private static final MediaType GRPC_MEDIA_TYPE = new MediaType("application/grpc");
+
+    private static final MethodDescriptor<StringValue, StringValue> ECHO_METHOD =
+            MethodDescriptor.<StringValue, StringValue>newBuilder()
+                    .setType(MethodDescriptor.MethodType.UNARY)
+                    .setFullMethodName("restlet.r0.Echo/Echo")
+                    .setRequestMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .build();
+
+    private Client client;
+
+    private io.grpc.Server grpcServer;
+
+    private ManagedChannel grpcClientChannel;
+
+    private Server restletServer;
+
+    private ManagedChannel channel;
+
+    private final AtomicReference<Protocol> lastGrpcResponseProtocol = new AtomicReference<>();
+
+    @BeforeEach
+    void setUp() {
+        Engine.clearThreadLocalVariables();
+        Engine.register(false);
+        Engine.getInstance().getRegisteredServers().add(new HttpServerHelper(null));
+        Engine.getInstance().getRegisteredClients().add(new HttpClientHelper(null));
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        if (channel != null) {
+            channel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+        if (client != null) {
+            client.stop();
+        }
+        if (grpcClientChannel != null) {
+            grpcClientChannel.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+        if (restletServer != null) {
+            restletServer.stop();
+        }
+        if (grpcServer != null) {
+            grpcServer.shutdownNow().awaitTermination(5, TimeUnit.SECONDS);
+        }
+        Engine.clearThreadLocalVariables();
+    }
+
+    @Test
+    void invokesOfficialGrpcServerThroughRestletHttp2Client() throws Exception {
+        ServerServiceDefinition service =
+                ServerServiceDefinition.builder("restlet.r0.Echo")
+                        .addMethod(
+                                ECHO_METHOD,
+                                ServerCalls.asyncUnaryCall(
+                                        (StringValue message,
+                                                io.grpc.stub.StreamObserver<StringValue>
+                                                        result) -> {
+                                            if ("bad".equals(message.getValue())) {
+                                                result.onError(
+                                                        Status.INVALID_ARGUMENT
+                                                                .withDescription("spike-error")
+                                                                .asRuntimeException());
+                                            } else {
+                                                result.onNext(
+                                                        StringValue.of(
+                                                                "echo:" + message.getValue()));
+                                                result.onCompleted();
+                                            }
+                                        }))
+                        .build();
+        grpcServer = NettyServerBuilder.forPort(0).addService(service).build().start();
+
+        Context restletContext = new Context();
+        restletContext.getParameters().add("httpClientTransportMode", "HTTP2");
+        client = new Client(restletContext, Protocol.HTTP);
+        client.start();
+
+        String target = "http://localhost:" + grpcServer.getPort();
+        String authority = "localhost:" + grpcServer.getPort();
+        RestletTransportFactory transportFactory =
+                new RestletTransportFactory(client, lastGrpcResponseProtocol);
+        channel =
+                new ManagedChannelImplBuilder(
+                                new RestletSocketAddress(target),
+                                authority,
+                                () -> transportFactory,
+                                () -> 0)
+                        .build();
+
+        assertEquals(
+                "echo:hello",
+                ClientCalls.blockingUnaryCall(
+                                channel, ECHO_METHOD, CallOptions.DEFAULT, StringValue.of("hello"))
+                        .getValue());
+        StatusRuntimeException failure =
+                assertThrows(
+                        StatusRuntimeException.class,
+                        () ->
+                                ClientCalls.blockingUnaryCall(
+                                        channel,
+                                        ECHO_METHOD,
+                                        CallOptions.DEFAULT,
+                                        StringValue.of("bad")));
+        assertEquals(Status.Code.INVALID_ARGUMENT, failure.getStatus().getCode());
+        assertEquals("2.0", lastGrpcResponseProtocol.get().getVersion());
+    }
+
+    @Test
+    void hostsOfficialGrpcServiceThroughRestletHttp2Server() throws Exception {
+        ServerServiceDefinition service =
+                ServerServiceDefinition.builder("restlet.r0.Echo")
+                        .addMethod(
+                                ECHO_METHOD,
+                                ServerCalls.asyncUnaryCall(
+                                        (StringValue message,
+                                                io.grpc.stub.StreamObserver<StringValue>
+                                                        result) -> {
+                                            if ("bad".equals(message.getValue())) {
+                                                result.onError(
+                                                        Status.INVALID_ARGUMENT
+                                                                .withDescription("spike-error")
+                                                                .asRuntimeException());
+                                            } else {
+                                                result.onNext(
+                                                        StringValue.of(
+                                                                "echo:" + message.getValue()));
+                                                result.onCompleted();
+                                            }
+                                        }))
+                        .build();
+        Context serverContext = new Context();
+        serverContext.getParameters().add("http.transport.protocol", "HTTP2");
+        RestletGrpcServer adapter = new RestletGrpcServer(service);
+        restletServer = new Server(serverContext, Protocol.HTTP, 0, adapter);
+        restletServer.start();
+        grpcClientChannel =
+                NettyChannelBuilder.forAddress("localhost", restletServer.getActualPort())
+                        .usePlaintext()
+                        .build();
+
+        assertEquals(
+                "echo:hello",
+                ClientCalls.blockingUnaryCall(
+                                grpcClientChannel,
+                                ECHO_METHOD,
+                                CallOptions.DEFAULT,
+                                StringValue.of("hello"))
+                        .getValue());
+        assertEquals("HTTP/2.0", adapter.lastRequestProtocol.get());
+        StatusRuntimeException failure =
+                assertThrows(
+                        StatusRuntimeException.class,
+                        () ->
+                                ClientCalls.blockingUnaryCall(
+                                        grpcClientChannel,
+                                        ECHO_METHOD,
+                                        CallOptions.DEFAULT,
+                                        StringValue.of("bad")));
+        assertEquals(Status.Code.INVALID_ARGUMENT, failure.getStatus().getCode());
+    }
+
+    private static final class RestletGrpcServer extends org.restlet.Restlet {
+
+        private final ServerServiceDefinition service;
+
+        private final java.util.concurrent.atomic.AtomicReference<String> lastRequestProtocol =
+                new java.util.concurrent.atomic.AtomicReference<>();
+
+        private RestletGrpcServer(ServerServiceDefinition service) {
+            this.service = service;
+        }
+
+        @Override
+        public void handle(Request request, Response response) {
+            try {
+                lastRequestProtocol.set(
+                        (String) request.getAttributes().get(HeaderConstants.ATTRIBUTE_VERSION));
+                if (!Method.POST.equals(request.getMethod())) {
+                    response.setStatus(org.restlet.data.Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+                    return;
+                }
+                String path = request.getResourceRef().getPath();
+                String fullMethodName = path.startsWith("/") ? path.substring(1) : path;
+                ServerMethodDefinition<?, ?> definition = service.getMethod(fullMethodName);
+                if (definition == null) {
+                    setGrpcStatus(response, Status.UNIMPLEMENTED);
+                    return;
+                }
+                if (!request.isEntityAvailable()) {
+                    setGrpcStatus(response, Status.INVALID_ARGUMENT);
+                    return;
+                }
+
+                byte[] frame;
+                try (InputStream input = request.getEntity().getStream()) {
+                    frame = input.readNBytes(MAX_MESSAGE_BYTES + 6);
+                }
+                byte[] payload = unframe(frame);
+                dispatch(definition, request, response, payload);
+            } catch (Exception e) {
+                setGrpcStatus(response, Status.fromThrowable(e));
+            }
+        }
+
+        private <RequestT, ResponseT> void dispatch(
+                ServerMethodDefinition<RequestT, ResponseT> definition,
+                Request request,
+                Response response,
+                byte[] payload)
+                throws IOException {
+            MethodDescriptor<RequestT, ResponseT> method = definition.getMethodDescriptor();
+            Metadata requestHeaders = readMetadata(request.getHeaders());
+            SpikeServerCall<RequestT, ResponseT> serverCall = new SpikeServerCall<>(method);
+            ServerCall.Listener<RequestT> listener =
+                    definition.getServerCallHandler().startCall(serverCall, requestHeaders);
+            if (listener == null) {
+                throw new IOException("gRPC SDK returned no call listener");
+            }
+            listener.onMessage(method.parseRequest(new ByteArrayInputStream(payload)));
+            listener.onHalfClose();
+            serverCall.writeResponse(response);
+        }
+    }
+
+    private static final class SpikeServerCall<RequestT, ResponseT>
+            extends ServerCall<RequestT, ResponseT> {
+
+        private final MethodDescriptor<RequestT, ResponseT> method;
+
+        private ResponseT responseMessage;
+
+        private final Metadata responseHeaders = new Metadata();
+
+        private Status status;
+
+        private Metadata trailers = new Metadata();
+
+        private SpikeServerCall(MethodDescriptor<RequestT, ResponseT> method) {
+            this.method = method;
+        }
+
+        @Override
+        public void request(int numMessages) {}
+
+        @Override
+        public void sendHeaders(Metadata headers) {
+            responseHeaders.merge(headers);
+        }
+
+        @Override
+        public void sendMessage(ResponseT message) {
+            responseMessage = message;
+        }
+
+        @Override
+        public void close(Status status, Metadata trailers) {
+            this.status = status;
+            this.trailers = trailers;
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return false;
+        }
+
+        @Override
+        public MethodDescriptor<RequestT, ResponseT> getMethodDescriptor() {
+            return method;
+        }
+
+        private void writeResponse(Response response) throws IOException {
+            if (status == null) {
+                status = Status.INTERNAL.withDescription("SDK call did not close");
+                trailers = new Metadata();
+            }
+            response.setStatus(org.restlet.data.Status.SUCCESS_OK);
+            writeMetadata(responseHeaders, response.getHeaders());
+            if (responseMessage != null && status.isOk()) {
+                try (InputStream payload = method.streamResponse(responseMessage)) {
+                    byte[] bytes = payload.readNBytes(MAX_MESSAGE_BYTES + 1);
+                    if (bytes.length > MAX_MESSAGE_BYTES) {
+                        throw new IOException(
+                                "gRPC response exceeds " + MAX_MESSAGE_BYTES + " bytes");
+                    }
+                    response.setEntity(new ByteArrayRepresentation(frame(bytes), GRPC_MEDIA_TYPE));
+                }
+            } else {
+                response.setEntity(new ByteArrayRepresentation(new byte[0], GRPC_MEDIA_TYPE));
+            }
+            response.getTrailers().add("grpc-status", Integer.toString(status.getCode().value()));
+            if (status.getDescription() != null) {
+                response.getTrailers().add("grpc-message", status.getDescription());
+            }
+            writeMetadata(trailers, response.getTrailers());
+        }
+    }
+
+    private static void setGrpcStatus(Response response, Status status) {
+        response.setStatus(org.restlet.data.Status.SUCCESS_OK);
+        response.setEntity(new ByteArrayRepresentation(new byte[0], GRPC_MEDIA_TYPE));
+        response.getTrailers().add("grpc-status", Integer.toString(status.getCode().value()));
+    }
+
+    private static final class RestletSocketAddress extends SocketAddress {
+
+        private static final long serialVersionUID = 1L;
+
+        private final String target;
+
+        private RestletSocketAddress(String target) {
+            this.target = target;
+        }
+    }
+
+    private static final class RestletTransportFactory implements ClientTransportFactory {
+
+        private final Client client;
+
+        private final AtomicReference<Protocol> lastResponseProtocol;
+
+        private final ScheduledExecutorService scheduledExecutor =
+                Executors.newSingleThreadScheduledExecutor(
+                        runnable -> {
+                            Thread thread = new Thread(runnable, "restlet-grpc-r0-timer");
+                            thread.setDaemon(true);
+                            return thread;
+                        });
+
+        private RestletTransportFactory(
+                Client client, AtomicReference<Protocol> lastResponseProtocol) {
+            this.client = client;
+            this.lastResponseProtocol = lastResponseProtocol;
+        }
+
+        @Override
+        public ConnectionClientTransport newClientTransport(
+                SocketAddress address,
+                ClientTransportOptions options,
+                ChannelLogger channelLogger) {
+            if (!(address instanceof RestletSocketAddress restletAddress)) {
+                throw new IllegalArgumentException("Unsupported address: " + address);
+            }
+            return new RestletClientTransport(
+                    client, restletAddress, options.getAuthority(), lastResponseProtocol);
+        }
+
+        @Override
+        public ScheduledExecutorService getScheduledExecutorService() {
+            return scheduledExecutor;
+        }
+
+        @Override
+        public SwapChannelCredentialsResult swapChannelCredentials(
+                io.grpc.ChannelCredentials channelCredentials) {
+            throw new UnsupportedOperationException(
+                    "R0 spike does not support channel credentials");
+        }
+
+        @Override
+        public void close() {
+            scheduledExecutor.shutdownNow();
+        }
+
+        @Override
+        public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes() {
+            return Set.of(RestletSocketAddress.class);
+        }
+    }
+
+    private static final class RestletClientTransport implements ConnectionClientTransport {
+
+        private final Client client;
+
+        private final RestletSocketAddress address;
+
+        private final String authority;
+
+        private final AtomicReference<Protocol> lastResponseProtocol;
+
+        private final InternalLogId logId =
+                InternalLogId.allocate(RestletClientTransport.class, "Restlet HTTP/2");
+
+        private final AtomicInteger activeStreams = new AtomicInteger();
+
+        private final java.util.concurrent.atomic.AtomicBoolean terminated =
+                new java.util.concurrent.atomic.AtomicBoolean();
+
+        private volatile Listener listener;
+
+        private volatile boolean shutdown;
+
+        private RestletClientTransport(
+                Client client,
+                RestletSocketAddress address,
+                String authority,
+                AtomicReference<Protocol> lastResponseProtocol) {
+            this.client = client;
+            this.address = address;
+            this.authority = authority;
+            this.lastResponseProtocol = lastResponseProtocol;
+        }
+
+        @Override
+        public Runnable start(Listener listener) {
+            this.listener = listener;
+            return listener::transportReady;
+        }
+
+        @Override
+        public void shutdown(Status status) {
+            if (!shutdown) {
+                shutdown = true;
+                Listener currentListener = listener;
+                if (currentListener != null) {
+                    currentListener.transportShutdown(status, null);
+                    terminateIfIdle();
+                }
+            }
+        }
+
+        @Override
+        public void shutdownNow(Status status) {
+            shutdown(status);
+        }
+
+        @Override
+        public ClientStream newStream(
+                MethodDescriptor<?, ?> method,
+                Metadata headers,
+                CallOptions callOptions,
+                io.grpc.ClientStreamTracer[] tracers) {
+            if (shutdown) {
+                throw new IllegalStateException("gRPC transport is shut down");
+            }
+            if (method.getType() != MethodDescriptor.MethodType.UNARY) {
+                throw new UnsupportedOperationException("R0 SPI probe supports unary calls only");
+            }
+            if (callOptions.getCredentials() != null || callOptions.getCompressor() != null) {
+                throw new UnsupportedOperationException(
+                        "R0 SPI probe does not support call credentials or compression");
+            }
+            return new RestletClientStream(
+                    client,
+                    address,
+                    authority,
+                    method,
+                    headers,
+                    lastResponseProtocol,
+                    this::streamStarted,
+                    this::streamFinished);
+        }
+
+        @Override
+        public void ping(PingCallback callback, java.util.concurrent.Executor executor) {
+            executor.execute(
+                    () ->
+                            callback.onFailure(
+                                    Status.UNIMPLEMENTED.withDescription("PING unsupported")));
+        }
+
+        @Override
+        public ListenableFuture<InternalChannelz.SocketStats> getStats() {
+            InternalChannelz.TransportStats transportStats =
+                    new InternalChannelz.TransportStats(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0);
+            return Futures.immediateFuture(
+                    new InternalChannelz.SocketStats(transportStats, address, address, null, null));
+        }
+
+        @Override
+        public InternalLogId getLogId() {
+            return logId;
+        }
+
+        @Override
+        public Attributes getAttributes() {
+            return Attributes.EMPTY;
+        }
+
+        private void streamStarted() {
+            if (activeStreams.getAndIncrement() == 0) {
+                Listener currentListener = listener;
+                if (currentListener != null) {
+                    currentListener.transportInUse(true);
+                }
+            }
+        }
+
+        private void streamFinished() {
+            if (activeStreams.decrementAndGet() == 0) {
+                Listener currentListener = listener;
+                if (currentListener != null) {
+                    currentListener.transportInUse(false);
+                }
+                terminateIfIdle();
+            }
+        }
+
+        private void terminateIfIdle() {
+            Listener currentListener = listener;
+            if (shutdown
+                    && activeStreams.get() == 0
+                    && currentListener != null
+                    && terminated.compareAndSet(false, true)) {
+                currentListener.transportTerminated();
+            }
+        }
+    }
+
+    private static final class RestletClientStream implements ClientStream {
+
+        private final Client client;
+
+        private final RestletSocketAddress address;
+
+        private final String authority;
+
+        private final MethodDescriptor<?, ?> method;
+
+        private final Metadata requestMetadata;
+
+        private final AtomicReference<Protocol> lastResponseProtocol;
+
+        private final Runnable onStart;
+
+        private final Runnable onClose;
+
+        private volatile ClientStreamListener listener;
+
+        private volatile Request activeRequest;
+
+        private byte[] requestPayload;
+
+        private int maxInboundMessageSize = MAX_MESSAGE_BYTES;
+
+        private int maxOutboundMessageSize = MAX_MESSAGE_BYTES;
+
+        private volatile boolean closed;
+
+        private volatile boolean messageWritten;
+
+        private RestletClientStream(
+                Client client,
+                RestletSocketAddress address,
+                String authority,
+                MethodDescriptor<?, ?> method,
+                Metadata requestMetadata,
+                AtomicReference<Protocol> lastResponseProtocol,
+                Runnable onStart,
+                Runnable onClose) {
+            this.client = client;
+            this.address = address;
+            this.authority = authority;
+            this.method = method;
+            this.requestMetadata = requestMetadata;
+            this.lastResponseProtocol = lastResponseProtocol;
+            this.onStart = onStart;
+            this.onClose = onClose;
+        }
+
+        @Override
+        public void start(ClientStreamListener listener) {
+            this.listener = listener;
+            onStart.run();
+            listener.onReady();
+        }
+
+        @Override
+        public void request(int numMessages) {
+            if (numMessages <= 0) {
+                throw new IllegalArgumentException("numMessages must be positive");
+            }
+        }
+
+        @Override
+        public void cancel(Status reason) {
+            Request request = activeRequest;
+            if (request != null) {
+                request.abort();
+            }
+            close(reason, new Metadata());
+        }
+
+        @Override
+        public void writeMessage(InputStream message) {
+            if (messageWritten || closed) {
+                throw new IllegalStateException("R0 SPI probe accepts one request message");
+            }
+            messageWritten = true;
+            try (InputStream input = message) {
+                requestPayload = input.readNBytes(maxOutboundMessageSize + 1);
+            } catch (IOException e) {
+                close(Status.INTERNAL.withCause(e), new Metadata());
+                return;
+            }
+            if (requestPayload.length > maxOutboundMessageSize) {
+                close(
+                        Status.RESOURCE_EXHAUSTED.withDescription(
+                                "gRPC request exceeds " + maxOutboundMessageSize + " bytes"),
+                        new Metadata());
+            }
+        }
+
+        @Override
+        public void halfClose() {
+            if (closed) {
+                return;
+            }
+            if (!messageWritten || requestPayload == null) {
+                close(
+                        Status.INTERNAL.withDescription("gRPC unary request message is missing"),
+                        new Metadata());
+                return;
+            }
+            try {
+                Request request =
+                        new Request(
+                                Method.POST,
+                                address.target + "/" + method.getFullMethodName(),
+                                new ByteArrayRepresentation(
+                                        frame(requestPayload), GRPC_MEDIA_TYPE));
+                activeRequest = request;
+                request.getHeaders().add("te", "trailers");
+                writeMetadata(requestMetadata, request.getHeaders());
+                Response response = client.handle(request);
+                lastResponseProtocol.set(response.getProtocol());
+                byte[] responsePayload = null;
+                if (response.getEntity() != null) {
+                    InputStream responseStream = response.getEntity().getStream();
+                    if (responseStream != null) {
+                        try (InputStream input = responseStream) {
+                            byte[] framedResponse = input.readNBytes(maxInboundMessageSize + 6);
+                            if (framedResponse.length > 0) {
+                                responsePayload = unframe(framedResponse, maxInboundMessageSize);
+                            }
+                        }
+                    }
+                }
+                Metadata trailers = readMetadata(response.getTrailers());
+                String statusText = response.getTrailers().getFirstValue("grpc-status", true);
+                if (statusText == null) {
+                    statusText = response.getHeaders().getFirstValue("grpc-status", true);
+                }
+                if (statusText == null) {
+                    close(Status.UNKNOWN.withDescription("Missing grpc-status"), trailers);
+                    return;
+                }
+                Status status;
+                try {
+                    status = Status.fromCodeValue(Integer.parseInt(statusText));
+                } catch (NumberFormatException e) {
+                    status = Status.UNKNOWN.withDescription("Invalid grpc-status: " + statusText);
+                }
+                String statusMessage = response.getTrailers().getFirstValue("grpc-message", true);
+                if (statusMessage == null) {
+                    statusMessage = response.getHeaders().getFirstValue("grpc-message", true);
+                }
+                if (statusMessage != null) {
+                    status = status.withDescription(statusMessage);
+                }
+                if (!status.isOk()) {
+                    close(status, trailers);
+                    return;
+                }
+                if (responsePayload == null) {
+                    throw new IOException("gRPC response did not contain a message");
+                }
+                listener.headersRead(readMetadata(response.getHeaders()));
+                byte[] message = responsePayload;
+                listener.messagesAvailable(
+                        new StreamListener.MessageProducer() {
+                            private boolean consumed;
+
+                            @Override
+                            public InputStream next() {
+                                if (consumed) {
+                                    return null;
+                                }
+                                consumed = true;
+                                return new ByteArrayInputStream(message);
+                            }
+                        });
+                close(status, ClientStreamListener.RpcProgress.PROCESSED, trailers);
+            } catch (Exception e) {
+                close(
+                        Status.UNAVAILABLE.withCause(e),
+                        ClientStreamListener.RpcProgress.PROCESSED,
+                        new Metadata());
+            }
+        }
+
+        private synchronized void close(Status status, Metadata trailers) {
+            close(status, ClientStreamListener.RpcProgress.PROCESSED, trailers);
+        }
+
+        private synchronized void close(
+                Status status, ClientStreamListener.RpcProgress progress, Metadata trailers) {
+            if (!closed && listener != null) {
+                closed = true;
+                try {
+                    listener.closed(status, progress, trailers);
+                } finally {
+                    onClose.run();
+                }
+            }
+        }
+
+        @Override
+        public void flush() {}
+
+        @Override
+        public boolean isReady() {
+            return !closed && !messageWritten;
+        }
+
+        @Override
+        public void optimizeForDirectExecutor() {}
+
+        @Override
+        public void setCompressor(io.grpc.Compressor compressor) {
+            if (!"identity".equalsIgnoreCase(compressor.getMessageEncoding())) {
+                throw new UnsupportedOperationException(
+                        "R0 SPI probe does not support compression");
+            }
+        }
+
+        @Override
+        public void setMessageCompression(boolean enabled) {
+            if (enabled) {
+                throw new UnsupportedOperationException(
+                        "R0 SPI probe does not support compression");
+            }
+        }
+
+        @Override
+        public void setAuthority(String authority) {
+            if (authority != null && !authority.equals(this.authority)) {
+                throw new UnsupportedOperationException(
+                        "R0 SPI probe does not support authority overrides");
+            }
+        }
+
+        @Override
+        public void setFullStreamDecompression(boolean enabled) {
+            if (enabled) {
+                throw new UnsupportedOperationException(
+                        "R0 SPI probe does not support decompression");
+            }
+        }
+
+        @Override
+        public void setDecompressorRegistry(io.grpc.DecompressorRegistry registry) {}
+
+        @Override
+        public void setMaxInboundMessageSize(int maxSize) {
+            maxInboundMessageSize = Math.min(maxSize, MAX_MESSAGE_BYTES);
+        }
+
+        @Override
+        public void setMaxOutboundMessageSize(int maxSize) {
+            maxOutboundMessageSize = Math.min(maxSize, MAX_MESSAGE_BYTES);
+        }
+
+        @Override
+        public void setDeadline(Deadline deadline) {
+            if (deadline != null) {
+                throw new UnsupportedOperationException("R0 SPI probe does not support deadlines");
+            }
+        }
+
+        @Override
+        public Attributes getAttributes() {
+            return Attributes.EMPTY;
+        }
+
+        @Override
+        public void appendTimeoutInsight(InsightBuilder insight) {}
+    }
+
+    private static byte[] frame(byte[] payload) {
+        ByteBuffer buffer = ByteBuffer.allocate(payload.length + 5).order(ByteOrder.BIG_ENDIAN);
+        buffer.put((byte) 0);
+        buffer.putInt(payload.length);
+        buffer.put(payload);
+        return buffer.array();
+    }
+
+    private static byte[] unframe(byte[] frame) throws IOException {
+        return unframe(frame, MAX_MESSAGE_BYTES);
+    }
+
+    private static byte[] unframe(byte[] frame, int maxMessageSize) throws IOException {
+        if (frame.length < 5 || frame[0] != 0) {
+            throw new IOException("Invalid or compressed gRPC message frame");
+        }
+        int length = ByteBuffer.wrap(frame, 1, 4).order(ByteOrder.BIG_ENDIAN).getInt();
+        if (length < 0 || length > maxMessageSize || frame.length != length + 5) {
+            throw new IOException("Invalid gRPC message length: " + length);
+        }
+        return java.util.Arrays.copyOfRange(frame, 5, frame.length);
+    }
+
+    private static void writeMetadata(Metadata metadata, Series<Header> headers) {
+        for (String name : metadata.keys()) {
+            if (name.startsWith("grpc-")) {
+                continue;
+            }
+            if (name.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+                Metadata.Key<byte[]> key = Metadata.Key.of(name, Metadata.BINARY_BYTE_MARSHALLER);
+                Iterable<byte[]> values = metadata.getAll(key);
+                if (values != null) {
+                    for (byte[] value : values) {
+                        headers.add(name, Base64.getEncoder().encodeToString(value));
+                    }
+                }
+            } else {
+                Metadata.Key<String> key = Metadata.Key.of(name, Metadata.ASCII_STRING_MARSHALLER);
+                Iterable<String> values = metadata.getAll(key);
+                if (values != null) {
+                    for (String value : values) {
+                        headers.add(name, value);
+                    }
+                }
+            }
+        }
+    }
+
+    private static Metadata readMetadata(Series<Header> headers) {
+        Metadata metadata = new Metadata();
+        Set<String> excluded =
+                Set.of(
+                        "content-type",
+                        "content-length",
+                        "te",
+                        "date",
+                        "server",
+                        "grpc-status",
+                        "grpc-message",
+                        "grpc-encoding",
+                        "grpc-accept-encoding");
+        for (Header header : headers) {
+            String name = header.getName().toLowerCase(java.util.Locale.ROOT);
+            if (excluded.contains(name) || name.startsWith("grpc-")) {
+                continue;
+            }
+            if (name.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
+                Metadata.Key<byte[]> key = Metadata.Key.of(name, Metadata.BINARY_BYTE_MARSHALLER);
+                metadata.put(
+                        key,
+                        Base64.getDecoder()
+                                .decode(header.getValue().getBytes(StandardCharsets.US_ASCII)));
+            } else {
+                Metadata.Key<String> key = Metadata.Key.of(name, Metadata.ASCII_STRING_MARSHALLER);
+                metadata.put(key, header.getValue());
+            }
+        }
+        return metadata;
+    }
+}
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
new file mode 100644
index 0000000000..a1e9c71381
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -0,0 +1,336 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+package org.restlet.engine.connector;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.modelcontextprotocol.client.McpAsyncClient;
+import io.modelcontextprotocol.client.McpClient;
+import io.modelcontextprotocol.common.McpTransportContext;
+import io.modelcontextprotocol.json.McpJsonDefaults;
+import io.modelcontextprotocol.json.McpJsonMapper;
+import io.modelcontextprotocol.server.McpServer;
+import io.modelcontextprotocol.server.McpStatelessAsyncServer;
+import io.modelcontextprotocol.server.McpStatelessServerHandler;
+import io.modelcontextprotocol.spec.McpClientTransport;
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpStatelessServerTransport;
+import java.io.IOException;
+import java.io.InputStream;
+import java.time.Duration;
+import java.util.Map;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.restlet.Client;
+import org.restlet.Context;
+import org.restlet.Request;
+import org.restlet.Response;
+import org.restlet.Restlet;
+import org.restlet.Server;
+import org.restlet.data.MediaType;
+import org.restlet.data.Method;
+import org.restlet.data.Protocol;
+import org.restlet.engine.Engine;
+import org.restlet.representation.StringRepresentation;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+
+class McpSdkTransportSpikeTestCase {
+
+    private static final int MAX_MESSAGE_BYTES = 64 * 1024;
+
+    private static final Duration REQUEST_TIMEOUT = Duration.ofSeconds(5);
+
+    private Client client;
+
+    private McpAsyncClient sdkClient;
+
+    private McpStatelessAsyncServer sdkServer;
+
+    private Server server;
+
+    @BeforeEach
+    void setUp() {
+        Engine.clearThreadLocalVariables();
+        Engine.register(false);
+        Engine.getInstance().getRegisteredServers().add(new HttpServerHelper(null));
+        Engine.getInstance().getRegisteredClients().add(new HttpClientHelper(null));
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        if (sdkServer != null) {
+            sdkServer.close();
+        }
+        if (sdkClient != null) {
+            sdkClient.close();
+        }
+        if (client != null) {
+            client.stop();
+        }
+        if (server != null) {
+            server.stop();
+        }
+        Engine.clearThreadLocalVariables();
+    }
+
+    @Test
+    void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
+        McpStatelessServerTransport transport = new RestletHttpTransport(mapper);
+        var tool =
+                new McpSchema.Tool(
+                        "echo",
+                        null,
+                        "Returns the supplied text",
+                        Map.of(
+                                "type",
+                                "object",
+                                "properties",
+                                Map.of("text", Map.of("type", "string")),
+                                "required",
+                                java.util.List.of("text")),
+                        null,
+                        null,
+                        null,
+                        null);
+        sdkServer =
+                McpServer.async(transport)
+                        .serverInfo("restlet-r0-spike", "1")
+                        .toolCall(
+                                tool,
+                                (context, call) ->
+                                        Mono.just(
+                                                McpSchema.CallToolResult.builder()
+                                                        .addTextContent(
+                                                                "echo:"
+                                                                        + call.arguments()
+                                                                                .get("text"))
+                                                        .build()))
+                        .build();
+
+        RestletHttpTransport restlet = (RestletHttpTransport) transport;
+        Context serverContext = new Context();
+        serverContext.getParameters().add("http.transport.protocol", "HTTP2");
+        server = new Server(serverContext, Protocol.HTTP, 0, restlet);
+        server.start();
+
+        Context clientContext = new Context();
+        clientContext.getParameters().add("httpClientTransportMode", "HTTP2");
+        client = new Client(clientContext, Protocol.HTTP);
+        client.start();
+        RestletHttpClientTransport clientTransport =
+                new RestletHttpClientTransport(
+                        client, mapper, "http://localhost:" + server.getActualPort() + "/mcp");
+        sdkClient =
+                McpClient.async(clientTransport)
+                        .requestTimeout(REQUEST_TIMEOUT)
+                        .initializationTimeout(REQUEST_TIMEOUT)
+                        .build();
+
+        try {
+            sdkClient.initialize().block(REQUEST_TIMEOUT);
+        } catch (RuntimeException e) {
+            throw new AssertionError(
+                    "MCP initialization failed. Request: "
+                            + clientTransport.lastRequestPayload.get()
+                            + "; response: "
+                            + clientTransport.lastResponsePayload.get(),
+                    e);
+        }
+        McpSchema.ListToolsResult listedTools = sdkClient.listTools().block(REQUEST_TIMEOUT);
+        McpSchema.CallToolResult result =
+                sdkClient
+                        .callTool(
+                                new McpSchema.CallToolRequest(
+                                        "echo", Map.of("text", "hello"), null))
+                        .block(REQUEST_TIMEOUT);
+
+        assertTrue(listedTools.tools().stream().anyMatch(item -> item.name().equals("echo")));
+        assertEquals("echo:hello", ((McpSchema.TextContent) result.content().getFirst()).text());
+        assertEquals("2.0", clientTransport.lastResponseProtocol.get().getVersion());
+    }
+
+    private static final class RestletHttpTransport extends Restlet
+            implements McpStatelessServerTransport {
+
+        private final McpJsonMapper jsonMapper;
+
+        private volatile McpStatelessServerHandler handler;
+
+        private RestletHttpTransport(McpJsonMapper jsonMapper) {
+            this.jsonMapper = jsonMapper;
+        }
+
+        @Override
+        public void setMcpHandler(McpStatelessServerHandler handler) {
+            this.handler = handler;
+        }
+
+        @Override
+        public Mono<Void> closeGracefully() {
+            return Mono.empty();
+        }
+
+        @Override
+        public void handle(Request request, Response response) {
+            McpStatelessServerHandler currentHandler = handler;
+            if (currentHandler == null) {
+                response.setStatus(org.restlet.data.Status.SERVER_ERROR_SERVICE_UNAVAILABLE);
+                return;
+            }
+            if (!request.isEntityAvailable()) {
+                response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
+                return;
+            }
+
+            try (var input = request.getEntity().getStream()) {
+                byte[] message = input.readNBytes(MAX_MESSAGE_BYTES + 1);
+                if (message.length > MAX_MESSAGE_BYTES) {
+                    response.setStatus(
+                            org.restlet.data.Status.CLIENT_ERROR_REQUEST_ENTITY_TOO_LARGE);
+                    return;
+                }
+                McpSchema.JSONRPCMessage parsed =
+                        McpSchema.deserializeJsonRpcMessage(
+                                jsonMapper,
+                                new String(message, java.nio.charset.StandardCharsets.UTF_8));
+                if (parsed instanceof McpSchema.JSONRPCRequest rpcRequest) {
+                    McpSchema.JSONRPCResponse rpcResponse =
+                            currentHandler
+                                    .handleRequest(McpTransportContext.EMPTY, rpcRequest)
+                                    .block(REQUEST_TIMEOUT);
+                    if (rpcResponse == null) {
+                        response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
+                        return;
+                    }
+                    response.setEntity(
+                            jsonMapper.writeValueAsString(rpcResponse), MediaType.APPLICATION_JSON);
+                } else if (parsed instanceof McpSchema.JSONRPCNotification notification) {
+                    currentHandler
+                            .handleNotification(McpTransportContext.EMPTY, notification)
+                            .block(REQUEST_TIMEOUT);
+                    response.setStatus(org.restlet.data.Status.SUCCESS_ACCEPTED);
+                } else {
+                    response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
+                }
+            } catch (IOException e) {
+                response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
+                getLogger().warning("Unable to read MCP spike request: " + e.getMessage());
+            }
+        }
+    }
+
+    private static final class RestletHttpClientTransport implements McpClientTransport {
+
+        private final Client client;
+
+        private final McpJsonMapper jsonMapper;
+
+        private final String target;
+
+        private final AtomicReference<Protocol> lastResponseProtocol = new AtomicReference<>();
+
+        private final AtomicReference<String> lastRequestPayload = new AtomicReference<>();
+
+        private final AtomicReference<String> lastResponsePayload = new AtomicReference<>();
+
+        private volatile java.util.function.Function<
+                        Mono<McpSchema.JSONRPCMessage>, Mono<McpSchema.JSONRPCMessage>>
+                incomingMessageHandler;
+
+        private RestletHttpClientTransport(Client client, McpJsonMapper jsonMapper, String target) {
+            this.client = client;
+            this.jsonMapper = jsonMapper;
+            this.target = target;
+        }
+
+        @Override
+        public Mono<Void> connect(
+                java.util.function.Function<
+                                Mono<McpSchema.JSONRPCMessage>, Mono<McpSchema.JSONRPCMessage>>
+                        handler) {
+            incomingMessageHandler = handler;
+            return Mono.empty();
+        }
+
+        @Override
+        public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+            return Mono.fromRunnable(() -> sendMessageBlocking(message))
+                    .subscribeOn(Schedulers.boundedElastic())
+                    .then();
+        }
+
+        private void sendMessageBlocking(McpSchema.JSONRPCMessage message) {
+            String payload;
+            try {
+                payload = jsonMapper.writeValueAsString(message);
+            } catch (IOException e) {
+                throw new IllegalStateException("Unable to encode MCP spike request", e);
+            }
+            lastRequestPayload.set(payload);
+
+            Request request =
+                    new Request(
+                            Method.POST,
+                            target,
+                            new StringRepresentation(payload, MediaType.APPLICATION_JSON));
+            Response response = client.handle(request);
+            lastResponseProtocol.set(response.getProtocol());
+            if (response.getEntity() == null) {
+                lastResponsePayload.set("");
+                return;
+            }
+
+            try {
+                InputStream responseStream = response.getEntity().getStream();
+                if (responseStream == null) {
+                    lastResponsePayload.set("");
+                    return;
+                }
+                try (var input = responseStream) {
+                    byte[] bytes = input.readNBytes(MAX_MESSAGE_BYTES + 1);
+                    if (bytes.length > MAX_MESSAGE_BYTES) {
+                        throw new IllegalStateException(
+                                "MCP spike response exceeds " + MAX_MESSAGE_BYTES + " bytes");
+                    }
+                    if (bytes.length == 0) {
+                        lastResponsePayload.set("");
+                        return;
+                    }
+                    lastResponsePayload.set(
+                            new String(bytes, java.nio.charset.StandardCharsets.UTF_8));
+                    McpSchema.JSONRPCMessage incoming =
+                            McpSchema.deserializeJsonRpcMessage(
+                                    jsonMapper, lastResponsePayload.get());
+                    var handler = incomingMessageHandler;
+                    if (handler == null) {
+                        throw new IllegalStateException("MCP client is not connected");
+                    }
+                    handler.apply(Mono.just(incoming)).block(REQUEST_TIMEOUT);
+                }
+            } catch (IOException e) {
+                throw new IllegalStateException("Unable to read MCP spike response", e);
+            }
+        }
+
+        @Override
+        public <T> T unmarshalFrom(Object data, io.modelcontextprotocol.json.TypeRef<T> typeRef) {
+            return jsonMapper.convertValue(data, typeRef);
+        }
+
+        @Override
+        public Mono<Void> closeGracefully() {
+            return Mono.empty();
+        }
+    }
+}

From b3d6695f6897e89a2bdae75e89707d64b60125ac Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Tue, 20 Oct 2026 19:18:55 -0400
Subject: [PATCH 02/18] Extend R0 protocol SDK interop probes

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrpcSdkTransportSpikeTestCase.java        | 166 ++++++++++++++++--
 .../McpSdkTransportSpikeTestCase.java         |  49 ++++++
 .../connector/McpStdioSdkServerProcess.java   |  64 +++++++
 3 files changed, 260 insertions(+), 19 deletions(-)
 create mode 100644 org.restlet/src/test/java/org/restlet/engine/connector/McpStdioSdkServerProcess.java

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index e48e28e3ce..18a7b423f4 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -41,15 +41,19 @@
 import io.grpc.stub.ClientCalls;
 import io.grpc.stub.ServerCalls;
 import java.io.ByteArrayInputStream;
+import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.net.SocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
 import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
 import java.util.Base64;
 import java.util.Collection;
+import java.util.List;
 import java.util.Set;
+import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
@@ -76,6 +80,8 @@ class GrpcSdkTransportSpikeTestCase {
 
     private static final int MAX_MESSAGE_BYTES = 1024 * 1024;
 
+    private static final int MAX_STREAM_BYTES = 4 * MAX_MESSAGE_BYTES;
+
     private static final MediaType GRPC_MEDIA_TYPE = new MediaType("application/grpc");
 
     private static final MethodDescriptor<StringValue, StringValue> ECHO_METHOD =
@@ -86,6 +92,14 @@ class GrpcSdkTransportSpikeTestCase {
                     .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
                     .build();
 
+    private static final MethodDescriptor<StringValue, StringValue> STREAM_METHOD =
+            MethodDescriptor.<StringValue, StringValue>newBuilder()
+                    .setType(MethodDescriptor.MethodType.SERVER_STREAMING)
+                    .setFullMethodName("restlet.r0.Echo/Stream")
+                    .setRequestMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .build();
+
     private Client client;
 
     private io.grpc.Server grpcServer;
@@ -148,6 +162,35 @@ void invokesOfficialGrpcServerThroughRestletHttp2Client() throws Exception {
                                                 result.onCompleted();
                                             }
                                         }))
+                        .addMethod(
+                                STREAM_METHOD,
+                                ServerCalls.asyncServerStreamingCall(
+                                        (StringValue message,
+                                                io.grpc.stub.StreamObserver<StringValue>
+                                                        result) -> {
+                                            java.util.concurrent.CompletableFuture.runAsync(
+                                                    () -> {
+                                                        try {
+                                                            Thread.sleep(50);
+                                                            result.onNext(
+                                                                    StringValue.of(
+                                                                            message.getValue()
+                                                                                    + ":1"));
+                                                            Thread.sleep(50);
+                                                            result.onNext(
+                                                                    StringValue.of(
+                                                                            message.getValue()
+                                                                                    + ":2"));
+                                                            result.onCompleted();
+                                                        } catch (InterruptedException e) {
+                                                            Thread.currentThread().interrupt();
+                                                            result.onError(
+                                                                    Status.CANCELLED
+                                                                            .withCause(e)
+                                                                            .asRuntimeException());
+                                                        }
+                                                    });
+                                        }))
                         .build();
         grpcServer = NettyServerBuilder.forPort(0).addService(service).build().start();
 
@@ -184,6 +227,18 @@ void invokesOfficialGrpcServerThroughRestletHttp2Client() throws Exception {
                                         StringValue.of("bad")));
         assertEquals(Status.Code.INVALID_ARGUMENT, failure.getStatus().getCode());
         assertEquals("2.0", lastGrpcResponseProtocol.get().getVersion());
+
+        var stream =
+                ClientCalls.blockingServerStreamingCall(
+                        channel, STREAM_METHOD, CallOptions.DEFAULT, StringValue.of("delayed"));
+        assertEquals(
+                List.of("delayed:1", "delayed:2"),
+                java.util.stream.StreamSupport.stream(
+                                java.util.Spliterators.spliteratorUnknownSize(
+                                        stream, java.util.Spliterator.ORDERED),
+                                false)
+                        .map(StringValue::getValue)
+                        .toList());
     }
 
     @Test
@@ -208,6 +263,18 @@ void hostsOfficialGrpcServiceThroughRestletHttp2Server() throws Exception {
                                                 result.onCompleted();
                                             }
                                         }))
+                        .addMethod(
+                                STREAM_METHOD,
+                                ServerCalls.asyncServerStreamingCall(
+                                        (StringValue message,
+                                                io.grpc.stub.StreamObserver<StringValue>
+                                                        result) -> {
+                                            result.onNext(
+                                                    StringValue.of(message.getValue() + ":1"));
+                                            result.onNext(
+                                                    StringValue.of(message.getValue() + ":2"));
+                                            result.onCompleted();
+                                        }))
                         .build();
         Context serverContext = new Context();
         serverContext.getParameters().add("http.transport.protocol", "HTTP2");
@@ -238,6 +305,20 @@ void hostsOfficialGrpcServiceThroughRestletHttp2Server() throws Exception {
                                         CallOptions.DEFAULT,
                                         StringValue.of("bad")));
         assertEquals(Status.Code.INVALID_ARGUMENT, failure.getStatus().getCode());
+        var stream =
+                ClientCalls.blockingServerStreamingCall(
+                        grpcClientChannel,
+                        STREAM_METHOD,
+                        CallOptions.DEFAULT,
+                        StringValue.of("stream"));
+        assertEquals(
+                List.of("stream:1", "stream:2"),
+                java.util.stream.StreamSupport.stream(
+                                java.util.Spliterators.spliteratorUnknownSize(
+                                        stream, java.util.Spliterator.ORDERED),
+                                false)
+                        .map(StringValue::getValue)
+                        .toList());
     }
 
     private static final class RestletGrpcServer extends org.restlet.Restlet {
@@ -299,6 +380,9 @@ private <RequestT, ResponseT> void dispatch(
             }
             listener.onMessage(method.parseRequest(new ByteArrayInputStream(payload)));
             listener.onHalfClose();
+            if (!serverCall.awaitClose()) {
+                throw new IOException("Timed out waiting for SDK gRPC server call to close");
+            }
             serverCall.writeResponse(response);
         }
     }
@@ -308,10 +392,12 @@ private static final class SpikeServerCall<RequestT, ResponseT>
 
         private final MethodDescriptor<RequestT, ResponseT> method;
 
-        private ResponseT responseMessage;
+        private final List<ResponseT> responseMessages = new ArrayList<>();
 
         private final Metadata responseHeaders = new Metadata();
 
+        private final CountDownLatch closed = new CountDownLatch(1);
+
         private Status status;
 
         private Metadata trailers = new Metadata();
@@ -330,13 +416,14 @@ public void sendHeaders(Metadata headers) {
 
         @Override
         public void sendMessage(ResponseT message) {
-            responseMessage = message;
+            responseMessages.add(message);
         }
 
         @Override
         public void close(Status status, Metadata trailers) {
             this.status = status;
             this.trailers = trailers;
+            closed.countDown();
         }
 
         @Override
@@ -349,6 +436,15 @@ public MethodDescriptor<RequestT, ResponseT> getMethodDescriptor() {
             return method;
         }
 
+        private boolean awaitClose() throws IOException {
+            try {
+                return closed.await(5, TimeUnit.SECONDS);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                throw new IOException("Interrupted while waiting for gRPC call completion", e);
+            }
+        }
+
         private void writeResponse(Response response) throws IOException {
             if (status == null) {
                 status = Status.INTERNAL.withDescription("SDK call did not close");
@@ -356,15 +452,24 @@ private void writeResponse(Response response) throws IOException {
             }
             response.setStatus(org.restlet.data.Status.SUCCESS_OK);
             writeMetadata(responseHeaders, response.getHeaders());
-            if (responseMessage != null && status.isOk()) {
-                try (InputStream payload = method.streamResponse(responseMessage)) {
-                    byte[] bytes = payload.readNBytes(MAX_MESSAGE_BYTES + 1);
-                    if (bytes.length > MAX_MESSAGE_BYTES) {
-                        throw new IOException(
-                                "gRPC response exceeds " + MAX_MESSAGE_BYTES + " bytes");
+            if (!responseMessages.isEmpty() && status.isOk()) {
+                ByteArrayOutputStream framedMessages = new ByteArrayOutputStream();
+                for (ResponseT responseMessage : responseMessages) {
+                    try (InputStream payload = method.streamResponse(responseMessage)) {
+                        byte[] bytes = payload.readNBytes(MAX_MESSAGE_BYTES + 1);
+                        if (bytes.length > MAX_MESSAGE_BYTES) {
+                            throw new IOException(
+                                    "gRPC response exceeds " + MAX_MESSAGE_BYTES + " bytes");
+                        }
+                        framedMessages.write(frame(bytes));
+                        if (framedMessages.size() > MAX_STREAM_BYTES) {
+                            throw new IOException(
+                                    "gRPC response stream exceeds " + MAX_STREAM_BYTES + " bytes");
+                        }
                     }
-                    response.setEntity(new ByteArrayRepresentation(frame(bytes), GRPC_MEDIA_TYPE));
                 }
+                response.setEntity(
+                        new ByteArrayRepresentation(framedMessages.toByteArray(), GRPC_MEDIA_TYPE));
             } else {
                 response.setEntity(new ByteArrayRepresentation(new byte[0], GRPC_MEDIA_TYPE));
             }
@@ -513,8 +618,10 @@ public ClientStream newStream(
             if (shutdown) {
                 throw new IllegalStateException("gRPC transport is shut down");
             }
-            if (method.getType() != MethodDescriptor.MethodType.UNARY) {
-                throw new UnsupportedOperationException("R0 SPI probe supports unary calls only");
+            if (method.getType() != MethodDescriptor.MethodType.UNARY
+                    && method.getType() != MethodDescriptor.MethodType.SERVER_STREAMING) {
+                throw new UnsupportedOperationException(
+                        "R0 SPI probe supports unary and server-streaming calls only");
             }
             if (callOptions.getCredentials() != null || callOptions.getCompressor() != null) {
                 throw new UnsupportedOperationException(
@@ -709,10 +816,14 @@ public void halfClose() {
                     InputStream responseStream = response.getEntity().getStream();
                     if (responseStream != null) {
                         try (InputStream input = responseStream) {
-                            byte[] framedResponse = input.readNBytes(maxInboundMessageSize + 6);
-                            if (framedResponse.length > 0) {
-                                responsePayload = unframe(framedResponse, maxInboundMessageSize);
+                            byte[] framedResponse = input.readNBytes(MAX_STREAM_BYTES + 1);
+                            if (framedResponse.length > MAX_STREAM_BYTES) {
+                                throw new IOException(
+                                        "gRPC response stream exceeds "
+                                                + MAX_STREAM_BYTES
+                                                + " bytes");
                             }
+                            responsePayload = framedResponse;
                         }
                     }
                 }
@@ -746,18 +857,17 @@ public void halfClose() {
                     throw new IOException("gRPC response did not contain a message");
                 }
                 listener.headersRead(readMetadata(response.getHeaders()));
-                byte[] message = responsePayload;
+                List<byte[]> messages = unframeMessages(responsePayload, maxInboundMessageSize);
                 listener.messagesAvailable(
                         new StreamListener.MessageProducer() {
-                            private boolean consumed;
+                            private int next;
 
                             @Override
                             public InputStream next() {
-                                if (consumed) {
+                                if (next == messages.size()) {
                                     return null;
                                 }
-                                consumed = true;
-                                return new ByteArrayInputStream(message);
+                                return new ByteArrayInputStream(messages.get(next++));
                             }
                         });
                 close(status, ClientStreamListener.RpcProgress.PROCESSED, trailers);
@@ -880,6 +990,24 @@ private static byte[] unframe(byte[] frame, int maxMessageSize) throws IOExcepti
         return java.util.Arrays.copyOfRange(frame, 5, frame.length);
     }
 
+    private static List<byte[]> unframeMessages(byte[] bytes, int maxMessageSize)
+            throws IOException {
+        List<byte[]> messages = new ArrayList<>();
+        int offset = 0;
+        while (offset < bytes.length) {
+            if (bytes.length - offset < 5 || bytes[offset] != 0) {
+                throw new IOException("Invalid or compressed gRPC message frame");
+            }
+            int length = ByteBuffer.wrap(bytes, offset + 1, 4).order(ByteOrder.BIG_ENDIAN).getInt();
+            if (length < 0 || length > maxMessageSize || bytes.length - offset < length + 5) {
+                throw new IOException("Invalid gRPC message length: " + length);
+            }
+            messages.add(java.util.Arrays.copyOfRange(bytes, offset + 5, offset + length + 5));
+            offset += length + 5;
+        }
+        return messages;
+    }
+
     private static void writeMetadata(Metadata metadata, Series<Header> headers) {
         for (String name : metadata.keys()) {
             if (name.startsWith("grpc-")) {
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
index a1e9c71381..6e466c43cf 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -13,6 +13,8 @@
 
 import io.modelcontextprotocol.client.McpAsyncClient;
 import io.modelcontextprotocol.client.McpClient;
+import io.modelcontextprotocol.client.transport.ServerParameters;
+import io.modelcontextprotocol.client.transport.StdioClientTransport;
 import io.modelcontextprotocol.common.McpTransportContext;
 import io.modelcontextprotocol.json.McpJsonDefaults;
 import io.modelcontextprotocol.json.McpJsonMapper;
@@ -24,6 +26,8 @@
 import io.modelcontextprotocol.spec.McpStatelessServerTransport;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.Files;
+import java.nio.file.Path;
 import java.time.Duration;
 import java.util.Map;
 import java.util.concurrent.atomic.AtomicReference;
@@ -56,6 +60,8 @@ class McpSdkTransportSpikeTestCase {
 
     private McpStatelessAsyncServer sdkServer;
 
+    private McpAsyncClient stdioClient;
+
     private Server server;
 
     @BeforeEach
@@ -71,6 +77,9 @@ void tearDown() throws Exception {
         if (sdkServer != null) {
             sdkServer.close();
         }
+        if (stdioClient != null) {
+            stdioClient.close();
+        }
         if (sdkClient != null) {
             sdkClient.close();
         }
@@ -160,6 +169,46 @@ void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
         assertEquals("2.0", clientTransport.lastResponseProtocol.get().getVersion());
     }
 
+    @Test
+    void dispatchesMcpSdkClientAndServerThroughOfficialStdioTransports() throws Exception {
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
+        String javaExecutable =
+                Path.of(
+                                System.getProperty("java.home"),
+                                "bin",
+                                System.getProperty("os.name").toLowerCase().contains("win")
+                                        ? "java.exe"
+                                        : "java")
+                        .toString();
+        String classPath =
+                System.getProperty(
+                        "surefire.test.class.path", System.getProperty("java.class.path"));
+        assertTrue(Files.isRegularFile(Path.of(javaExecutable)));
+        assertTrue(classPath.contains("test-classes") || classPath.contains("surefire"));
+        ServerParameters parameters =
+                ServerParameters.builder(javaExecutable)
+                        .args("-cp", classPath, McpStdioSdkServerProcess.class.getName())
+                        .build();
+        StdioClientTransport transport = new StdioClientTransport(parameters, mapper);
+        stdioClient =
+                McpClient.async(transport)
+                        .requestTimeout(REQUEST_TIMEOUT)
+                        .initializationTimeout(REQUEST_TIMEOUT)
+                        .build();
+
+        stdioClient.initialize().block(REQUEST_TIMEOUT);
+        McpSchema.ListToolsResult listedTools = stdioClient.listTools().block(REQUEST_TIMEOUT);
+        McpSchema.CallToolResult result =
+                stdioClient
+                        .callTool(
+                                new McpSchema.CallToolRequest(
+                                        "echo", Map.of("text", "stdio"), null))
+                        .block(REQUEST_TIMEOUT);
+
+        assertTrue(listedTools.tools().stream().anyMatch(item -> item.name().equals("echo")));
+        assertEquals("echo:stdio", ((McpSchema.TextContent) result.content().getFirst()).text());
+    }
+
     private static final class RestletHttpTransport extends Restlet
             implements McpStatelessServerTransport {
 
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpStdioSdkServerProcess.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpStdioSdkServerProcess.java
new file mode 100644
index 0000000000..62032d761f
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpStdioSdkServerProcess.java
@@ -0,0 +1,64 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+package org.restlet.engine.connector;
+
+import io.modelcontextprotocol.json.McpJsonDefaults;
+import io.modelcontextprotocol.server.McpServer;
+import io.modelcontextprotocol.server.transport.StdioServerTransportProvider;
+import io.modelcontextprotocol.spec.McpSchema;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CountDownLatch;
+import reactor.core.publisher.Mono;
+
+public final class McpStdioSdkServerProcess {
+
+    private McpStdioSdkServerProcess() {}
+
+    public static void main(String[] args) throws InterruptedException {
+        StdioServerTransportProvider transport =
+                new StdioServerTransportProvider(McpJsonDefaults.getMapper());
+        McpSchema.Tool tool =
+                new McpSchema.Tool(
+                        "echo",
+                        null,
+                        "Returns the supplied text",
+                        Map.of(
+                                "type",
+                                "object",
+                                "properties",
+                                Map.of("text", Map.of("type", "string")),
+                                "required",
+                                List.of("text")),
+                        null,
+                        null,
+                        null,
+                        null);
+        var server =
+                McpServer.async(transport)
+                        .serverInfo("restlet-r0-stdio-spike", "1")
+                        .toolCall(
+                                tool,
+                                (context, call) ->
+                                        Mono.just(
+                                                McpSchema.CallToolResult.builder()
+                                                        .addTextContent(
+                                                                "echo:"
+                                                                        + call.arguments()
+                                                                                .get("text"))
+                                                        .build()))
+                        .build();
+        Runtime.getRuntime()
+                .addShutdownHook(
+                        new Thread(
+                                () -> server.closeGracefully().block(),
+                                "mcp-stdio-r0-server-close"));
+        new CountDownLatch(1).await();
+    }
+}

From 666a612f72d0c6ce3097ac17dade55e133a3a41d Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:34:32 -0400
Subject: [PATCH 03/18] Probe MCP Streamable HTTP over Restlet

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...cpStreamableSdkTransportSpikeTestCase.java | 510 ++++++++++++++++++
 1 file changed, 510 insertions(+)
 create mode 100644 org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
new file mode 100644
index 0000000000..b143b5a53d
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
@@ -0,0 +1,510 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+package org.restlet.engine.connector;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.modelcontextprotocol.client.McpAsyncClient;
+import io.modelcontextprotocol.client.McpClient;
+import io.modelcontextprotocol.json.McpJsonDefaults;
+import io.modelcontextprotocol.json.McpJsonMapper;
+import io.modelcontextprotocol.json.TypeRef;
+import io.modelcontextprotocol.server.McpServer;
+import io.modelcontextprotocol.spec.McpClientTransport;
+import io.modelcontextprotocol.spec.McpSchema;
+import io.modelcontextprotocol.spec.McpStreamableServerSession;
+import io.modelcontextprotocol.spec.McpStreamableServerTransport;
+import io.modelcontextprotocol.spec.McpStreamableServerTransportProvider;
+import java.io.IOException;
+import java.io.InputStream;
+import java.time.Duration;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.restlet.Client;
+import org.restlet.Context;
+import org.restlet.Request;
+import org.restlet.Response;
+import org.restlet.Restlet;
+import org.restlet.Server;
+import org.restlet.data.MediaType;
+import org.restlet.data.Method;
+import org.restlet.data.Preference;
+import org.restlet.data.Protocol;
+import org.restlet.engine.Engine;
+import org.restlet.representation.StringRepresentation;
+import reactor.core.publisher.Mono;
+import reactor.core.scheduler.Schedulers;
+
+class McpStreamableSdkTransportSpikeTestCase {
+
+    private static final int MAX_MESSAGE_BYTES = 64 * 1024;
+
+    private static final Duration REQUEST_TIMEOUT = Duration.ofSeconds(5);
+
+    private Client client;
+
+    private McpAsyncClient sdkClient;
+
+    private io.modelcontextprotocol.server.McpAsyncServer sdkServer;
+
+    private Server server;
+
+    @BeforeEach
+    void setUp() {
+        Engine.clearThreadLocalVariables();
+        Engine.register(false);
+        Engine.getInstance().getRegisteredServers().add(new HttpServerHelper(null));
+        Engine.getInstance().getRegisteredClients().add(new HttpClientHelper(null));
+    }
+
+    @AfterEach
+    void tearDown() throws Exception {
+        if (sdkClient != null) {
+            sdkClient.close();
+        }
+        if (sdkServer != null) {
+            sdkServer.close();
+        }
+        if (client != null) {
+            client.stop();
+        }
+        if (server != null) {
+            server.stop();
+        }
+        Engine.clearThreadLocalVariables();
+    }
+
+    @Test
+    void dispatchesMcpSdkClientAndServerThroughRestletStreamableHttp() throws Exception {
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
+        RestletStreamableTransport transport = new RestletStreamableTransport(mapper);
+        McpSchema.Tool tool =
+                new McpSchema.Tool(
+                        "echo",
+                        null,
+                        "Returns the supplied text",
+                        Map.of(
+                                "type",
+                                "object",
+                                "properties",
+                                Map.of("text", Map.of("type", "string")),
+                                "required",
+                                List.of("text")),
+                        null,
+                        null,
+                        null,
+                        null);
+        sdkServer =
+                McpServer.async(transport)
+                        .serverInfo("restlet-r0-streamable-spike", "1")
+                        .toolCall(
+                                tool,
+                                (context, call) ->
+                                        Mono.just(
+                                                McpSchema.CallToolResult.builder()
+                                                        .addTextContent(
+                                                                "echo:"
+                                                                        + call.arguments()
+                                                                                .get("text"))
+                                                        .build()))
+                        .build();
+
+        Context serverContext = new Context();
+        serverContext.getParameters().add("http.transport.protocol", "HTTP2");
+        server = new Server(serverContext, Protocol.HTTP, 0, transport);
+        server.start();
+
+        Context clientContext = new Context();
+        clientContext.getParameters().add("httpClientTransportMode", "HTTP2");
+        client = new Client(clientContext, Protocol.HTTP);
+        client.start();
+        RestletStreamableClientTransport clientTransport =
+                new RestletStreamableClientTransport(
+                        client, mapper, "http://localhost:" + server.getActualPort() + "/mcp");
+        sdkClient =
+                McpClient.async(clientTransport)
+                        .requestTimeout(REQUEST_TIMEOUT)
+                        .initializationTimeout(REQUEST_TIMEOUT)
+                        .build();
+
+        sdkClient.initialize().block(REQUEST_TIMEOUT);
+        McpSchema.ListToolsResult listedTools = sdkClient.listTools().block(REQUEST_TIMEOUT);
+        McpSchema.CallToolResult result =
+                sdkClient
+                        .callTool(
+                                new McpSchema.CallToolRequest(
+                                        "echo", Map.of("text", "streamable"), null))
+                        .block(REQUEST_TIMEOUT);
+
+        assertTrue(listedTools.tools().stream().anyMatch(item -> item.name().equals("echo")));
+        assertEquals(
+                "echo:streamable", ((McpSchema.TextContent) result.content().getFirst()).text());
+        assertEquals(3, transport.postCount.get());
+        assertEquals("2.0", clientTransport.lastResponseProtocol.get().getVersion());
+    }
+
+    private static final class RestletStreamableTransport extends Restlet
+            implements McpStreamableServerTransportProvider {
+
+        private final McpJsonMapper jsonMapper;
+
+        private final Map<String, McpStreamableServerSession> sessions = new ConcurrentHashMap<>();
+
+        private final AtomicInteger postCount = new AtomicInteger();
+
+        private volatile McpStreamableServerSession.Factory sessionFactory;
+
+        private RestletStreamableTransport(McpJsonMapper jsonMapper) {
+            this.jsonMapper = jsonMapper;
+        }
+
+        @Override
+        public void setSessionFactory(McpStreamableServerSession.Factory sessionFactory) {
+            this.sessionFactory = sessionFactory;
+        }
+
+        @Override
+        public Mono<Void> notifyClients(String sessionId, Object notification) {
+            return Mono.error(
+                    new UnsupportedOperationException(
+                            "The R0 Streamable HTTP probe does not open server-sent streams"));
+        }
+
+        @Override
+        public Mono<Void> closeGracefully() {
+            return Mono.<Void>fromRunnable(
+                            () -> sessions.values().forEach(McpStreamableServerSession::close))
+                    .doFinally(signal -> sessions.clear());
+        }
+
+        @Override
+        public void handle(Request request, Response response) {
+            if (request.getMethod().equals(Method.DELETE)) {
+                deleteSession(request, response);
+            } else if (request.getMethod().equals(Method.POST)) {
+                postMessage(request, response);
+            } else {
+                response.setStatus(org.restlet.data.Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+            }
+        }
+
+        private void postMessage(Request request, Response response) {
+            if (!request.isEntityAvailable()) {
+                response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
+                return;
+            }
+
+            try (InputStream input = request.getEntity().getStream()) {
+                byte[] bytes = input.readNBytes(MAX_MESSAGE_BYTES + 1);
+                if (bytes.length > MAX_MESSAGE_BYTES) {
+                    response.setStatus(
+                            org.restlet.data.Status.CLIENT_ERROR_REQUEST_ENTITY_TOO_LARGE);
+                    return;
+                }
+                McpSchema.JSONRPCMessage message =
+                        McpSchema.deserializeJsonRpcMessage(
+                                jsonMapper,
+                                new String(bytes, java.nio.charset.StandardCharsets.UTF_8));
+                if (message instanceof McpSchema.JSONRPCRequest) {
+                    postCount.incrementAndGet();
+                }
+                if (message instanceof McpSchema.JSONRPCRequest rpcRequest
+                        && McpSchema.METHOD_INITIALIZE.equals(rpcRequest.method())) {
+                    initializeSession(rpcRequest, response);
+                    return;
+                }
+
+                String sessionId = request.getHeaders().getFirstValue("Mcp-Session-Id", true);
+                McpStreamableServerSession session = sessions.get(sessionId);
+                if (session == null) {
+                    response.setStatus(org.restlet.data.Status.CLIENT_ERROR_NOT_FOUND);
+                    response.setEntity(
+                            "Unknown MCP session: "
+                                    + sessionId
+                                    + "; request headers: "
+                                    + request.getHeaders(),
+                            MediaType.TEXT_PLAIN);
+                    return;
+                }
+                response.getHeaders().add("Mcp-Session-Id", sessionId);
+
+                if (message instanceof McpSchema.JSONRPCRequest rpcRequest) {
+                    AtomicReference<McpSchema.JSONRPCMessage> result = new AtomicReference<>();
+                    McpStreamableServerSession.McpStreamableServerSessionStream stream =
+                            session.responseStream(new JsonResponseTransport(jsonMapper, result));
+                    stream.handle(rpcRequest)
+                            .doFinally(signal -> stream.releaseTransport())
+                            .block(REQUEST_TIMEOUT);
+                    McpSchema.JSONRPCMessage reply = result.get();
+                    if (reply == null) {
+                        response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
+                    } else {
+                        writeJsonResponse(response, reply);
+                    }
+                } else if (message instanceof McpSchema.JSONRPCNotification notification) {
+                    session.accept(notification).block(REQUEST_TIMEOUT);
+                    response.setStatus(org.restlet.data.Status.SUCCESS_ACCEPTED);
+                } else if (message instanceof McpSchema.JSONRPCResponse rpcResponse) {
+                    session.accept(rpcResponse).block(REQUEST_TIMEOUT);
+                    response.setStatus(org.restlet.data.Status.SUCCESS_ACCEPTED);
+                } else {
+                    response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
+                }
+            } catch (IOException e) {
+                getLogger().warning("Unable to read MCP streamable request: " + e.getMessage());
+                response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
+            } catch (RuntimeException e) {
+                getLogger().warning("Unable to dispatch MCP streamable request: " + e.getMessage());
+                response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
+            }
+        }
+
+        private void initializeSession(McpSchema.JSONRPCRequest request, Response response)
+                throws IOException {
+            McpStreamableServerSession.Factory currentFactory = sessionFactory;
+            if (currentFactory == null) {
+                response.setStatus(org.restlet.data.Status.SERVER_ERROR_SERVICE_UNAVAILABLE);
+                return;
+            }
+            McpSchema.InitializeRequest initializeRequest =
+                    jsonMapper.convertValue(
+                            request.params(), new TypeRef<McpSchema.InitializeRequest>() {});
+            McpStreamableServerSession.McpStreamableServerSessionInit init =
+                    currentFactory.startSession(initializeRequest);
+            McpSchema.InitializeResult initResult = init.initResult().block(REQUEST_TIMEOUT);
+            sessions.put(init.session().getId(), init.session());
+            response.getHeaders().add("Mcp-Session-Id", init.session().getId());
+            writeJsonResponse(response, McpSchema.JSONRPCResponse.result(request.id(), initResult));
+        }
+
+        private void deleteSession(Request request, Response response) {
+            String sessionId = request.getHeaders().getFirstValue("Mcp-Session-Id", true);
+            McpStreamableServerSession session = sessions.remove(sessionId);
+            if (session == null) {
+                response.setStatus(org.restlet.data.Status.CLIENT_ERROR_NOT_FOUND);
+                return;
+            }
+            session.close();
+            response.setStatus(org.restlet.data.Status.SUCCESS_NO_CONTENT);
+        }
+
+        private void writeJsonResponse(Response response, McpSchema.JSONRPCMessage message)
+                throws IOException {
+            response.setEntity(jsonMapper.writeValueAsString(message), MediaType.APPLICATION_JSON);
+        }
+    }
+
+    private static final class JsonResponseTransport implements McpStreamableServerTransport {
+
+        private final McpJsonMapper jsonMapper;
+
+        private final AtomicReference<McpSchema.JSONRPCMessage> response;
+
+        private JsonResponseTransport(
+                McpJsonMapper jsonMapper, AtomicReference<McpSchema.JSONRPCMessage> response) {
+            this.jsonMapper = jsonMapper;
+            this.response = response;
+        }
+
+        @Override
+        public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message, String messageId) {
+            response.set(message);
+            return Mono.empty();
+        }
+
+        @Override
+        public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+            return sendMessage(message, null);
+        }
+
+        @Override
+        public <T> T unmarshalFrom(Object value, TypeRef<T> typeRef) {
+            return jsonMapper.convertValue(value, typeRef);
+        }
+
+        @Override
+        public Mono<Void> closeGracefully() {
+            return Mono.empty();
+        }
+    }
+
+    private static final class RestletStreamableClientTransport implements McpClientTransport {
+
+        private final Client client;
+
+        private final McpJsonMapper jsonMapper;
+
+        private final String target;
+
+        private final AtomicReference<Protocol> lastResponseProtocol = new AtomicReference<>();
+
+        private volatile java.util.function.Function<
+                        Mono<McpSchema.JSONRPCMessage>, Mono<McpSchema.JSONRPCMessage>>
+                incomingMessageHandler;
+
+        private volatile String sessionId;
+
+        private volatile String protocolVersion;
+
+        private RestletStreamableClientTransport(
+                Client client, McpJsonMapper jsonMapper, String target) {
+            this.client = client;
+            this.jsonMapper = jsonMapper;
+            this.target = target;
+        }
+
+        @Override
+        public Mono<Void> connect(
+                java.util.function.Function<
+                                Mono<McpSchema.JSONRPCMessage>, Mono<McpSchema.JSONRPCMessage>>
+                        handler) {
+            incomingMessageHandler = handler;
+            return Mono.empty();
+        }
+
+        @Override
+        public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+            return Mono.fromRunnable(() -> sendMessageBlocking(message))
+                    .subscribeOn(Schedulers.boundedElastic())
+                    .then();
+        }
+
+        private void sendMessageBlocking(McpSchema.JSONRPCMessage message) {
+            try {
+                Request request =
+                        new Request(
+                                Method.POST,
+                                target,
+                                new StringRepresentation(
+                                        jsonMapper.writeValueAsString(message),
+                                        MediaType.APPLICATION_JSON));
+                request.getClientInfo()
+                        .getAcceptedMediaTypes()
+                        .add(new Preference<>(MediaType.APPLICATION_JSON));
+                request.getClientInfo()
+                        .getAcceptedMediaTypes()
+                        .add(new Preference<>(new MediaType("text/event-stream")));
+                if (sessionId != null) {
+                    request.getHeaders().add("Mcp-Session-Id", sessionId);
+                    request.getHeaders().add("Mcp-Protocol-Version", protocolVersion);
+                }
+
+                Response response = client.handle(request);
+                lastResponseProtocol.set(response.getProtocol());
+                boolean initializing =
+                        message instanceof McpSchema.JSONRPCRequest rpcRequest
+                                && McpSchema.METHOD_INITIALIZE.equals(rpcRequest.method());
+                if (message instanceof McpSchema.JSONRPCRequest rpcRequest
+                        && McpSchema.METHOD_INITIALIZE.equals(rpcRequest.method())
+                        && response.getHeaders().getFirstValue("Mcp-Session-Id", true) == null) {
+                    throw new IllegalStateException(
+                            "MCP initialize response omitted session ID; headers: "
+                                    + response.getHeaders());
+                }
+                if (!response.getStatus().isSuccess()) {
+                    String errorBody = "";
+                    if (response.getEntity() != null) {
+                        try (InputStream errorStream = response.getEntity().getStream()) {
+                            if (errorStream != null) {
+                                errorBody =
+                                        new String(
+                                                errorStream.readNBytes(MAX_MESSAGE_BYTES),
+                                                java.nio.charset.StandardCharsets.UTF_8);
+                            }
+                        }
+                    }
+                    throw new IllegalStateException(
+                            "MCP streamable request failed: "
+                                    + response.getStatus()
+                                    + " "
+                                    + errorBody);
+                }
+                if (message instanceof McpSchema.JSONRPCRequest) {
+                    if (initializing) {
+                        sessionId = response.getHeaders().getFirstValue("Mcp-Session-Id", true);
+                    }
+                    if (response.getEntity() == null) {
+                        throw new IllegalStateException(
+                                "MCP streamable response has no JSON entity: "
+                                        + response.getStatus());
+                    }
+                    try (InputStream input = response.getEntity().getStream()) {
+                        byte[] bytes = input.readNBytes(MAX_MESSAGE_BYTES + 1);
+                        if (bytes.length > MAX_MESSAGE_BYTES) {
+                            throw new IllegalStateException(
+                                    "MCP streamable response exceeds the configured size limit");
+                        }
+                        McpSchema.JSONRPCMessage reply =
+                                McpSchema.deserializeJsonRpcMessage(
+                                        jsonMapper,
+                                        new String(bytes, java.nio.charset.StandardCharsets.UTF_8));
+                        if (reply instanceof McpSchema.JSONRPCResponse rpcResponse
+                                && rpcResponse.result() != null
+                                && message instanceof McpSchema.JSONRPCRequest requestMessage
+                                && McpSchema.METHOD_INITIALIZE.equals(requestMessage.method())) {
+                            protocolVersion =
+                                    jsonMapper
+                                            .convertValue(
+                                                    rpcResponse.result(),
+                                                    McpSchema.InitializeResult.class)
+                                            .protocolVersion();
+                        }
+                        java.util.function.Function<
+                                        Mono<McpSchema.JSONRPCMessage>,
+                                        Mono<McpSchema.JSONRPCMessage>>
+                                handler = incomingMessageHandler;
+                        if (handler == null) {
+                            throw new IllegalStateException(
+                                    "MCP client transport is not connected");
+                        }
+                        handler.apply(Mono.just(reply)).block(REQUEST_TIMEOUT);
+                    }
+                } else if (!response.getStatus().isSuccess()) {
+                    throw new IllegalStateException(
+                            "MCP streamable notification failed: " + response.getStatus());
+                }
+            } catch (IOException e) {
+                throw new IllegalStateException("Unable to encode MCP streamable request", e);
+            }
+        }
+
+        @Override
+        public <T> T unmarshalFrom(Object value, TypeRef<T> typeRef) {
+            return jsonMapper.convertValue(value, typeRef);
+        }
+
+        @Override
+        public Mono<Void> closeGracefully() {
+            if (sessionId == null) {
+                return Mono.empty();
+            }
+            return Mono.fromRunnable(
+                            () -> {
+                                Request request = new Request(Method.DELETE, target);
+                                request.getHeaders().add("Mcp-Session-Id", sessionId);
+                                Response response = client.handle(request);
+                                if (!response.getStatus().isSuccess()) {
+                                    throw new IllegalStateException(
+                                            "MCP streamable session close failed: "
+                                                    + response.getStatus());
+                                }
+                                sessionId = null;
+                            })
+                    .subscribeOn(Schedulers.boundedElastic())
+                    .then();
+        }
+    }
+}

From ee708aeda75e237575fdb60078f1d04d7bc73b7b Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:44:52 -0400
Subject: [PATCH 04/18] Exercise gRPC client-stream half-close interop

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrpcSdkTransportSpikeTestCase.java        | 162 ++++++++++++++++--
 1 file changed, 143 insertions(+), 19 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index 18a7b423f4..118530db2a 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -10,6 +10,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.google.common.util.concurrent.Futures;
 import com.google.common.util.concurrent.ListenableFuture;
@@ -100,6 +101,14 @@ class GrpcSdkTransportSpikeTestCase {
                     .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
                     .build();
 
+    private static final MethodDescriptor<StringValue, StringValue> CLIENT_STREAM_METHOD =
+            MethodDescriptor.<StringValue, StringValue>newBuilder()
+                    .setType(MethodDescriptor.MethodType.CLIENT_STREAMING)
+                    .setFullMethodName("restlet.r0.Echo/ClientStream")
+                    .setRequestMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .build();
+
     private Client client;
 
     private io.grpc.Server grpcServer;
@@ -191,6 +200,32 @@ void invokesOfficialGrpcServerThroughRestletHttp2Client() throws Exception {
                                                         }
                                                     });
                                         }))
+                        .addMethod(
+                                CLIENT_STREAM_METHOD,
+                                ServerCalls.asyncClientStreamingCall(
+                                        result ->
+                                                new io.grpc.stub.StreamObserver<>() {
+                                                    private final List<String> values =
+                                                            new ArrayList<>();
+
+                                                    @Override
+                                                    public void onNext(StringValue value) {
+                                                        values.add(value.getValue());
+                                                    }
+
+                                                    @Override
+                                                    public void onError(Throwable error) {
+                                                        result.onError(error);
+                                                    }
+
+                                                    @Override
+                                                    public void onCompleted() {
+                                                        result.onNext(
+                                                                StringValue.of(
+                                                                        String.join(",", values)));
+                                                        result.onCompleted();
+                                                    }
+                                                }))
                         .build();
         grpcServer = NettyServerBuilder.forPort(0).addService(service).build().start();
 
@@ -239,6 +274,8 @@ void invokesOfficialGrpcServerThroughRestletHttp2Client() throws Exception {
                                 false)
                         .map(StringValue::getValue)
                         .toList());
+
+        assertClientStreaming(channel);
     }
 
     @Test
@@ -275,6 +312,32 @@ void hostsOfficialGrpcServiceThroughRestletHttp2Server() throws Exception {
                                                     StringValue.of(message.getValue() + ":2"));
                                             result.onCompleted();
                                         }))
+                        .addMethod(
+                                CLIENT_STREAM_METHOD,
+                                ServerCalls.asyncClientStreamingCall(
+                                        result ->
+                                                new io.grpc.stub.StreamObserver<>() {
+                                                    private final List<String> values =
+                                                            new ArrayList<>();
+
+                                                    @Override
+                                                    public void onNext(StringValue value) {
+                                                        values.add(value.getValue());
+                                                    }
+
+                                                    @Override
+                                                    public void onError(Throwable error) {
+                                                        result.onError(error);
+                                                    }
+
+                                                    @Override
+                                                    public void onCompleted() {
+                                                        result.onNext(
+                                                                StringValue.of(
+                                                                        String.join(",", values)));
+                                                        result.onCompleted();
+                                                    }
+                                                }))
                         .build();
         Context serverContext = new Context();
         serverContext.getParameters().add("http.transport.protocol", "HTTP2");
@@ -319,6 +382,42 @@ void hostsOfficialGrpcServiceThroughRestletHttp2Server() throws Exception {
                                 false)
                         .map(StringValue::getValue)
                         .toList());
+
+        assertClientStreaming(grpcClientChannel);
+    }
+
+    private static void assertClientStreaming(ManagedChannel channel) throws InterruptedException {
+        CountDownLatch closed = new CountDownLatch(1);
+        AtomicReference<StringValue> response = new AtomicReference<>();
+        AtomicReference<Throwable> failure = new AtomicReference<>();
+        var request =
+                ClientCalls.asyncClientStreamingCall(
+                        channel.newCall(CLIENT_STREAM_METHOD, CallOptions.DEFAULT),
+                        new io.grpc.stub.StreamObserver<>() {
+                            @Override
+                            public void onNext(StringValue value) {
+                                response.set(value);
+                            }
+
+                            @Override
+                            public void onError(Throwable error) {
+                                failure.set(error);
+                                closed.countDown();
+                            }
+
+                            @Override
+                            public void onCompleted() {
+                                closed.countDown();
+                            }
+                        });
+        request.onNext(StringValue.of("first"));
+        request.onNext(StringValue.of("second"));
+        request.onCompleted();
+        assertTrue(closed.await(5, TimeUnit.SECONDS));
+        if (failure.get() != null) {
+            throw new AssertionError("gRPC client-streaming request failed", failure.get());
+        }
+        assertEquals("first,second", response.get().getValue());
     }
 
     private static final class RestletGrpcServer extends org.restlet.Restlet {
@@ -353,12 +452,15 @@ public void handle(Request request, Response response) {
                     return;
                 }
 
-                byte[] frame;
+                byte[] frames;
                 try (InputStream input = request.getEntity().getStream()) {
-                    frame = input.readNBytes(MAX_MESSAGE_BYTES + 6);
+                    frames = input.readNBytes(MAX_STREAM_BYTES + 1);
+                }
+                if (frames.length > MAX_STREAM_BYTES) {
+                    throw new IOException(
+                            "gRPC request stream exceeds " + MAX_STREAM_BYTES + " bytes");
                 }
-                byte[] payload = unframe(frame);
-                dispatch(definition, request, response, payload);
+                dispatch(definition, request, response, unframeMessages(frames, MAX_MESSAGE_BYTES));
             } catch (Exception e) {
                 setGrpcStatus(response, Status.fromThrowable(e));
             }
@@ -368,7 +470,7 @@ private <RequestT, ResponseT> void dispatch(
                 ServerMethodDefinition<RequestT, ResponseT> definition,
                 Request request,
                 Response response,
-                byte[] payload)
+                List<byte[]> payloads)
                 throws IOException {
             MethodDescriptor<RequestT, ResponseT> method = definition.getMethodDescriptor();
             Metadata requestHeaders = readMetadata(request.getHeaders());
@@ -378,7 +480,9 @@ private <RequestT, ResponseT> void dispatch(
             if (listener == null) {
                 throw new IOException("gRPC SDK returned no call listener");
             }
-            listener.onMessage(method.parseRequest(new ByteArrayInputStream(payload)));
+            for (byte[] payload : payloads) {
+                listener.onMessage(method.parseRequest(new ByteArrayInputStream(payload)));
+            }
             listener.onHalfClose();
             if (!serverCall.awaitClose()) {
                 throw new IOException("Timed out waiting for SDK gRPC server call to close");
@@ -619,9 +723,10 @@ public ClientStream newStream(
                 throw new IllegalStateException("gRPC transport is shut down");
             }
             if (method.getType() != MethodDescriptor.MethodType.UNARY
-                    && method.getType() != MethodDescriptor.MethodType.SERVER_STREAMING) {
+                    && method.getType() != MethodDescriptor.MethodType.SERVER_STREAMING
+                    && method.getType() != MethodDescriptor.MethodType.CLIENT_STREAMING) {
                 throw new UnsupportedOperationException(
-                        "R0 SPI probe supports unary and server-streaming calls only");
+                        "R0 SPI probe does not support bidirectional streaming");
             }
             if (callOptions.getCredentials() != null || callOptions.getCompressor() != null) {
                 throw new UnsupportedOperationException(
@@ -716,7 +821,9 @@ private static final class RestletClientStream implements ClientStream {
 
         private volatile Request activeRequest;
 
-        private byte[] requestPayload;
+        private final List<byte[]> requestPayloads = new ArrayList<>();
+
+        private int requestStreamBytes;
 
         private int maxInboundMessageSize = MAX_MESSAGE_BYTES;
 
@@ -724,8 +831,6 @@ private static final class RestletClientStream implements ClientStream {
 
         private volatile boolean closed;
 
-        private volatile boolean messageWritten;
-
         private RestletClientStream(
                 Client client,
                 RestletSocketAddress address,
@@ -770,22 +875,36 @@ public void cancel(Status reason) {
 
         @Override
         public void writeMessage(InputStream message) {
-            if (messageWritten || closed) {
-                throw new IllegalStateException("R0 SPI probe accepts one request message");
+            if (closed) {
+                throw new IllegalStateException("gRPC stream is already closed");
             }
-            messageWritten = true;
+            if (method.getType() == MethodDescriptor.MethodType.UNARY
+                    && !requestPayloads.isEmpty()) {
+                throw new IllegalStateException("R0 unary probe accepts one request message");
+            }
+            byte[] payload;
             try (InputStream input = message) {
-                requestPayload = input.readNBytes(maxOutboundMessageSize + 1);
+                payload = input.readNBytes(maxOutboundMessageSize + 1);
             } catch (IOException e) {
                 close(Status.INTERNAL.withCause(e), new Metadata());
                 return;
             }
-            if (requestPayload.length > maxOutboundMessageSize) {
+            if (payload.length > maxOutboundMessageSize) {
                 close(
                         Status.RESOURCE_EXHAUSTED.withDescription(
                                 "gRPC request exceeds " + maxOutboundMessageSize + " bytes"),
                         new Metadata());
+                return;
+            }
+            requestStreamBytes += payload.length + 5;
+            if (requestStreamBytes > MAX_STREAM_BYTES) {
+                close(
+                        Status.RESOURCE_EXHAUSTED.withDescription(
+                                "gRPC request stream exceeds " + MAX_STREAM_BYTES + " bytes"),
+                        new Metadata());
+                return;
             }
+            requestPayloads.add(payload);
         }
 
         @Override
@@ -793,19 +912,24 @@ public void halfClose() {
             if (closed) {
                 return;
             }
-            if (!messageWritten || requestPayload == null) {
+            if (method.getType() == MethodDescriptor.MethodType.UNARY
+                    && requestPayloads.size() != 1) {
                 close(
                         Status.INTERNAL.withDescription("gRPC unary request message is missing"),
                         new Metadata());
                 return;
             }
             try {
+                ByteArrayOutputStream framedRequest = new ByteArrayOutputStream();
+                for (byte[] payload : requestPayloads) {
+                    framedRequest.write(frame(payload));
+                }
                 Request request =
                         new Request(
                                 Method.POST,
                                 address.target + "/" + method.getFullMethodName(),
                                 new ByteArrayRepresentation(
-                                        frame(requestPayload), GRPC_MEDIA_TYPE));
+                                        framedRequest.toByteArray(), GRPC_MEDIA_TYPE));
                 activeRequest = request;
                 request.getHeaders().add("te", "trailers");
                 writeMetadata(requestMetadata, request.getHeaders());
@@ -900,7 +1024,7 @@ public void flush() {}
 
         @Override
         public boolean isReady() {
-            return !closed && !messageWritten;
+            return !closed;
         }
 
         @Override

From f5e0ebc762b23690fc49329e1b85eaef509bd837 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:48:10 -0400
Subject: [PATCH 05/18] Exercise MCP Streamable POST SSE responses

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...cpStreamableSdkTransportSpikeTestCase.java | 31 ++++++++++++++++---
 1 file changed, 27 insertions(+), 4 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
index b143b5a53d..ad9ba75354 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
@@ -154,6 +154,7 @@ void dispatchesMcpSdkClientAndServerThroughRestletStreamableHttp() throws Except
                 "echo:streamable", ((McpSchema.TextContent) result.content().getFirst()).text());
         assertEquals(3, transport.postCount.get());
         assertEquals("2.0", clientTransport.lastResponseProtocol.get().getVersion());
+        assertTrue(clientTransport.sawEventStreamResponse.get());
     }
 
     private static final class RestletStreamableTransport extends Restlet
@@ -252,7 +253,7 @@ private void postMessage(Request request, Response response) {
                     if (reply == null) {
                         response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
                     } else {
-                        writeJsonResponse(response, reply);
+                        writeEventStreamResponse(response, reply);
                     }
                 } else if (message instanceof McpSchema.JSONRPCNotification notification) {
                     session.accept(notification).block(REQUEST_TIMEOUT);
@@ -305,6 +306,13 @@ private void writeJsonResponse(Response response, McpSchema.JSONRPCMessage messa
                 throws IOException {
             response.setEntity(jsonMapper.writeValueAsString(message), MediaType.APPLICATION_JSON);
         }
+
+        private void writeEventStreamResponse(Response response, McpSchema.JSONRPCMessage message)
+                throws IOException {
+            response.setEntity(
+                    "event: message\ndata: " + jsonMapper.writeValueAsString(message) + "\n\n",
+                    new MediaType("text/event-stream"));
+        }
     }
 
     private static final class JsonResponseTransport implements McpStreamableServerTransport {
@@ -351,6 +359,9 @@ private static final class RestletStreamableClientTransport implements McpClient
 
         private final AtomicReference<Protocol> lastResponseProtocol = new AtomicReference<>();
 
+        private final AtomicReference<Boolean> sawEventStreamResponse =
+                new AtomicReference<>(false);
+
         private volatile java.util.function.Function<
                         Mono<McpSchema.JSONRPCMessage>, Mono<McpSchema.JSONRPCMessage>>
                 incomingMessageHandler;
@@ -447,10 +458,22 @@ private void sendMessageBlocking(McpSchema.JSONRPCMessage message) {
                             throw new IllegalStateException(
                                     "MCP streamable response exceeds the configured size limit");
                         }
+                        String payload = new String(bytes, java.nio.charset.StandardCharsets.UTF_8);
+                        if ("text/event-stream"
+                                .equalsIgnoreCase(response.getEntity().getMediaType().getName())) {
+                            sawEventStreamResponse.set(true);
+                            payload =
+                                    payload.lines()
+                                            .filter(line -> line.startsWith("data:"))
+                                            .map(line -> line.substring("data:".length()).strip())
+                                            .findFirst()
+                                            .orElseThrow(
+                                                    () ->
+                                                            new IllegalStateException(
+                                                                    "MCP SSE response has no data event"));
+                        }
                         McpSchema.JSONRPCMessage reply =
-                                McpSchema.deserializeJsonRpcMessage(
-                                        jsonMapper,
-                                        new String(bytes, java.nio.charset.StandardCharsets.UTF_8));
+                                McpSchema.deserializeJsonRpcMessage(jsonMapper, payload);
                         if (reply instanceof McpSchema.JSONRPCResponse rpcResponse
                                 && rpcResponse.result() != null
                                 && message instanceof McpSchema.JSONRPCRequest requestMessage

From 8468c7438b9dddb4aee5e7a92b632713a518b246 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:53:36 -0400
Subject: [PATCH 06/18] Probe stateless SDK dispatch with Ikanos metadata

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../McpSdkTransportSpikeTestCase.java         | 20 +++++++++++++++++++
 1 file changed, 20 insertions(+)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
index 6e466c43cf..3fdd83d526 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -167,6 +167,26 @@ void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
         assertTrue(listedTools.tools().stream().anyMatch(item -> item.name().equals("echo")));
         assertEquals("echo:hello", ((McpSchema.TextContent) result.content().getFirst()).text());
         assertEquals("2.0", clientTransport.lastResponseProtocol.get().getVersion());
+
+        String profileRequestBody =
+                "{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"tools/list\",\"params\":{\"_meta\":{\"io.modelcontextprotocol/protocolVersion\":\"2026-07-28\"}}}";
+        Request statelessRequest =
+                new Request(
+                        Method.POST,
+                        "http://localhost:" + server.getActualPort() + "/mcp",
+                        new StringRepresentation(profileRequestBody, MediaType.APPLICATION_JSON));
+        statelessRequest.getHeaders().add("Mcp-Method", "tools/list");
+        statelessRequest.getHeaders().add("Mcp-Protocol-Version", "2026-07-28");
+        Response statelessResponse = client.handle(statelessRequest);
+        assertEquals(org.restlet.data.Status.SUCCESS_OK, statelessResponse.getStatus());
+        assertEquals("2.0", statelessResponse.getProtocol().getVersion());
+        try (InputStream input = statelessResponse.getEntity().getStream()) {
+            String body =
+                    new String(
+                            input.readNBytes(MAX_MESSAGE_BYTES),
+                            java.nio.charset.StandardCharsets.UTF_8);
+            assertTrue(body.contains("\"echo\""));
+        }
     }
 
     @Test

From d78fac570792025a1876746a4538fd0c5381f1ac Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Tue, 20 Oct 2026 21:59:56 -0400
Subject: [PATCH 07/18] Assert MCP SDK revision incompatibility

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../McpStreamableSdkTransportSpikeTestCase.java | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
index ad9ba75354..19823113c3 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
@@ -9,10 +9,12 @@
 package org.restlet.engine.connector;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import io.modelcontextprotocol.client.McpAsyncClient;
 import io.modelcontextprotocol.client.McpClient;
+import io.modelcontextprotocol.client.transport.HttpClientStreamableHttpTransport;
 import io.modelcontextprotocol.json.McpJsonDefaults;
 import io.modelcontextprotocol.json.McpJsonMapper;
 import io.modelcontextprotocol.json.TypeRef;
@@ -22,6 +24,7 @@
 import io.modelcontextprotocol.spec.McpStreamableServerSession;
 import io.modelcontextprotocol.spec.McpStreamableServerTransport;
 import io.modelcontextprotocol.spec.McpStreamableServerTransportProvider;
+import io.modelcontextprotocol.spec.ProtocolVersions;
 import java.io.IOException;
 import java.io.InputStream;
 import java.time.Duration;
@@ -157,6 +160,20 @@ void dispatchesMcpSdkClientAndServerThroughRestletStreamableHttp() throws Except
         assertTrue(clientTransport.sawEventStreamResponse.get());
     }
 
+    @Test
+    void pinnedSdkDoesNotAdvertiseIkanosProtocolRevision() {
+        HttpClientStreamableHttpTransport transport =
+                HttpClientStreamableHttpTransport.builder("http://localhost/mcp")
+                        .jsonMapper(McpJsonDefaults.getMapper())
+                        .build();
+        try {
+            assertTrue(transport.protocolVersions().contains(ProtocolVersions.MCP_2025_11_25));
+            assertFalse(transport.protocolVersions().contains("2026-07-28"));
+        } finally {
+            transport.closeGracefully().block(REQUEST_TIMEOUT);
+        }
+    }
+
     private static final class RestletStreamableTransport extends Restlet
             implements McpStreamableServerTransportProvider {
 

From eb1ad50ac360648bb3af79dbb6b3cf48080a778d Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 09:14:13 -0400
Subject: [PATCH 08/18] Probe Ikanos tools profile over MCP SDK dispatch

Exercise stateless tool dispatch, profile header and revision errors, and resultType mapping over shared Restlet HTTP/2. Keep the bridge test-only and bounded to tool methods.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../McpSdkTransportSpikeTestCase.java         | 289 +++++++++++++++++-
 1 file changed, 275 insertions(+), 14 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
index 3fdd83d526..56bdff3ac1 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -9,6 +9,8 @@
 package org.restlet.engine.connector;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertInstanceOf;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import io.modelcontextprotocol.client.McpAsyncClient;
@@ -18,6 +20,7 @@
 import io.modelcontextprotocol.common.McpTransportContext;
 import io.modelcontextprotocol.json.McpJsonDefaults;
 import io.modelcontextprotocol.json.McpJsonMapper;
+import io.modelcontextprotocol.json.TypeRef;
 import io.modelcontextprotocol.server.McpServer;
 import io.modelcontextprotocol.server.McpStatelessAsyncServer;
 import io.modelcontextprotocol.server.McpStatelessServerHandler;
@@ -26,10 +29,16 @@
 import io.modelcontextprotocol.spec.McpStatelessServerTransport;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.time.Duration;
+import java.util.Base64;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Locale;
 import java.util.Map;
+import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -43,6 +52,7 @@
 import org.restlet.data.MediaType;
 import org.restlet.data.Method;
 import org.restlet.data.Protocol;
+import org.restlet.data.Status;
 import org.restlet.engine.Engine;
 import org.restlet.representation.StringRepresentation;
 import reactor.core.publisher.Mono;
@@ -64,6 +74,8 @@ class McpSdkTransportSpikeTestCase {
 
     private Server server;
 
+    private final AtomicInteger toolCalls = new AtomicInteger();
+
     @BeforeEach
     void setUp() {
         Engine.clearThreadLocalVariables();
@@ -92,10 +104,9 @@ void tearDown() throws Exception {
         Engine.clearThreadLocalVariables();
     }
 
-    @Test
-    void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
+    private void startHttpServer(boolean ikanosProfile) throws Exception {
         McpJsonMapper mapper = McpJsonDefaults.getMapper();
-        McpStatelessServerTransport transport = new RestletHttpTransport(mapper);
+        RestletHttpTransport transport = new RestletHttpTransport(mapper, ikanosProfile);
         var tool =
                 new McpSchema.Tool(
                         "echo",
@@ -117,26 +128,36 @@ void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
                         .serverInfo("restlet-r0-spike", "1")
                         .toolCall(
                                 tool,
-                                (context, call) ->
-                                        Mono.just(
-                                                McpSchema.CallToolResult.builder()
-                                                        .addTextContent(
-                                                                "echo:"
-                                                                        + call.arguments()
-                                                                                .get("text"))
-                                                        .build()))
+                                (context, call) -> {
+                                    toolCalls.incrementAndGet();
+                                    return Mono.just(
+                                            McpSchema.CallToolResult.builder()
+                                                    .isError(
+                                                            "fail"
+                                                                    .equals(
+                                                                            call.arguments()
+                                                                                    .get("text")))
+                                                    .addTextContent(
+                                                            "echo:" + call.arguments().get("text"))
+                                                    .build());
+                                })
                         .build();
 
-        RestletHttpTransport restlet = (RestletHttpTransport) transport;
         Context serverContext = new Context();
         serverContext.getParameters().add("http.transport.protocol", "HTTP2");
-        server = new Server(serverContext, Protocol.HTTP, 0, restlet);
+        server = new Server(serverContext, Protocol.HTTP, 0, transport);
         server.start();
 
         Context clientContext = new Context();
         clientContext.getParameters().add("httpClientTransportMode", "HTTP2");
         client = new Client(clientContext, Protocol.HTTP);
         client.start();
+    }
+
+    @Test
+    void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
+        startHttpServer(false);
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
         RestletHttpClientTransport clientTransport =
                 new RestletHttpClientTransport(
                         client, mapper, "http://localhost:" + server.getActualPort() + "/mcp");
@@ -189,6 +210,152 @@ void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
         }
     }
 
+    @Test
+    void bridgesIkanosToolResultsWithoutAnSdkSession() throws Exception {
+        startHttpServer(true);
+        McpSchema.JSONRPCResponse listed = profileRequest("tools/list", Map.of(), Map.of());
+        assertNull(listed.error());
+        Map<String, Object> listing = resultMap(listed.result());
+        assertEquals("complete", listing.get("resultType"));
+        assertTrue(
+                listing.get("tools") instanceof List<?> tools
+                        && tools.size() == 1
+                        && tools.getFirst() instanceof Map<?, ?> tool
+                        && "echo".equals(tool.get("name")));
+
+        McpSchema.JSONRPCResponse called =
+                profileRequest(
+                        "tools/call",
+                        Map.of("name", "echo", "arguments", Map.of("text", "profile")),
+                        Map.of("Mcp-Name", "=?base64?ZWNobw==?="));
+        assertNull(called.error());
+        Map<String, Object> result = resultMap(called.result());
+        assertEquals("complete", result.get("resultType"));
+        assertEquals(
+                List.of(Map.of("type", "text", "text", "echo:profile")), result.get("content"));
+        assertEquals(false, result.get("isError"));
+        assertEquals(1, toolCalls.get());
+
+        McpSchema.JSONRPCResponse failed =
+                profileRequest(
+                        "tools/call",
+                        Map.of("name", "echo", "arguments", Map.of("text", "fail")),
+                        Map.of());
+        assertNull(failed.error());
+        Map<String, Object> failedResult = resultMap(failed.result());
+        assertEquals("complete", failedResult.get("resultType"));
+        assertEquals(true, failedResult.get("isError"));
+        assertEquals(
+                List.of(Map.of("type", "text", "text", "echo:fail")), failedResult.get("content"));
+        assertEquals(2, toolCalls.get());
+    }
+
+    @Test
+    void rejectsIkanosProfileMismatchesBeforeToolDispatch() throws Exception {
+        startHttpServer(true);
+        Map<String, Object> params = Map.of("name", "echo", "arguments", Map.of("text", "unused"));
+        for (Map<String, String> headers :
+                List.of(
+                        Map.of("Mcp-Method", ""),
+                        Map.of("Mcp-Method", "tools/list"),
+                        Map.of("MCP-Protocol-Version", ""),
+                        Map.of("MCP-Protocol-Version", "2025-11-25"),
+                        Map.of("Mcp-Name", ""),
+                        Map.of("Mcp-Name", "wrong"),
+                        Map.of("Mcp-Name", "=?base64?%%%?="))) {
+            McpSchema.JSONRPCResponse rejected = profileRequest("tools/call", params, headers);
+            assertEquals(-32020, rejected.error().code());
+            assertNull(rejected.result());
+        }
+        McpSchema.JSONRPCResponse unsupported =
+                profileRequest(
+                        "tools/call",
+                        Map.of(
+                                "name",
+                                "echo",
+                                "_meta",
+                                Map.of("io.modelcontextprotocol/protocolVersion", "2025-11-25")),
+                        Map.of("MCP-Protocol-Version", "2025-11-25"));
+        assertEquals(-32022, unsupported.error().code());
+        assertEquals(
+                Map.of("supported", List.of("2026-07-28"), "requested", "2025-11-25"),
+                unsupported.error().data());
+        assertEquals(0, toolCalls.get());
+        for (Method method : List.of(Method.GET, Method.DELETE)) {
+            Response response = client.handle(new Request(method, endpoint()));
+            try {
+                assertEquals(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED, response.getStatus());
+            } finally {
+                if (response.getEntity() != null) {
+                    response.getEntity().release();
+                }
+            }
+        }
+    }
+
+    private String endpoint() {
+        return "http://localhost:" + server.getActualPort() + "/mcp";
+    }
+
+    private static Map<String, Object> resultMap(Object value) {
+        return McpJsonDefaults.getMapper()
+                .convertValue(value, new TypeRef<Map<String, Object>>() {});
+    }
+
+    private McpSchema.JSONRPCResponse profileRequest(
+            String method, Map<String, Object> params, Map<String, String> overrides)
+            throws IOException {
+        Map<String, Object> bodyParams = new LinkedHashMap<>(params);
+        bodyParams.putIfAbsent(
+                "_meta", Map.of("io.modelcontextprotocol/protocolVersion", "2026-07-28"));
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
+        Request request =
+                new Request(
+                        Method.POST,
+                        endpoint(),
+                        new StringRepresentation(
+                                mapper.writeValueAsString(
+                                        new McpSchema.JSONRPCRequest(method, 17, bodyParams)),
+                                MediaType.APPLICATION_JSON));
+        Map<String, String> headers =
+                new LinkedHashMap<>(
+                        Map.of(
+                                "Mcp-Method",
+                                method,
+                                "MCP-Protocol-Version",
+                                "2026-07-28",
+                                "Mcp-Name",
+                                "echo"));
+        headers.putAll(overrides);
+        headers.forEach(
+                (name, value) -> {
+                    if (!value.isEmpty()) {
+                        request.getHeaders().add(name.toLowerCase(Locale.ROOT), value);
+                    }
+                });
+        Response response = client.handle(request);
+        try (InputStream input = response.getEntity().getStream()) {
+            assertEquals("2.0", response.getProtocol().getVersion());
+            assertNull(response.getHeaders().getFirstValue("Mcp-Session-Id", true));
+            byte[] bytes = input.readNBytes(MAX_MESSAGE_BYTES + 1);
+            assertTrue(bytes.length <= MAX_MESSAGE_BYTES);
+            McpSchema.JSONRPCMessage message =
+                    McpSchema.deserializeJsonRpcMessage(
+                            mapper, new String(bytes, StandardCharsets.UTF_8));
+            McpSchema.JSONRPCResponse rpcResponse =
+                    assertInstanceOf(McpSchema.JSONRPCResponse.class, message);
+            assertEquals(17, rpcResponse.id());
+            assertEquals(
+                    rpcResponse.error() == null
+                            ? Status.SUCCESS_OK
+                            : Status.CLIENT_ERROR_BAD_REQUEST,
+                    response.getStatus());
+            return rpcResponse;
+        } finally {
+            response.getEntity().release();
+        }
+    }
+
     @Test
     void dispatchesMcpSdkClientAndServerThroughOfficialStdioTransports() throws Exception {
         McpJsonMapper mapper = McpJsonDefaults.getMapper();
@@ -236,8 +403,11 @@ private static final class RestletHttpTransport extends Restlet
 
         private volatile McpStatelessServerHandler handler;
 
-        private RestletHttpTransport(McpJsonMapper jsonMapper) {
+        private final boolean ikanosProfile;
+
+        private RestletHttpTransport(McpJsonMapper jsonMapper, boolean ikanosProfile) {
             this.jsonMapper = jsonMapper;
+            this.ikanosProfile = ikanosProfile;
         }
 
         @Override
@@ -252,6 +422,10 @@ public Mono<Void> closeGracefully() {
 
         @Override
         public void handle(Request request, Response response) {
+            if (ikanosProfile && !Method.POST.equals(request.getMethod())) {
+                response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+                return;
+            }
             McpStatelessServerHandler currentHandler = handler;
             if (currentHandler == null) {
                 response.setStatus(org.restlet.data.Status.SERVER_ERROR_SERVICE_UNAVAILABLE);
@@ -274,6 +448,15 @@ public void handle(Request request, Response response) {
                                 jsonMapper,
                                 new String(message, java.nio.charset.StandardCharsets.UTF_8));
                 if (parsed instanceof McpSchema.JSONRPCRequest rpcRequest) {
+                    McpSchema.JSONRPCResponse profileError =
+                            ikanosProfile ? validateProfile(request, rpcRequest) : null;
+                    if (profileError != null) {
+                        response.setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
+                        response.setEntity(
+                                jsonMapper.writeValueAsString(profileError),
+                                MediaType.APPLICATION_JSON);
+                        return;
+                    }
                     McpSchema.JSONRPCResponse rpcResponse =
                             currentHandler
                                     .handleRequest(McpTransportContext.EMPTY, rpcRequest)
@@ -282,6 +465,14 @@ public void handle(Request request, Response response) {
                         response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
                         return;
                     }
+                    if (ikanosProfile
+                            && rpcResponse.error() == null
+                            && List.of("tools/list", "tools/call").contains(rpcRequest.method())) {
+                        Map<String, Object> result =
+                                new LinkedHashMap<>(resultMap(rpcResponse.result()));
+                        result.put("resultType", "complete");
+                        rpcResponse = McpSchema.JSONRPCResponse.result(rpcResponse.id(), result);
+                    }
                     response.setEntity(
                             jsonMapper.writeValueAsString(rpcResponse), MediaType.APPLICATION_JSON);
                 } else if (parsed instanceof McpSchema.JSONRPCNotification notification) {
@@ -297,6 +488,76 @@ public void handle(Request request, Response response) {
                 getLogger().warning("Unable to read MCP spike request: " + e.getMessage());
             }
         }
+
+        // A tools-only compatibility experiment, not an implementation of the Ikanos profile.
+        private static McpSchema.JSONRPCResponse validateProfile(
+                Request request, McpSchema.JSONRPCRequest rpcRequest) {
+            Map<String, Object> params = resultMap(rpcRequest.params());
+            Object version =
+                    params.get("_meta") instanceof Map<?, ?> meta
+                            ? meta.get("io.modelcontextprotocol/protocolVersion")
+                            : null;
+            Map<String, Object> expected = new LinkedHashMap<>();
+            expected.put("Mcp-Method", rpcRequest.method());
+            expected.put("MCP-Protocol-Version", version);
+            if ("tools/call".equals(rpcRequest.method())) {
+                expected.put("Mcp-Name", params.get("name"));
+            }
+            for (var header : expected.entrySet()) {
+                String value = request.getHeaders().getFirstValue(header.getKey(), true);
+                if ("Mcp-Name".equals(header.getKey())
+                        && value != null
+                        && value.startsWith("=?base64?")
+                        && value.endsWith("?=")) {
+                    try {
+                        value =
+                                new String(
+                                        Base64.getDecoder()
+                                                .decode(value.substring(9, value.length() - 2)),
+                                        StandardCharsets.UTF_8);
+                    } catch (IllegalArgumentException e) {
+                        return profileError(
+                                rpcRequest,
+                                -32020,
+                                "The value of the header Mcp-Name contains invalid characters",
+                                null);
+                    }
+                }
+                if (value == null) {
+                    return profileError(
+                            rpcRequest,
+                            -32020,
+                            "Missing mandatory header: " + header.getKey(),
+                            null);
+                }
+                if (!value.equals(header.getValue())) {
+                    return profileError(
+                            rpcRequest,
+                            -32020,
+                            "Header mismatch: %s header value '%s' does not match body value '%s'"
+                                    .formatted(header.getKey(), value, header.getValue()),
+                            null);
+                }
+            }
+            if (!"2026-07-28".equals(version)) {
+                return profileError(
+                        rpcRequest,
+                        -32022,
+                        "Unsupported protocol version",
+                        Map.of(
+                                "supported",
+                                List.of("2026-07-28"),
+                                "requested",
+                                version == null ? "" : version));
+            }
+            return null;
+        }
+
+        private static McpSchema.JSONRPCResponse profileError(
+                McpSchema.JSONRPCRequest request, int code, String message, Object data) {
+            return McpSchema.JSONRPCResponse.error(
+                    request.id(), new McpSchema.JSONRPCResponse.JSONRPCError(code, message, data));
+        }
     }
 
     private static final class RestletHttpClientTransport implements McpClientTransport {

From 06905a18d0e170dbb442820e38cf937d6dd2ac9b Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 09:34:38 -0400
Subject: [PATCH 09/18] Compare MCP SDK prototype with real Ikanos endpoint

Run a shared 20-request corpus against an isolated real Ikanos capability and the Restlet HTTP/2 prototype. Assert recorded full responses and measured differences by default, with an opt-in live check and bounded subprocess lifecycle. Document the compatibility gaps and defer Ikanos migration.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../connector/McpIkanosDifferentialProbe.java | 404 ++++++++++++++++++
 .../McpSdkTransportSpikeTestCase.java         |  14 +
 .../mcp-ikanos/IkanosReferenceEndpoint.java   |  89 ++++
 .../resources/mcp-ikanos/observations.json    | 102 +++++
 readme.md                                     |  49 +++
 5 files changed, 658 insertions(+)
 create mode 100644 org.restlet/src/test/java/org/restlet/engine/connector/McpIkanosDifferentialProbe.java
 create mode 100644 org.restlet/src/test/resources/mcp-ikanos/IkanosReferenceEndpoint.java
 create mode 100644 org.restlet/src/test/resources/mcp-ikanos/observations.json

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpIkanosDifferentialProbe.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpIkanosDifferentialProbe.java
new file mode 100644
index 0000000000..7102e6a1e3
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpIkanosDifferentialProbe.java
@@ -0,0 +1,404 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+package org.restlet.engine.connector;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import io.modelcontextprotocol.json.McpJsonDefaults;
+import io.modelcontextprotocol.json.McpJsonMapper;
+import io.modelcontextprotocol.json.TypeRef;
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.net.URI;
+import java.net.http.HttpClient;
+import java.net.http.HttpRequest;
+import java.net.http.HttpResponse;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Objects;
+import java.util.Set;
+import java.util.TreeSet;
+import java.util.concurrent.TimeUnit;
+import org.restlet.Client;
+import org.restlet.Request;
+import org.restlet.Response;
+import org.restlet.data.MediaType;
+import org.restlet.data.Method;
+import org.restlet.representation.StringRepresentation;
+
+/** Recorded and opt-in live comparisons; no Ikanos dependency enters the Restlet module. */
+final class McpIkanosDifferentialProbe {
+    private static final McpJsonMapper JSON = McpJsonDefaults.getMapper();
+    private static final int MAX_BYTES = 64 * 1024;
+    private static final Duration TIMEOUT = Duration.ofSeconds(10);
+    private static final String REVISION = "2026-07-28";
+
+    private McpIkanosDifferentialProbe() {}
+
+    private record ProbeCase(
+            String name, String method, String body, Map<String, String> headers) {}
+
+    @FunctionalInterface
+    private interface ReferenceEndpoint {
+        Map<String, Object> observe(ProbeCase test) throws IOException, InterruptedException;
+    }
+
+    static void runRecorded(Client prototype, String endpoint) throws Exception {
+        Map<String, Map<String, Object>> baseline = baseline();
+        compare(
+                prototype,
+                endpoint,
+                test ->
+                        JSON.convertValue(
+                                baseline.get(test.name()).get("reference"),
+                                new TypeRef<Map<String, Object>>() {}),
+                baseline,
+                "mcp-ikanos-recorded.json");
+    }
+
+    private static Map<String, Map<String, Object>> baseline() throws IOException {
+        try (InputStream input =
+                McpIkanosDifferentialProbe.class.getResourceAsStream(
+                        "/mcp-ikanos/observations.json")) {
+            assertNotNull(input, "Missing recorded Ikanos observations");
+            return JSON.readValue(
+                    new String(input.readAllBytes(), StandardCharsets.UTF_8),
+                    new TypeRef<Map<String, Map<String, Object>>>() {});
+        }
+    }
+
+    private static void compare(
+            Client prototype,
+            String endpoint,
+            ReferenceEndpoint reference,
+            Map<String, Map<String, Object>> baseline,
+            String reportName)
+            throws Exception {
+        Map<String, Object> observations = new LinkedHashMap<>();
+        Set<String> failures = new TreeSet<>();
+        for (ProbeCase test : corpus()) {
+            Map<String, Object> actual = observePrototype(prototype, endpoint, test);
+            Map<String, Object> expected = reference.observe(test);
+            Set<String> differences = new TreeSet<>();
+            differences("", expected, actual, differences);
+            Map<String, Object> observation =
+                    Map.of(
+                            "reference",
+                            expected,
+                            "prototype",
+                            actual,
+                            "differences",
+                            List.copyOf(differences));
+            observations.put(test.name(), observation);
+            if (!observation.equals(baseline.get(test.name()))) {
+                failures.add(test.name());
+            }
+        }
+        Path report = Path.of("target", reportName).toAbsolutePath();
+        Files.writeString(report, JSON.writeValueAsString(observations));
+        assertEquals(baseline.keySet(), observations.keySet(), "Corpus and baseline differ");
+        assertTrue(failures.isEmpty(), "Changed observations: " + failures + "\nReport: " + report);
+    }
+
+    static void run(Client prototype, String endpoint) throws Exception {
+        Path home = Path.of(System.getProperty("restlet.mcp.ikanos.home")).toAbsolutePath();
+        String configuredClasspath = System.getProperty("restlet.mcp.ikanos.classpathFile");
+        assertNotNull(
+                configuredClasspath,
+                "Set restlet.mcp.ikanos.classpathFile to Ikanos' dependency:build-classpath output");
+        Path classpathFile = Path.of(configuredClasspath);
+        for (String module : List.of("ikanos-engine", "ikanos-spec")) {
+            assertTrue(
+                    Files.isDirectory(
+                            home.resolve("modules")
+                                    .resolve(module)
+                                    .resolve("target")
+                                    .resolve("classes")),
+                    "Compile the Ikanos reactor first: " + module);
+        }
+        String classpath =
+                home.resolve("modules")
+                                .resolve("ikanos-engine")
+                                .resolve("target")
+                                .resolve("classes")
+                        + File.pathSeparator
+                        + home.resolve("modules")
+                                .resolve("ikanos-spec")
+                                .resolve("target")
+                                .resolve("classes")
+                        + File.pathSeparator
+                        + Files.readString(classpathFile).strip();
+        Path target = Path.of("target").toAbsolutePath();
+        Path work = Files.createTempDirectory(target, "mcp-ikanos-");
+        Path ready = work.resolve("endpoint");
+        Path log = work.resolve("reference.log");
+        String java =
+                Path.of(
+                                System.getProperty("java.home"),
+                                "bin",
+                                System.getProperty("os.name").startsWith("Windows")
+                                        ? "java.exe"
+                                        : "java")
+                        .toString();
+        Process reference =
+                new ProcessBuilder(
+                                java,
+                                "--class-path",
+                                classpath,
+                                Path.of(
+                                                "src",
+                                                "test",
+                                                "resources",
+                                                "mcp-ikanos",
+                                                "IkanosReferenceEndpoint.java")
+                                        .toAbsolutePath()
+                                        .toString(),
+                                ready.toString())
+                        .redirectErrorStream(true)
+                        .redirectOutput(log.toFile())
+                        .start();
+        try (HttpClient http =
+                HttpClient.newBuilder()
+                        .version(HttpClient.Version.HTTP_1_1)
+                        .connectTimeout(TIMEOUT)
+                        .build()) {
+            long deadline = System.nanoTime() + Duration.ofSeconds(45).toNanos();
+            while (!Files.exists(ready) && reference.isAlive() && System.nanoTime() < deadline) {
+                Thread.sleep(50);
+            }
+            assertTrue(Files.exists(ready), "Ikanos reference did not become ready; see " + log);
+            String referenceEndpoint = Files.readString(ready);
+            compare(
+                    prototype,
+                    endpoint,
+                    test -> observeReference(http, referenceEndpoint, test),
+                    baseline(),
+                    "mcp-ikanos-differential.json");
+        } finally {
+            try {
+                reference.getOutputStream().close();
+            } finally {
+                if (!reference.waitFor(10, TimeUnit.SECONDS)) {
+                    reference.destroy();
+                    if (!reference.waitFor(5, TimeUnit.SECONDS)) {
+                        reference.destroyForcibly();
+                        assertTrue(
+                                reference.waitFor(5, TimeUnit.SECONDS),
+                                "Ikanos reference process did not terminate");
+                    }
+                    throw new AssertionError(
+                            "Ikanos reference required forced shutdown; see " + log);
+                }
+            }
+        }
+    }
+
+    private static List<ProbeCase> corpus() throws IOException {
+        Map<String, Object> call = Map.of("name", "echo", "arguments", Map.of("text", "profile"));
+        List<ProbeCase> cases = new ArrayList<>();
+        cases.add(rpc("list", "tools/list", Map.of(), Map.of()));
+        cases.add(rpc("call", "tools/call", call, Map.of()));
+        cases.add(
+                rpc(
+                        "tool-error",
+                        "tools/call",
+                        Map.of("name", "echo", "arguments", Map.of("text", "fail")),
+                        Map.of()));
+        cases.add(
+                rpc("encoded-name", "tools/call", call, Map.of("Mcp-Name", "=?base64?ZWNobw==?=")));
+        cases.add(rpc("missing-method", "tools/call", call, Map.of("Mcp-Method", "")));
+        cases.add(rpc("mismatched-method", "tools/call", call, Map.of("Mcp-Method", "tools/list")));
+        cases.add(rpc("missing-version", "tools/call", call, Map.of("MCP-Protocol-Version", "")));
+        cases.add(
+                rpc(
+                        "mismatched-version",
+                        "tools/call",
+                        call,
+                        Map.of("MCP-Protocol-Version", "2025-11-25")));
+        cases.add(rpc("missing-name", "tools/call", call, Map.of("Mcp-Name", "")));
+        cases.add(rpc("mismatched-name", "tools/call", call, Map.of("Mcp-Name", "other")));
+        cases.add(rpc("invalid-base64", "tools/call", call, Map.of("Mcp-Name", "=?base64?%%%?=")));
+        cases.add(
+                rpc(
+                        "unsupported-version",
+                        "tools/call",
+                        Map.of(
+                                "name",
+                                "echo",
+                                "_meta",
+                                Map.of("io.modelcontextprotocol/protocolVersion", "2025-11-25")),
+                        Map.of("MCP-Protocol-Version", "2025-11-25")));
+        cases.add(
+                rpc(
+                        "unknown-tool",
+                        "tools/call",
+                        Map.of("name", "missing", "arguments", Map.of()),
+                        Map.of("Mcp-Name", "missing")));
+        cases.add(rpc("unknown-method", "unknown", Map.of(), Map.of()));
+        cases.add(rpc("discovery", "server/discover", Map.of(), Map.of()));
+        cases.add(
+                new ProbeCase(
+                        "legacy-initialize",
+                        "POST",
+                        JSON.writeValueAsString(
+                                Map.of(
+                                        "jsonrpc",
+                                        "2.0",
+                                        "id",
+                                        17,
+                                        "method",
+                                        "initialize",
+                                        "params",
+                                        Map.of(
+                                                "protocolVersion",
+                                                "2025-11-25",
+                                                "capabilities",
+                                                Map.of(),
+                                                "clientInfo",
+                                                Map.of("name", "r0", "version", "1")))),
+                        Map.of()));
+        cases.add(new ProbeCase("malformed-json", "POST", "{", Map.of()));
+        cases.add(new ProbeCase("empty-body", "POST", "", Map.of()));
+        for (String method : List.of("GET", "DELETE")) {
+            cases.add(new ProbeCase(method, method, "", Map.of()));
+        }
+        return cases;
+    }
+
+    private static ProbeCase rpc(
+            String name, String method, Map<String, Object> params, Map<String, String> overrides)
+            throws IOException {
+        Map<String, Object> bodyParams = new LinkedHashMap<>(params);
+        bodyParams.putIfAbsent(
+                "_meta", Map.of("io.modelcontextprotocol/protocolVersion", REVISION));
+        Map<String, String> headers =
+                new LinkedHashMap<>(
+                        Map.of(
+                                "Mcp-Method",
+                                method,
+                                "MCP-Protocol-Version",
+                                REVISION,
+                                "Mcp-Name",
+                                "echo"));
+        headers.putAll(overrides);
+        headers.values().removeIf(String::isEmpty);
+        return new ProbeCase(
+                name,
+                "POST",
+                JSON.writeValueAsString(
+                        Map.of("jsonrpc", "2.0", "id", 17, "method", method, "params", bodyParams)),
+                headers);
+    }
+
+    private static Map<String, Object> observePrototype(
+            Client client, String endpoint, ProbeCase test) throws IOException {
+        Request request = new Request(Method.valueOf(test.method()), endpoint);
+        if ("POST".equals(test.method())) {
+            request.setEntity(new StringRepresentation(test.body(), MediaType.APPLICATION_JSON));
+        }
+        test.headers().forEach((name, value) -> request.getHeaders().add(name, value));
+        Response response = client.handle(request);
+        try {
+            assertEquals("2.0", response.getProtocol().getVersion());
+            byte[] body;
+            if (response.getEntity() == null) {
+                body = new byte[0];
+            } else {
+                try (InputStream input = response.getEntity().getStream()) {
+                    body = input == null ? new byte[0] : input.readNBytes(MAX_BYTES + 1);
+                }
+            }
+            return observation(
+                    response.getStatus().getCode(),
+                    response.getHeaders().getFirstValue("Mcp-Session-Id", true),
+                    body,
+                    response.getEntity() != null
+                            && MediaType.APPLICATION_JSON.equals(
+                                    response.getEntity().getMediaType(), true));
+        } finally {
+            if (response.getEntity() != null) {
+                response.getEntity().release();
+            }
+        }
+    }
+
+    private static Map<String, Object> observeReference(
+            HttpClient client, String endpoint, ProbeCase test)
+            throws IOException, InterruptedException {
+        HttpRequest.Builder request =
+                HttpRequest.newBuilder(URI.create(endpoint))
+                        .timeout(TIMEOUT)
+                        .header("Content-Type", "application/json")
+                        .method(
+                                test.method(),
+                                "POST".equals(test.method())
+                                        ? HttpRequest.BodyPublishers.ofString(test.body())
+                                        : HttpRequest.BodyPublishers.noBody());
+        test.headers().forEach(request::header);
+        HttpResponse<InputStream> response =
+                client.send(request.build(), HttpResponse.BodyHandlers.ofInputStream());
+        try (InputStream input = response.body()) {
+            return observation(
+                    response.statusCode(),
+                    response.headers().firstValue("Mcp-Session-Id").orElse(null),
+                    input.readNBytes(MAX_BYTES + 1),
+                    response.headers()
+                            .firstValue("Content-Type")
+                            .orElse("")
+                            .startsWith("application/json"));
+        }
+    }
+
+    private static Map<String, Object> observation(
+            int status, String session, byte[] bytes, boolean json) throws IOException {
+        assertTrue(bytes.length <= MAX_BYTES, "Differential response exceeds limit");
+        assertNull(session, "Unexpected MCP session");
+        String text = new String(bytes, StandardCharsets.UTF_8);
+        Map<String, Object> result = new LinkedHashMap<>();
+        result.put("status", status);
+        result.put(
+                "body",
+                json && !text.isEmpty() ? JSON.readValue(text, new TypeRef<Object>() {}) : text);
+        return result;
+    }
+
+    private static void differences(
+            String path, Object expected, Object actual, Set<String> result) {
+        if (expected instanceof Map<?, ?> left && actual instanceof Map<?, ?> right) {
+            Set<Object> keys = new java.util.HashSet<>(left.keySet());
+            keys.addAll(right.keySet());
+            for (Object key : keys) {
+                String child = path + "/" + key.toString().replace("~", "~0").replace("/", "~1");
+                if (!left.containsKey(key) || !right.containsKey(key)) {
+                    result.add(child);
+                } else {
+                    differences(child, left.get(key), right.get(key), result);
+                }
+            }
+        } else if (expected instanceof List<?> left
+                && actual instanceof List<?> right
+                && left.size() == right.size()) {
+            for (int index = 0; index < left.size(); index++) {
+                differences(path + "/" + index, left.get(index), right.get(index), result);
+            }
+        } else if (!Objects.equals(expected, actual)) {
+            result.add(path);
+        }
+    }
+}
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
index 56bdff3ac1..8a4bc190a0 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -43,6 +43,7 @@
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.EnabledIfSystemProperty;
 import org.restlet.Client;
 import org.restlet.Context;
 import org.restlet.Request;
@@ -250,6 +251,19 @@ void bridgesIkanosToolResultsWithoutAnSdkSession() throws Exception {
         assertEquals(2, toolCalls.get());
     }
 
+    @Test
+    void comparesToolsProfileWithRecordedIkanosResponses() throws Exception {
+        startHttpServer(true);
+        McpIkanosDifferentialProbe.runRecorded(client, endpoint());
+    }
+
+    @Test
+    @EnabledIfSystemProperty(named = "restlet.mcp.ikanos.home", matches = ".+")
+    void comparesToolsProfileWithRealIkanosEndpoint() throws Exception {
+        startHttpServer(true);
+        McpIkanosDifferentialProbe.run(client, endpoint());
+    }
+
     @Test
     void rejectsIkanosProfileMismatchesBeforeToolDispatch() throws Exception {
         startHttpServer(true);
diff --git a/org.restlet/src/test/resources/mcp-ikanos/IkanosReferenceEndpoint.java b/org.restlet/src/test/resources/mcp-ikanos/IkanosReferenceEndpoint.java
new file mode 100644
index 0000000000..6923446dcb
--- /dev/null
+++ b/org.restlet/src/test/resources/mcp-ikanos/IkanosReferenceEndpoint.java
@@ -0,0 +1,89 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+import com.sun.net.httpserver.HttpServer;
+import io.ikanos.Capability;
+import io.ikanos.engine.exposes.mcp.McpServerAdapter;
+import io.ikanos.spec.IkanosSpec;
+import io.ikanos.spec.util.IkanosMappers;
+import io.ikanos.spec.util.VersionHelper;
+import java.net.InetSocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.nio.file.Files;
+import java.nio.file.Path;
+
+/**
+ * Source-launched in an isolated JVM with Ikanos' own dependencies, not Restlet's test classpath.
+ * Uses the real capability, MCP adapter, resource, dispatcher and tool execution path.
+ */
+class IkanosReferenceEndpoint {
+    public static void main(String[] args) throws Exception {
+        HttpServer upstream = HttpServer.create(new InetSocketAddress("127.0.0.1", 0), 0);
+        upstream.createContext("/echo/", exchange -> {
+            try {
+                String text = exchange.getRequestURI().getPath().substring("/echo/".length());
+                byte[] body = ("echo:" + text).getBytes(StandardCharsets.UTF_8);
+                exchange.getResponseHeaders().set("Content-Type", "text/plain");
+                exchange.sendResponseHeaders("fail".equals(text) ? 400 : 200, body.length);
+                exchange.getResponseBody().write(body);
+            } finally {
+                exchange.close();
+            }
+        });
+        upstream.start();
+        Capability capability = null;
+        try {
+            String yaml = """
+                    ikanos: "%s"
+                    capability:
+                      exposes:
+                        - type: mcp
+                          namespace: restlet-r0-reference
+                          address: 127.0.0.1
+                          port: 0
+                          tools:
+                            echo:
+                              description: Returns the supplied text
+                              inputParameters:
+                                - name: text
+                                  type: string
+                                  required: true
+                              call: upstream.echo
+                      consumes:
+                        - type: http
+                          namespace: upstream
+                          baseUri: "http://127.0.0.1:%d"
+                          resources:
+                            echo:
+                              path: "/echo/{{text}}"
+                              operations:
+                                echo:
+                                  method: GET
+                    """.formatted(VersionHelper.getSchemaVersion(), upstream.getAddress().getPort());
+            IkanosSpec spec = IkanosMappers.lenientYaml().readValue(yaml, IkanosSpec.class);
+            capability = new Capability(spec);
+            McpServerAdapter adapter = (McpServerAdapter) capability.getServerAdapters().getFirst();
+            capability.start();
+            Path ready = Path.of(args[0]);
+            Path pending = ready.resolveSibling(ready.getFileName() + ".pending");
+            Files.writeString(pending, "http://127.0.0.1:" + adapter.getServer().getActualPort() + "/mcp");
+            Files.move(pending, ready);
+            // The parent owns stdin; EOF is the normal shutdown signal.
+            while (System.in.read() != -1) {
+            }
+        } finally {
+            try {
+                if (capability != null) {
+                    capability.stop();
+                }
+            } finally {
+                upstream.stop(0);
+            }
+        }
+    }
+}
diff --git a/org.restlet/src/test/resources/mcp-ikanos/observations.json b/org.restlet/src/test/resources/mcp-ikanos/observations.json
new file mode 100644
index 0000000000..ce205f2d02
--- /dev/null
+++ b/org.restlet/src/test/resources/mcp-ikanos/observations.json
@@ -0,0 +1,102 @@
+{
+  "list": {
+    "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"tools":[{"name":"echo","description":"Returns the supplied text","inputSchema":{"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}}],"resultType":"complete","ttlMs":0,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"tools":[{"name":"echo","description":"Returns the supplied text","inputSchema":{"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}}],"resultType":"complete"}}},
+    "differences": ["/body/result/_meta","/body/result/cacheScope","/body/result/ttlMs"]
+  },
+  "call": {
+    "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete"}}},
+    "differences": ["/body/result/_meta"]
+  },
+  "tool-error": {
+    "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:fail"}],"isError":true,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:fail"}],"isError":true,"resultType":"complete"}}},
+    "differences": ["/body/result/_meta"]
+  },
+  "encoded-name": {
+    "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete"}}},
+    "differences": ["/body/result/_meta"]
+  },
+  "missing-method": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: Mcp-Method"}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: Mcp-Method"}}},
+    "differences": []
+  },
+  "mismatched-method": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Header mismatch: Mcp-Method header value 'tools/list' does not match body value 'tools/call'"}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Header mismatch: Mcp-Method header value 'tools/list' does not match body value 'tools/call'"}}},
+    "differences": []
+  },
+  "missing-version": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: MCP-Protocol-Version"}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: MCP-Protocol-Version"}}},
+    "differences": []
+  },
+  "mismatched-version": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Header mismatch: MCP-Protocol-Version header value '2025-11-25' does not match body value '2026-07-28'"}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Header mismatch: MCP-Protocol-Version header value '2025-11-25' does not match body value '2026-07-28'"}}},
+    "differences": []
+  },
+  "missing-name": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: Mcp-Name"}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: Mcp-Name"}}},
+    "differences": []
+  },
+  "mismatched-name": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Header mismatch: Mcp-Name header value 'other' does not match body value 'echo'"}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Header mismatch: Mcp-Name header value 'other' does not match body value 'echo'"}}},
+    "differences": []
+  },
+  "invalid-base64": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"The value of the header Mcp-Name contains invalid characters"}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"The value of the header Mcp-Name contains invalid characters"}}},
+    "differences": []
+  },
+  "unsupported-version": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32022,"message":"Unsupported protocol version","data":{"supported":["2026-07-28"],"requested":"2025-11-25"}}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32022,"message":"Unsupported protocol version","data":{"supported":["2026-07-28"],"requested":"2025-11-25"}}}},
+    "differences": []
+  },
+  "unknown-tool": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32602,"message":"Invalid params: Unknown tool: missing"}}},
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32602,"message":"Unknown tool: invalid_tool_name","data":"Tool not found: missing"}}},
+    "differences": ["/body/error/data","/body/error/message","/status"]
+  },
+  "unknown-method": {
+    "reference": {"status":404,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32601,"message":"Method not found: unknown"}}},
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32601,"message":"Method not found: unknown"}}},
+    "differences": ["/status"]
+  },
+  "discovery": {
+    "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"supportedVersions":["2026-07-28"],"capabilities":{"tools":{}},"resultType":"complete","ttlMs":0,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32601,"message":"Method not found: server/discover"}}},
+    "differences": ["/body/error","/body/result"]
+  },
+  "legacy-initialize": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32022,"message":"Unsupported protocol version 2025-11-25: this server supports only MCP 2026-07-28, which has no initialize handshake","data":{"supported":["2026-07-28"],"requested":"2025-11-25"}}}},
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: Mcp-Method"}}},
+    "differences": ["/body/error/code","/body/error/data","/body/error/message"]
+  },
+  "malformed-json": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Parse error: Unexpected end-of-input: expected close marker for Object (start marker at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled); byte offset: #UNKNOWN])\n at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled); byte offset: #UNKNOWN]"}}},
+    "prototype": {"status":500,"body":""},
+    "differences": ["/body","/status"]
+  },
+  "empty-body": {
+    "reference": {"status":400,"body":{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Parse error: empty body"}}},
+    "prototype": {"status":400,"body":""},
+    "differences": ["/body"]
+  },
+  "GET": {
+    "reference": {"status":405,"body":"GET not supported"},
+    "prototype": {"status":405,"body":""},
+    "differences": ["/body"]
+  },
+  "DELETE": {
+    "reference": {"status":405,"body":"DELETE not supported"},
+    "prototype": {"status":405,"body":""},
+    "differences": ["/body"]
+  }
+}
diff --git a/readme.md b/readme.md
index 27a4ac6d06..c34d925b0f 100644
--- a/readme.md
+++ b/readme.md
@@ -12,6 +12,55 @@ Restlet applications run directly in JVMs with minimal dependencies, resulting i
 
 ![](https://avatars.githubusercontent.com/u/374452?s=400&u=191f2eada671b2a07f61782cf638bdda0ccb6d3f&v=4)
 
+## R0 SDK interoperability probes
+
+The MCP and gRPC interoperability spikes are **test-only**, not production RPC extensions.
+Run the focused suite from the repository root:
+
+```powershell
+.\mvnw.cmd -pl org.restlet '-Dtest=GrpcSdkTransportSpikeTestCase,McpSdkTransportSpikeTestCase,McpStreamableSdkTransportSpikeTestCase' test
+```
+
+The MCP suite compares a 20-request corpus with
+[recorded Ikanos responses](org.restlet/src/test/resources/mcp-ikanos/observations.json).
+These observations were verified against Ikanos commit
+`3f4532efebd237498f6e253f0277e213d5995623` with its own dependencies.
+Full status/body snapshots and JSON-pointer difference paths are asserted, not just error codes.
+JSON object ordering is ignored; response fields, error messages and absent fields are not removed.
+All cases assert that neither endpoint creates an MCP session.
+
+Eight header/version rejection cases match exactly. Twelve cases have explicit differences:
+Ikanos adds server metadata and list-cache fields, has different unknown-tool error details and
+dispatch-error HTTP statuses, implements discovery and legacy-initialize rejection, and emits
+JSON-RPC parse errors and GET/DELETE response text that the prototype lacks.
+Tool content, `isError` and `resultType` match, but the complete tool responses do not.
+A passing differential test means these observations are unchanged, **not** that the endpoints
+are equivalent. Ikanos migration remains deferred.
+
+To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
+reference revision, then run the following PowerShell commands (adjust the checkout path):
+
+```powershell
+$ikanos = (Resolve-Path '..\ikanos').Path
+$classpath = Join-Path (Get-Location) 'org.restlet\target\ikanos-classpath.txt'
+mvn -f "$ikanos\pom.xml" -pl modules\ikanos-engine -am compile
+mvn -f "$ikanos\pom.xml" -pl modules\ikanos-engine dependency:build-classpath "-Dmdep.outputFile=$classpath" -DincludeScope=test
+.\mvnw.cmd -pl org.restlet '-Dtest=GrpcSdkTransportSpikeTestCase,McpSdkTransportSpikeTestCase,McpStreamableSdkTransportSpikeTestCase' "-Drestlet.mcp.ikanos.home=$ikanos" "-Drestlet.mcp.ikanos.classpathFile=$classpath" test
+```
+
+The opt-in test source-launches a separate JVM with Ikanos' classpath. It boots a real capability
+and MCP HTTP endpoint plus a deterministic loopback upstream; it does not replace Ikanos'
+resource, dispatcher or tool handler with mocks. The reference is called over HTTP/1.1 and the
+prototype over Restlet HTTP/2; this compares MCP semantics, not transport implementation parity.
+The reference process is stopped after the test. Startup failures fail the test rather than
+falling back to recorded responses.
+
+Without the opt-in properties, nine tests pass and the live comparison is skipped; with them,
+all ten run. Recorded and live reports are written separately under `org.restlet/target` as
+`mcp-ikanos-recorded.json` and `mcp-ikanos-differential.json`; reference-process logs are kept in
+per-run `mcp-ikanos-*` directories there. Review changed observations explicitly before updating
+the checked-in baseline. No Ikanos or additional production dependency is added to Restlet.
+
 ## Learn more
 
 To learn more about Restlet Framework, please have a look at the following resources:

From 73fa4162b83213f5096151dc182a09250aa2f89b Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 09:50:23 -0400
Subject: [PATCH 10/18] Close measured Ikanos tools profile compatibility gaps

Align fixture metadata, discovery, legacy initialize rejection, HTTP error mapping and parse-error envelopes with the real Ikanos reference. Keep normal dispatch and JSON serialization in the SDK. Prove the SDK null-response-ID limitation and isolate that parse-error envelope exception. The corpus now has 19 exact matches and one explicit Jackson diagnostic-text difference; reference snapshots are unchanged.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../McpSdkTransportSpikeTestCase.java         | 174 ++++++++++++++++--
 .../resources/mcp-ikanos/observations.json    |  48 ++---
 readme.md                                     |  33 +++-
 3 files changed, 202 insertions(+), 53 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
index 8a4bc190a0..0ff8179503 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -11,6 +11,7 @@
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertInstanceOf;
 import static org.junit.jupiter.api.Assertions.assertNull;
+import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import io.modelcontextprotocol.client.McpAsyncClient;
@@ -251,6 +252,17 @@ void bridgesIkanosToolResultsWithoutAnSdkSession() throws Exception {
         assertEquals(2, toolCalls.get());
     }
 
+    @Test
+    void pinnedSdkCannotRepresentNullIdParseErrors() {
+        var parseError = new McpSchema.JSONRPCResponse.JSONRPCError(-32700, "Parse error");
+        assertEquals(parseError, McpSchema.JSONRPCResponse.error(17, parseError).error());
+        IllegalArgumentException rejected =
+                assertThrows(
+                        IllegalArgumentException.class,
+                        () -> McpSchema.JSONRPCResponse.error(null, parseError));
+        assertTrue(rejected.getMessage().contains("null IDs"));
+    }
+
     @Test
     void comparesToolsProfileWithRecordedIkanosResponses() throws Exception {
         startHttpServer(true);
@@ -438,6 +450,8 @@ public Mono<Void> closeGracefully() {
         public void handle(Request request, Response response) {
             if (ikanosProfile && !Method.POST.equals(request.getMethod())) {
                 response.setStatus(Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
+                response.setEntity(
+                        request.getMethod().getName() + " not supported", MediaType.TEXT_PLAIN);
                 return;
             }
             McpStatelessServerHandler currentHandler = handler;
@@ -447,6 +461,17 @@ public void handle(Request request, Response response) {
             }
             if (!request.isEntityAvailable()) {
                 response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
+                if (ikanosProfile) {
+                    try {
+                        writeParseError(response, "Parse error: empty body");
+                    } catch (IOException e) {
+                        response.setStatus(Status.SERVER_ERROR_INTERNAL);
+                        getLogger()
+                                .warning(
+                                        "Unable to encode MCP spike parse error: "
+                                                + e.getMessage());
+                    }
+                }
                 return;
             }
 
@@ -457,18 +482,54 @@ public void handle(Request request, Response response) {
                             org.restlet.data.Status.CLIENT_ERROR_REQUEST_ENTITY_TOO_LARGE);
                     return;
                 }
-                McpSchema.JSONRPCMessage parsed =
-                        McpSchema.deserializeJsonRpcMessage(
-                                jsonMapper,
-                                new String(message, java.nio.charset.StandardCharsets.UTF_8));
+                String payload = new String(message, StandardCharsets.UTF_8);
+                McpSchema.JSONRPCMessage parsed;
+                if (ikanosProfile && payload.isBlank()) {
+                    writeParseError(response, "Parse error: empty body");
+                    return;
+                }
+                try {
+                    parsed = McpSchema.deserializeJsonRpcMessage(jsonMapper, payload);
+                } catch (IOException e) {
+                    if (!ikanosProfile) {
+                        throw e;
+                    }
+                    writeParseError(response, "Parse error: " + e.getMessage());
+                    return;
+                }
                 if (parsed instanceof McpSchema.JSONRPCRequest rpcRequest) {
+                    if (ikanosProfile && "initialize".equals(rpcRequest.method())) {
+                        Object version = params(rpcRequest).get("protocolVersion");
+                        String requested = version instanceof String text ? text : "";
+                        writeProfileResponse(
+                                response,
+                                profileError(
+                                        rpcRequest,
+                                        -32022,
+                                        "Unsupported protocol version"
+                                                + ("".equals(requested) ? "" : " " + requested)
+                                                + ": this server supports only MCP 2026-07-28, which has no initialize handshake",
+                                        Map.of(
+                                                "supported",
+                                                List.of("2026-07-28"),
+                                                "requested",
+                                                requested)));
+                        return;
+                    }
                     McpSchema.JSONRPCResponse profileError =
                             ikanosProfile ? validateProfile(request, rpcRequest) : null;
                     if (profileError != null) {
-                        response.setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
-                        response.setEntity(
-                                jsonMapper.writeValueAsString(profileError),
-                                MediaType.APPLICATION_JSON);
+                        writeProfileResponse(response, profileError);
+                        return;
+                    }
+                    if (ikanosProfile && "server/discover".equals(rpcRequest.method())) {
+                        writeProfileResponse(
+                                response,
+                                profileResult(
+                                        rpcRequest,
+                                        Map.of(
+                                                "supportedVersions", List.of("2026-07-28"),
+                                                "capabilities", Map.of("tools", Map.of()))));
                         return;
                     }
                     McpSchema.JSONRPCResponse rpcResponse =
@@ -479,13 +540,29 @@ public void handle(Request request, Response response) {
                         response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
                         return;
                     }
-                    if (ikanosProfile
-                            && rpcResponse.error() == null
-                            && List.of("tools/list", "tools/call").contains(rpcRequest.method())) {
-                        Map<String, Object> result =
-                                new LinkedHashMap<>(resultMap(rpcResponse.result()));
-                        result.put("resultType", "complete");
-                        rpcResponse = McpSchema.JSONRPCResponse.result(rpcResponse.id(), result);
+                    if (ikanosProfile) {
+                        if (rpcResponse.error() == null
+                                && List.of("tools/list", "tools/call")
+                                        .contains(rpcRequest.method())) {
+                            rpcResponse =
+                                    profileResult(rpcRequest, resultMap(rpcResponse.result()));
+                        } else if (rpcResponse.error() != null
+                                && rpcResponse.error().code() == -32602
+                                && "tools/call".equals(rpcRequest.method())) {
+                            Object name = params(rpcRequest).get("name");
+                            // Only adapt the pinned SDK's unknown-tool error, not other invalid
+                            // params.
+                            if (("Tool not found: " + name).equals(rpcResponse.error().data())) {
+                                rpcResponse =
+                                        profileError(
+                                                rpcRequest,
+                                                -32602,
+                                                "Invalid params: Unknown tool: " + name,
+                                                null);
+                            }
+                        }
+                        writeProfileResponse(response, rpcResponse);
+                        return;
                     }
                     response.setEntity(
                             jsonMapper.writeValueAsString(rpcResponse), MediaType.APPLICATION_JSON);
@@ -503,17 +580,76 @@ public void handle(Request request, Response response) {
             }
         }
 
-        // A tools-only compatibility experiment, not an implementation of the Ikanos profile.
+        private void writeProfileResponse(Response response, McpSchema.JSONRPCResponse rpcResponse)
+                throws IOException {
+            if (rpcResponse.error() != null) {
+                Status status =
+                        switch (rpcResponse.error().code()) {
+                            case -32601 -> Status.CLIENT_ERROR_NOT_FOUND;
+                            case -32700, -32600, -32602, -32020, -32021, -32022 ->
+                                    Status.CLIENT_ERROR_BAD_REQUEST;
+                            case -32603 -> Status.SERVER_ERROR_INTERNAL;
+                            default -> {
+                                getLogger()
+                                        .warning(
+                                                "Unmapped MCP profile error: "
+                                                        + rpcResponse.error().code());
+                                yield Status.SERVER_ERROR_INTERNAL;
+                            }
+                        };
+                response.setStatus(status);
+            }
+            response.setEntity(
+                    jsonMapper.writeValueAsString(rpcResponse), MediaType.APPLICATION_JSON);
+        }
+
+        private void writeParseError(Response response, String message) throws IOException {
+            getLogger().warning("Invalid MCP profile request: " + message);
+            // SDK 2.1.0 rejects null response IDs; only this proven envelope gap is SDK-external.
+            Map<String, Object> envelope = new LinkedHashMap<>();
+            envelope.put("jsonrpc", "2.0");
+            envelope.put("id", null);
+            envelope.put("error", new McpSchema.JSONRPCResponse.JSONRPCError(-32700, message));
+            response.setStatus(Status.CLIENT_ERROR_BAD_REQUEST);
+            response.setEntity(jsonMapper.writeValueAsString(envelope), MediaType.APPLICATION_JSON);
+        }
+
+        // Fixture-specific tools/discovery metadata; this is not a full Ikanos implementation.
+        private static McpSchema.JSONRPCResponse profileResult(
+                McpSchema.JSONRPCRequest request, Map<String, Object> sdkResult) {
+            Map<String, Object> result = new LinkedHashMap<>(sdkResult);
+            result.put("resultType", "complete");
+            result.put(
+                    "_meta",
+                    Map.of(
+                            "io.modelcontextprotocol/serverInfo",
+                            Map.of("name", "restlet-r0-reference", "version", "unspecified")));
+            if (List.of("tools/list", "server/discover").contains(request.method())) {
+                result.put("ttlMs", 0);
+                result.put("cacheScope", "private");
+            }
+            return McpSchema.JSONRPCResponse.result(request.id(), result);
+        }
+
+        private static Map<String, Object> params(McpSchema.JSONRPCRequest request) {
+            return request.params() == null ? Map.of() : resultMap(request.params());
+        }
+
         private static McpSchema.JSONRPCResponse validateProfile(
                 Request request, McpSchema.JSONRPCRequest rpcRequest) {
-            Map<String, Object> params = resultMap(rpcRequest.params());
+            Map<String, Object> params = params(rpcRequest);
             Object version =
                     params.get("_meta") instanceof Map<?, ?> meta
                             ? meta.get("io.modelcontextprotocol/protocolVersion")
                             : null;
             Map<String, Object> expected = new LinkedHashMap<>();
             expected.put("Mcp-Method", rpcRequest.method());
-            expected.put("MCP-Protocol-Version", version);
+            boolean supportedMethod =
+                    List.of("tools/list", "tools/call", "server/discover")
+                            .contains(rpcRequest.method());
+            if (supportedMethod) {
+                expected.put("MCP-Protocol-Version", version);
+            }
             if ("tools/call".equals(rpcRequest.method())) {
                 expected.put("Mcp-Name", params.get("name"));
             }
@@ -553,7 +689,7 @@ private static McpSchema.JSONRPCResponse validateProfile(
                             null);
                 }
             }
-            if (!"2026-07-28".equals(version)) {
+            if (supportedMethod && !"2026-07-28".equals(version)) {
                 return profileError(
                         rpcRequest,
                         -32022,
diff --git a/org.restlet/src/test/resources/mcp-ikanos/observations.json b/org.restlet/src/test/resources/mcp-ikanos/observations.json
index ce205f2d02..551df86017 100644
--- a/org.restlet/src/test/resources/mcp-ikanos/observations.json
+++ b/org.restlet/src/test/resources/mcp-ikanos/observations.json
@@ -1,23 +1,23 @@
 {
   "list": {
     "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"tools":[{"name":"echo","description":"Returns the supplied text","inputSchema":{"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}}],"resultType":"complete","ttlMs":0,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
-    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"tools":[{"name":"echo","description":"Returns the supplied text","inputSchema":{"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}}],"resultType":"complete"}}},
-    "differences": ["/body/result/_meta","/body/result/cacheScope","/body/result/ttlMs"]
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"tools":[{"name":"echo","description":"Returns the supplied text","inputSchema":{"type":"object","properties":{"text":{"type":"string"}},"required":["text"]}}],"resultType":"complete","ttlMs":0,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "differences": []
   },
   "call": {
     "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
-    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete"}}},
-    "differences": ["/body/result/_meta"]
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "differences": []
   },
   "tool-error": {
     "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:fail"}],"isError":true,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
-    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:fail"}],"isError":true,"resultType":"complete"}}},
-    "differences": ["/body/result/_meta"]
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:fail"}],"isError":true,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "differences": []
   },
   "encoded-name": {
     "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
-    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete"}}},
-    "differences": ["/body/result/_meta"]
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"content":[{"type":"text","text":"echo:profile"}],"isError":false,"resultType":"complete","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "differences": []
   },
   "missing-method": {
     "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: Mcp-Method"}}},
@@ -61,42 +61,42 @@
   },
   "unknown-tool": {
     "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32602,"message":"Invalid params: Unknown tool: missing"}}},
-    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32602,"message":"Unknown tool: invalid_tool_name","data":"Tool not found: missing"}}},
-    "differences": ["/body/error/data","/body/error/message","/status"]
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32602,"message":"Invalid params: Unknown tool: missing"}}},
+    "differences": []
   },
   "unknown-method": {
     "reference": {"status":404,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32601,"message":"Method not found: unknown"}}},
-    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32601,"message":"Method not found: unknown"}}},
-    "differences": ["/status"]
+    "prototype": {"status":404,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32601,"message":"Method not found: unknown"}}},
+    "differences": []
   },
   "discovery": {
     "reference": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"supportedVersions":["2026-07-28"],"capabilities":{"tools":{}},"resultType":"complete","ttlMs":0,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
-    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32601,"message":"Method not found: server/discover"}}},
-    "differences": ["/body/error","/body/result"]
+    "prototype": {"status":200,"body":{"jsonrpc":"2.0","id":17,"result":{"supportedVersions":["2026-07-28"],"capabilities":{"tools":{}},"resultType":"complete","ttlMs":0,"cacheScope":"private","_meta":{"io.modelcontextprotocol/serverInfo":{"name":"restlet-r0-reference","version":"unspecified"}}}}},
+    "differences": []
   },
   "legacy-initialize": {
     "reference": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32022,"message":"Unsupported protocol version 2025-11-25: this server supports only MCP 2026-07-28, which has no initialize handshake","data":{"supported":["2026-07-28"],"requested":"2025-11-25"}}}},
-    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32020,"message":"Missing mandatory header: Mcp-Method"}}},
-    "differences": ["/body/error/code","/body/error/data","/body/error/message"]
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":17,"error":{"code":-32022,"message":"Unsupported protocol version 2025-11-25: this server supports only MCP 2026-07-28, which has no initialize handshake","data":{"supported":["2026-07-28"],"requested":"2025-11-25"}}}},
+    "differences": []
   },
   "malformed-json": {
     "reference": {"status":400,"body":{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Parse error: Unexpected end-of-input: expected close marker for Object (start marker at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled); byte offset: #UNKNOWN])\n at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled); byte offset: #UNKNOWN]"}}},
-    "prototype": {"status":500,"body":""},
-    "differences": ["/body","/status"]
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Parse error: Unexpected end-of-input: expected close marker for Object (start marker at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled); line: 1, column: 1])\n at [Source: REDACTED (`StreamReadFeature.INCLUDE_SOURCE_IN_LOCATION` disabled); line: 1, column: 2]"}}},
+    "differences": ["/body/error/message"]
   },
   "empty-body": {
     "reference": {"status":400,"body":{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Parse error: empty body"}}},
-    "prototype": {"status":400,"body":""},
-    "differences": ["/body"]
+    "prototype": {"status":400,"body":{"jsonrpc":"2.0","id":null,"error":{"code":-32700,"message":"Parse error: empty body"}}},
+    "differences": []
   },
   "GET": {
     "reference": {"status":405,"body":"GET not supported"},
-    "prototype": {"status":405,"body":""},
-    "differences": ["/body"]
+    "prototype": {"status":405,"body":"GET not supported"},
+    "differences": []
   },
   "DELETE": {
     "reference": {"status":405,"body":"DELETE not supported"},
-    "prototype": {"status":405,"body":""},
-    "differences": ["/body"]
+    "prototype": {"status":405,"body":"DELETE not supported"},
+    "differences": []
   }
 }
diff --git a/readme.md b/readme.md
index c34d925b0f..060891a231 100644
--- a/readme.md
+++ b/readme.md
@@ -24,18 +24,31 @@ Run the focused suite from the repository root:
 The MCP suite compares a 20-request corpus with
 [recorded Ikanos responses](org.restlet/src/test/resources/mcp-ikanos/observations.json).
 These observations were verified against Ikanos commit
-`3f4532efebd237498f6e253f0277e213d5995623` with its own dependencies.
+`3f4532efebd237498f6e253f0277e213d5995623`, then revalidated at
+`932f2322d7dcf4ec973f650f3daf5e9ddf1b4c71`, with its own dependencies.
 Full status/body snapshots and JSON-pointer difference paths are asserted, not just error codes.
 JSON object ordering is ignored; response fields, error messages and absent fields are not removed.
 All cases assert that neither endpoint creates an MCP session.
 
-Eight header/version rejection cases match exactly. Twelve cases have explicit differences:
-Ikanos adds server metadata and list-cache fields, has different unknown-tool error details and
-dispatch-error HTTP statuses, implements discovery and legacy-initialize rejection, and emits
-JSON-RPC parse errors and GET/DELETE response text that the prototype lacks.
-Tool content, `isError` and `resultType` match, but the complete tool responses do not.
-A passing differential test means these observations are unchanged, **not** that the endpoints
-are equivalent. Ikanos migration remains deferred.
+After the compatibility follow-up, **19 cases match exactly**. The test-only bridge adds
+fixture-specific server/cache metadata, discovery, legacy-initialize rejection, unknown-tool
+error adaptation, dispatch-error HTTP mapping, parse-error envelopes, and GET/DELETE response
+text. Normal tools still dispatch through the SDK; only the profile-specific discovery and
+legacy-initialize behavior bypass it. Unknown-tool adaptation matches only the pinned SDK's
+specific error data, not every invalid-params failure.
+
+**One explicit difference remains:** malformed-JSON diagnostic text from Jackson 2 versus
+Ikanos' Jackson 3. Both responses now use HTTP 400, `-32700` and `id: null`; only
+`/body/error/message` differs. The snapshots assert both exact messages and do not normalize
+them or synthesize Jackson 3 diagnostics.
+
+A regression test demonstrates that SDK 2.1.0's `JSONRPCResponse` rejects null IDs. The parse-error
+path therefore uses an explicit null-ID envelope with the SDK's error type and JSON mapper.
+This is a measured compatibility exception, not a general replacement codec or dispatcher.
+A passing differential test means these bounded observations are unchanged, **not** full profile
+equivalence. Metadata/discovery are specific to the tools fixture; other methods, notifications,
+identity/capability checks and production lifecycle are not validated. Ikanos migration remains
+deferred.
 
 To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
 reference revision, then run the following PowerShell commands (adjust the checkout path):
@@ -55,8 +68,8 @@ prototype over Restlet HTTP/2; this compares MCP semantics, not transport implem
 The reference process is stopped after the test. Startup failures fail the test rather than
 falling back to recorded responses.
 
-Without the opt-in properties, nine tests pass and the live comparison is skipped; with them,
-all ten run. Recorded and live reports are written separately under `org.restlet/target` as
+Without the opt-in properties, ten tests pass and the live comparison is skipped; with them,
+all eleven run. Recorded and live reports are written separately under `org.restlet/target` as
 `mcp-ikanos-recorded.json` and `mcp-ikanos-differential.json`; reference-process logs are kept in
 per-run `mcp-ikanos-*` directories there. Review changed observations explicitly before updating
 the checked-in baseline. No Ikanos or additional production dependency is added to Restlet.

From 89a5b3cea2c75eb16fa13116eb557ae0ead80a75 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 15:56:51 -0400
Subject: [PATCH 11/18] Probe MCP Streamable listening and event replay

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 ...cpStreamableSdkTransportSpikeTestCase.java | 339 +++++++++++++++++-
 readme.md                                     |  12 +-
 2 files changed, 345 insertions(+), 6 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
index 19823113c3..c401dd4eff 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
@@ -10,6 +10,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import io.modelcontextprotocol.client.McpAsyncClient;
@@ -25,12 +26,21 @@
 import io.modelcontextprotocol.spec.McpStreamableServerTransport;
 import io.modelcontextprotocol.spec.McpStreamableServerTransportProvider;
 import io.modelcontextprotocol.spec.ProtocolVersions;
+import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.nio.charset.StandardCharsets;
 import java.time.Duration;
+import java.util.ArrayDeque;
+import java.util.ArrayList;
 import java.util.List;
 import java.util.Map;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.LinkedBlockingQueue;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import org.junit.jupiter.api.AfterEach;
@@ -47,6 +57,7 @@
 import org.restlet.data.Preference;
 import org.restlet.data.Protocol;
 import org.restlet.engine.Engine;
+import org.restlet.representation.OutputRepresentation;
 import org.restlet.representation.StringRepresentation;
 import reactor.core.publisher.Mono;
 import reactor.core.scheduler.Schedulers;
@@ -55,6 +66,10 @@ class McpStreamableSdkTransportSpikeTestCase {
 
     private static final int MAX_MESSAGE_BYTES = 64 * 1024;
 
+    private static final int MAX_REPLAY_EVENTS = 8;
+
+    private static final int MAX_LISTENING_EVENTS = 2;
+
     private static final Duration REQUEST_TIMEOUT = Duration.ofSeconds(5);
 
     private Client client;
@@ -65,6 +80,102 @@ class McpStreamableSdkTransportSpikeTestCase {
 
     private Server server;
 
+    @Test
+    void servesListeningSseAndReplaysEventsAfterLastEventId() throws Exception {
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
+        RestletStreamableTransport transport = new RestletStreamableTransport(mapper);
+        sdkServer =
+                McpServer.async(transport).serverInfo("restlet-r0-streamable-spike", "1").build();
+        Context serverContext = new Context();
+        serverContext.getParameters().add("http.transport.protocol", "HTTP2");
+        server = new Server(serverContext, Protocol.HTTP, 0, transport);
+        server.start();
+        Context clientContext = new Context();
+        clientContext.getParameters().add("httpClientTransportMode", "HTTP2");
+        client = new Client(clientContext, Protocol.HTTP);
+        client.start();
+
+        RestletStreamableClientTransport clientTransport =
+                new RestletStreamableClientTransport(
+                        client, mapper, "http://localhost:" + server.getActualPort() + "/mcp");
+        sdkClient =
+                McpClient.async(clientTransport)
+                        .requestTimeout(REQUEST_TIMEOUT)
+                        .initializationTimeout(REQUEST_TIMEOUT)
+                        .build();
+        sdkClient.initialize().block(REQUEST_TIMEOUT);
+        String sessionId = clientTransport.sessionId;
+        assertTrue(sessionId != null && !sessionId.isBlank());
+
+        Request get = new Request(Method.GET, clientTransport.target);
+        get.getHeaders().add("Mcp-Session-Id", sessionId);
+        var responseFuture =
+                java.util.concurrent.CompletableFuture.supplyAsync(() -> client.handle(get));
+        assertTrue(
+                transport.awaitListeningStream(sessionId, REQUEST_TIMEOUT),
+                "GET did not establish an SDK listening stream");
+        transport
+                .notifyClients(
+                        sessionId,
+                        new McpSchema.JSONRPCNotification(
+                                "notifications/message", Map.of("text", "first")))
+                .block(REQUEST_TIMEOUT);
+        transport
+                .notifyClients(
+                        sessionId,
+                        new McpSchema.JSONRPCNotification(
+                                "notifications/message", Map.of("text", "second")))
+                .block(REQUEST_TIMEOUT);
+        Response response = responseFuture.get(REQUEST_TIMEOUT.toMillis(), TimeUnit.MILLISECONDS);
+        assertEquals(org.restlet.data.Status.SUCCESS_OK, response.getStatus());
+        assertEquals("text/event-stream", response.getEntity().getMediaType().getName());
+        assertEquals(sessionId, response.getHeaders().getFirstValue("Mcp-Session-Id", true));
+
+        String firstId;
+        String secondEvent;
+        try (BufferedReader reader =
+                new BufferedReader(
+                        new InputStreamReader(
+                                response.getEntity().getStream(), StandardCharsets.UTF_8))) {
+            String firstEvent = readSseEvent(reader);
+            firstId = sseField(firstEvent, "id");
+            assertTrue(firstId != null && !firstId.isBlank());
+            assertTrue(firstEvent.contains("\"text\":\"first\""));
+
+            secondEvent = readSseEvent(reader);
+            String secondId = sseField(secondEvent, "id");
+            assertTrue(secondId != null && !secondId.isBlank() && !secondId.equals(firstId));
+            assertTrue(secondEvent.contains("\"text\":\"second\""));
+            assertNull(reader.readLine(), "Bounded listening probe should close after two events");
+        } finally {
+            response.getEntity().release();
+        }
+
+        Request replay = new Request(Method.GET, clientTransport.target);
+        replay.getHeaders().add("Mcp-Session-Id", sessionId);
+        replay.getHeaders().add("Last-Event-ID", firstId);
+        Response replayResponse = client.handle(replay);
+        assertEquals(org.restlet.data.Status.SUCCESS_OK, replayResponse.getStatus());
+        try (InputStream input = replayResponse.getEntity().getStream()) {
+            byte[] replayBytes = input.readNBytes(MAX_MESSAGE_BYTES + 1);
+            assertTrue(replayBytes.length <= MAX_MESSAGE_BYTES);
+            String replayBody = new String(replayBytes, StandardCharsets.UTF_8);
+            assertTrue(replayBody.contains("id: " + sseField(secondEvent, "id")));
+            assertTrue(replayBody.contains("\"text\":\"second\""));
+            assertFalse(replayBody.contains("\"text\":\"first\""));
+        } finally {
+            replayResponse.getEntity().release();
+        }
+
+        Request expiredReplay = new Request(Method.GET, clientTransport.target);
+        expiredReplay.getHeaders().add("Mcp-Session-Id", sessionId);
+        expiredReplay.getHeaders().add("Last-Event-ID", "expired-event");
+        Response expiredReplayResponse = client.handle(expiredReplay);
+        assertEquals(
+                org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST,
+                expiredReplayResponse.getStatus());
+    }
+
     @BeforeEach
     void setUp() {
         Engine.clearThreadLocalVariables();
@@ -174,6 +285,31 @@ void pinnedSdkDoesNotAdvertiseIkanosProtocolRevision() {
         }
     }
 
+    private static String readSseEvent(BufferedReader reader) throws IOException {
+        StringBuilder event = new StringBuilder();
+        String line;
+        while ((line = reader.readLine()) != null) {
+            if (line.isEmpty()) {
+                if (!event.isEmpty()) {
+                    return event.toString();
+                }
+            } else {
+                event.append(line).append('\n');
+            }
+        }
+        throw new IOException("MCP SSE stream closed before the expected event");
+    }
+
+    private static String sseField(String event, String field) {
+        return event.lines()
+                .filter(line -> line.startsWith(field + ":"))
+                .map(line -> line.substring(field.length() + 1).strip())
+                .findFirst()
+                .orElse(null);
+    }
+
+    private record ServerEvent(String id, String json) {}
+
     private static final class RestletStreamableTransport extends Restlet
             implements McpStreamableServerTransportProvider {
 
@@ -183,6 +319,13 @@ private static final class RestletStreamableTransport extends Restlet
 
         private final AtomicInteger postCount = new AtomicInteger();
 
+        private final Map<String, ArrayDeque<ServerEvent>> eventHistory = new ConcurrentHashMap<>();
+
+        private final Map<String, ListeningSseTransport> listeningTransports =
+                new ConcurrentHashMap<>();
+
+        private final Map<String, CountDownLatch> listeningStreamReady = new ConcurrentHashMap<>();
+
         private volatile McpStreamableServerSession.Factory sessionFactory;
 
         private RestletStreamableTransport(McpJsonMapper jsonMapper) {
@@ -196,15 +339,64 @@ public void setSessionFactory(McpStreamableServerSession.Factory sessionFactory)
 
         @Override
         public Mono<Void> notifyClients(String sessionId, Object notification) {
-            return Mono.error(
-                    new UnsupportedOperationException(
-                            "The R0 Streamable HTTP probe does not open server-sent streams"));
+            if (!(notification instanceof McpSchema.JSONRPCNotification rpcNotification)) {
+                return Mono.error(
+                        new IllegalArgumentException(
+                                "The R0 probe requires an SDK JSON-RPC notification"));
+            }
+            McpStreamableServerSession session = sessions.get(sessionId);
+            if (session == null) {
+                return Mono.error(new IllegalArgumentException("Unknown MCP session"));
+            }
+            return session.sendNotification(rpcNotification.method(), rpcNotification.params());
+        }
+
+        private boolean awaitListeningStream(String sessionId, Duration timeout)
+                throws InterruptedException {
+            return listeningStreamReady
+                    .computeIfAbsent(sessionId, ignored -> new CountDownLatch(1))
+                    .await(timeout.toMillis(), TimeUnit.MILLISECONDS);
+        }
+
+        private void recordEvent(String sessionId, ServerEvent event) {
+            ArrayDeque<ServerEvent> events =
+                    eventHistory.computeIfAbsent(sessionId, ignored -> new ArrayDeque<>());
+            synchronized (events) {
+                events.addLast(event);
+                while (events.size() > MAX_REPLAY_EVENTS) {
+                    events.removeFirst();
+                }
+            }
+        }
+
+        private List<ServerEvent> eventsAfter(String sessionId, String lastEventId) {
+            ArrayDeque<ServerEvent> events = eventHistory.get(sessionId);
+            if (events == null) {
+                return null;
+            }
+            synchronized (events) {
+                List<ServerEvent> snapshot = new ArrayList<>(events);
+                int lastIndex = -1;
+                for (int index = 0; index < snapshot.size(); index++) {
+                    if (snapshot.get(index).id().equals(lastEventId)) {
+                        lastIndex = index;
+                        break;
+                    }
+                }
+                return lastIndex < 0
+                        ? null
+                        : List.copyOf(snapshot.subList(lastIndex + 1, snapshot.size()));
+            }
         }
 
         @Override
         public Mono<Void> closeGracefully() {
             return Mono.<Void>fromRunnable(
-                            () -> sessions.values().forEach(McpStreamableServerSession::close))
+                            () -> {
+                                sessions.values().forEach(McpStreamableServerSession::close);
+                                listeningTransports.values().forEach(ListeningSseTransport::close);
+                                listeningStreamReady.clear();
+                            })
                     .doFinally(signal -> sessions.clear());
         }
 
@@ -214,11 +406,84 @@ public void handle(Request request, Response response) {
                 deleteSession(request, response);
             } else if (request.getMethod().equals(Method.POST)) {
                 postMessage(request, response);
+            } else if (request.getMethod().equals(Method.GET)) {
+                getListeningStream(request, response);
             } else {
                 response.setStatus(org.restlet.data.Status.CLIENT_ERROR_METHOD_NOT_ALLOWED);
             }
         }
 
+        private void getListeningStream(Request request, Response response) {
+            String sessionId = request.getHeaders().getFirstValue("Mcp-Session-Id", true);
+            if (sessionId == null || sessionId.isBlank()) {
+                response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
+                return;
+            }
+            McpStreamableServerSession session = sessions.get(sessionId);
+            if (session == null) {
+                response.setStatus(org.restlet.data.Status.CLIENT_ERROR_NOT_FOUND);
+                return;
+            }
+            response.getHeaders().add("Mcp-Session-Id", sessionId);
+            String lastEventId = request.getHeaders().getFirstValue("Last-Event-ID", true);
+            if (lastEventId != null) {
+                List<ServerEvent> replay = eventsAfter(sessionId, lastEventId);
+                if (replay == null) {
+                    response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
+                    return;
+                }
+                response.setEntity(formatEvents(replay), new MediaType("text/event-stream"));
+                return;
+            }
+
+            ListeningSseTransport listening = new ListeningSseTransport(this, sessionId);
+            listeningTransports.put(sessionId, listening);
+            session.listeningStream(listening);
+            listeningStreamReady
+                    .computeIfAbsent(sessionId, ignored -> new CountDownLatch(1))
+                    .countDown();
+            response.setEntity(
+                    new OutputRepresentation(new MediaType("text/event-stream")) {
+                        @Override
+                        public void write(OutputStream output) throws IOException {
+                            try {
+                                for (int index = 0; index < MAX_LISTENING_EVENTS; index++) {
+                                    ServerEvent event =
+                                            listening.events.poll(
+                                                    REQUEST_TIMEOUT.toMillis(),
+                                                    TimeUnit.MILLISECONDS);
+                                    if (event == null) {
+                                        throw new IOException(
+                                                "Timed out waiting for bounded MCP SSE event");
+                                    }
+                                    if (event.id() == null) {
+                                        break;
+                                    }
+                                    output.write(
+                                            formatEvent(event).getBytes(StandardCharsets.UTF_8));
+                                    output.flush();
+                                }
+                            } catch (InterruptedException e) {
+                                Thread.currentThread().interrupt();
+                                throw new IOException("Interrupted while writing MCP SSE", e);
+                            } finally {
+                                listeningTransports.remove(sessionId, listening);
+                                session.releaseListeningStream();
+                            }
+                        }
+                    });
+        }
+
+        private static String formatEvents(List<ServerEvent> events) {
+            StringBuilder result = new StringBuilder();
+            events.forEach(event -> result.append(formatEvent(event)));
+            return result.toString();
+        }
+
+        private static String formatEvent(ServerEvent event) {
+            return "id: " + event.id() + "\nevent: message\ndata: " + event.json() + "\n\n";
+        }
+
         private void postMessage(Request request, Response response) {
             if (!request.isEntityAvailable()) {
                 response.setStatus(org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST);
@@ -315,6 +580,12 @@ private void deleteSession(Request request, Response response) {
                 response.setStatus(org.restlet.data.Status.CLIENT_ERROR_NOT_FOUND);
                 return;
             }
+            eventHistory.remove(sessionId);
+            ListeningSseTransport listening = listeningTransports.remove(sessionId);
+            if (listening != null) {
+                listening.close();
+            }
+            listeningStreamReady.remove(sessionId);
             session.close();
             response.setStatus(org.restlet.data.Status.SUCCESS_NO_CONTENT);
         }
@@ -332,6 +603,66 @@ private void writeEventStreamResponse(Response response, McpSchema.JSONRPCMessag
         }
     }
 
+    private static final class ListeningSseTransport implements McpStreamableServerTransport {
+
+        private final RestletStreamableTransport owner;
+
+        private final String sessionId;
+
+        private final LinkedBlockingQueue<ServerEvent> events =
+                new LinkedBlockingQueue<>(MAX_LISTENING_EVENTS);
+
+        private ListeningSseTransport(RestletStreamableTransport owner, String sessionId) {
+            this.owner = owner;
+            this.sessionId = sessionId;
+        }
+
+        @Override
+        public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message, String messageId) {
+            return Mono.fromCallable(
+                            () -> {
+                                if (messageId == null || messageId.isBlank()) {
+                                    throw new IllegalArgumentException(
+                                            "SDK server event omitted its replay ID");
+                                }
+                                ServerEvent event =
+                                        new ServerEvent(
+                                                messageId,
+                                                owner.jsonMapper.writeValueAsString(message));
+                                owner.recordEvent(sessionId, event);
+                                if (!events.offer(event)) {
+                                    throw new IllegalStateException(
+                                            "Bounded MCP listening queue is full");
+                                }
+                                return event;
+                            })
+                    .then();
+        }
+
+        @Override
+        public Mono<Void> sendMessage(McpSchema.JSONRPCMessage message) {
+            return Mono.error(
+                    new IllegalStateException("SDK server event did not include its message ID"));
+        }
+
+        @Override
+        public <T> T unmarshalFrom(Object value, TypeRef<T> typeRef) {
+            return owner.jsonMapper.convertValue(value, typeRef);
+        }
+
+        @Override
+        public void close() {
+            events.clear();
+            events.offer(new ServerEvent(null, null));
+        }
+
+        @Override
+        public Mono<Void> closeGracefully() {
+            close();
+            return Mono.empty();
+        }
+    }
+
     private static final class JsonResponseTransport implements McpStreamableServerTransport {
 
         private final McpJsonMapper jsonMapper;
diff --git a/readme.md b/readme.md
index 060891a231..294c3e6fa2 100644
--- a/readme.md
+++ b/readme.md
@@ -50,6 +50,14 @@ equivalence. Metadata/discovery are specific to the tools fixture; other methods
 identity/capability checks and production lifecycle are not validated. Ikanos migration remains
 deferred.
 
+The Streamable HTTP probe also opens a session-bound GET listening stream, sends two SDK-generated
+notifications, and verifies the returned SSE event IDs and JSON. It replays events after a known
+`Last-Event-ID` from a test-only per-session history capped at eight events; unknown or expired IDs
+are rejected. Each live stream is deliberately bounded to two events. This history is a probe-owned
+compatibility seam, not SDK replay: `McpStreamableServerSession.replay` is empty in MCP SDK 2.1.0.
+The probe does not establish production SSE lifecycle, reconnection, or full Streamable HTTP
+conformance.
+
 To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
 reference revision, then run the following PowerShell commands (adjust the checkout path):
 
@@ -68,8 +76,8 @@ prototype over Restlet HTTP/2; this compares MCP semantics, not transport implem
 The reference process is stopped after the test. Startup failures fail the test rather than
 falling back to recorded responses.
 
-Without the opt-in properties, ten tests pass and the live comparison is skipped; with them,
-all eleven run. Recorded and live reports are written separately under `org.restlet/target` as
+Without the opt-in properties, eleven tests pass and the live comparison is skipped; with them,
+all twelve run. Recorded and live reports are written separately under `org.restlet/target` as
 `mcp-ikanos-recorded.json` and `mcp-ikanos-differential.json`; reference-process logs are kept in
 per-run `mcp-ikanos-*` directories there. Review changed observations explicitly before updating
 the checked-in baseline. No Ikanos or additional production dependency is added to Restlet.

From 082fc6ad3e19211a1f26729a114af8569df01964 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 17:32:20 -0400
Subject: [PATCH 12/18] Probe gRPC bidirectional SDK streaming

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrpcSdkTransportSpikeTestCase.java        | 98 ++++++++++++++++++-
 readme.md                                     |  6 ++
 2 files changed, 102 insertions(+), 2 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index 118530db2a..981d5d77fa 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -109,6 +109,14 @@ class GrpcSdkTransportSpikeTestCase {
                     .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
                     .build();
 
+    private static final MethodDescriptor<StringValue, StringValue> BIDI_STREAM_METHOD =
+            MethodDescriptor.<StringValue, StringValue>newBuilder()
+                    .setType(MethodDescriptor.MethodType.BIDI_STREAMING)
+                    .setFullMethodName("restlet.r0.Echo/BidiStream")
+                    .setRequestMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .build();
+
     private Client client;
 
     private io.grpc.Server grpcServer;
@@ -226,6 +234,30 @@ public void onCompleted() {
                                                         result.onCompleted();
                                                     }
                                                 }))
+                        .addMethod(
+                                BIDI_STREAM_METHOD,
+                                ServerCalls.asyncBidiStreamingCall(
+                                        result ->
+                                                new io.grpc.stub.StreamObserver<>() {
+                                                    @Override
+                                                    public void onNext(StringValue value) {
+                                                        result.onNext(
+                                                                StringValue.of(
+                                                                        "echo:"
+                                                                                + value
+                                                                                        .getValue()));
+                                                    }
+
+                                                    @Override
+                                                    public void onError(Throwable error) {
+                                                        result.onError(error);
+                                                    }
+
+                                                    @Override
+                                                    public void onCompleted() {
+                                                        result.onCompleted();
+                                                    }
+                                                }))
                         .build();
         grpcServer = NettyServerBuilder.forPort(0).addService(service).build().start();
 
@@ -276,6 +308,7 @@ public void onCompleted() {
                         .toList());
 
         assertClientStreaming(channel);
+        assertBufferedBidirectionalStreaming(channel);
     }
 
     @Test
@@ -338,6 +371,30 @@ public void onCompleted() {
                                                         result.onCompleted();
                                                     }
                                                 }))
+                        .addMethod(
+                                BIDI_STREAM_METHOD,
+                                ServerCalls.asyncBidiStreamingCall(
+                                        result ->
+                                                new io.grpc.stub.StreamObserver<>() {
+                                                    @Override
+                                                    public void onNext(StringValue value) {
+                                                        result.onNext(
+                                                                StringValue.of(
+                                                                        "echo:"
+                                                                                + value
+                                                                                        .getValue()));
+                                                    }
+
+                                                    @Override
+                                                    public void onError(Throwable error) {
+                                                        result.onError(error);
+                                                    }
+
+                                                    @Override
+                                                    public void onCompleted() {
+                                                        result.onCompleted();
+                                                    }
+                                                }))
                         .build();
         Context serverContext = new Context();
         serverContext.getParameters().add("http.transport.protocol", "HTTP2");
@@ -384,6 +441,7 @@ public void onCompleted() {
                         .toList());
 
         assertClientStreaming(grpcClientChannel);
+        assertBufferedBidirectionalStreaming(grpcClientChannel);
     }
 
     private static void assertClientStreaming(ManagedChannel channel) throws InterruptedException {
@@ -420,6 +478,41 @@ public void onCompleted() {
         assertEquals("first,second", response.get().getValue());
     }
 
+    private static void assertBufferedBidirectionalStreaming(ManagedChannel channel)
+            throws InterruptedException {
+        CountDownLatch closed = new CountDownLatch(1);
+        List<String> responses = new ArrayList<>();
+        AtomicReference<Throwable> failure = new AtomicReference<>();
+        var request =
+                ClientCalls.asyncBidiStreamingCall(
+                        channel.newCall(BIDI_STREAM_METHOD, CallOptions.DEFAULT),
+                        new io.grpc.stub.StreamObserver<>() {
+                            @Override
+                            public void onNext(StringValue value) {
+                                responses.add(value.getValue());
+                            }
+
+                            @Override
+                            public void onError(Throwable error) {
+                                failure.set(error);
+                                closed.countDown();
+                            }
+
+                            @Override
+                            public void onCompleted() {
+                                closed.countDown();
+                            }
+                        });
+        request.onNext(StringValue.of("first"));
+        request.onNext(StringValue.of("second"));
+        request.onCompleted();
+        assertTrue(closed.await(5, TimeUnit.SECONDS));
+        if (failure.get() != null) {
+            throw new AssertionError("gRPC bidirectional streaming request failed", failure.get());
+        }
+        assertEquals(List.of("echo:first", "echo:second"), responses);
+    }
+
     private static final class RestletGrpcServer extends org.restlet.Restlet {
 
         private final ServerServiceDefinition service;
@@ -724,9 +817,10 @@ public ClientStream newStream(
             }
             if (method.getType() != MethodDescriptor.MethodType.UNARY
                     && method.getType() != MethodDescriptor.MethodType.SERVER_STREAMING
-                    && method.getType() != MethodDescriptor.MethodType.CLIENT_STREAMING) {
+                    && method.getType() != MethodDescriptor.MethodType.CLIENT_STREAMING
+                    && method.getType() != MethodDescriptor.MethodType.BIDI_STREAMING) {
                 throw new UnsupportedOperationException(
-                        "R0 SPI probe does not support bidirectional streaming");
+                        "Unsupported gRPC method type: " + method.getType());
             }
             if (callOptions.getCredentials() != null || callOptions.getCompressor() != null) {
                 throw new UnsupportedOperationException(
diff --git a/readme.md b/readme.md
index 294c3e6fa2..aa301aab0f 100644
--- a/readme.md
+++ b/readme.md
@@ -58,6 +58,12 @@ compatibility seam, not SDK replay: `McpStreamableServerSession.replay` is empty
 The probe does not establish production SSE lifecycle, reconnection, or full Streamable HTTP
 conformance.
 
+The gRPC probes now also invoke SDK `BIDI_STREAMING` methods in both directions and exchange two
+request/response messages. This validates SDK service/method handling and framing for the finite
+exchange only. The Restlet-backed client buffers request messages until half-close, and the
+Restlet-hosted server dispatches buffered requests before writing responses; this is **not**
+full-duplex streaming or evidence of gRPC flow control, demand, or cancellation.
+
 To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
 reference revision, then run the following PowerShell commands (adjust the checkout path):
 

From f4ce572fa3d8f8285a9e2824c10377537c986ca0 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 17:46:01 -0400
Subject: [PATCH 13/18] Stream gRPC bidi messages concurrently over HTTP/2

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrpcSdkTransportSpikeTestCase.java        | 371 +++++++++++++++++-
 readme.md                                     |  13 +-
 2 files changed, 369 insertions(+), 15 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index 981d5d77fa..9b5abf9da4 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -45,6 +45,9 @@
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.PipedInputStream;
+import java.io.PipedOutputStream;
 import java.net.SocketAddress;
 import java.nio.ByteBuffer;
 import java.nio.ByteOrder;
@@ -56,6 +59,7 @@
 import java.util.Set;
 import java.util.concurrent.CountDownLatch;
 import java.util.concurrent.Executors;
+import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.ScheduledExecutorService;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicInteger;
@@ -75,6 +79,7 @@
 import org.restlet.engine.Engine;
 import org.restlet.engine.header.HeaderConstants;
 import org.restlet.representation.ByteArrayRepresentation;
+import org.restlet.representation.OutputRepresentation;
 import org.restlet.util.Series;
 
 class GrpcSdkTransportSpikeTestCase {
@@ -83,6 +88,8 @@ class GrpcSdkTransportSpikeTestCase {
 
     private static final int MAX_STREAM_BYTES = 4 * MAX_MESSAGE_BYTES;
 
+    private static final int STREAM_PIPE_BUFFER_BYTES = 64 * 1024;
+
     private static final MediaType GRPC_MEDIA_TYPE = new MediaType("application/grpc");
 
     private static final MethodDescriptor<StringValue, StringValue> ECHO_METHOD =
@@ -308,7 +315,7 @@ public void onCompleted() {
                         .toList());
 
         assertClientStreaming(channel);
-        assertBufferedBidirectionalStreaming(channel);
+        assertFullDuplexBidirectionalStreaming(channel);
     }
 
     @Test
@@ -441,7 +448,7 @@ public void onCompleted() {
                         .toList());
 
         assertClientStreaming(grpcClientChannel);
-        assertBufferedBidirectionalStreaming(grpcClientChannel);
+        assertFullDuplexBidirectionalStreaming(grpcClientChannel);
     }
 
     private static void assertClientStreaming(ManagedChannel channel) throws InterruptedException {
@@ -478,11 +485,14 @@ public void onCompleted() {
         assertEquals("first,second", response.get().getValue());
     }
 
-    private static void assertBufferedBidirectionalStreaming(ManagedChannel channel)
+    private static void assertFullDuplexBidirectionalStreaming(ManagedChannel channel)
             throws InterruptedException {
         CountDownLatch closed = new CountDownLatch(1);
-        List<String> responses = new ArrayList<>();
+        CountDownLatch firstResponse = new CountDownLatch(1);
+        CountDownLatch secondResponse = new CountDownLatch(1);
+        List<String> responses = java.util.Collections.synchronizedList(new ArrayList<>());
         AtomicReference<Throwable> failure = new AtomicReference<>();
+        AtomicInteger responseCount = new AtomicInteger();
         var request =
                 ClientCalls.asyncBidiStreamingCall(
                         channel.newCall(BIDI_STREAM_METHOD, CallOptions.DEFAULT),
@@ -490,6 +500,11 @@ private static void assertBufferedBidirectionalStreaming(ManagedChannel channel)
                             @Override
                             public void onNext(StringValue value) {
                                 responses.add(value.getValue());
+                                if (responseCount.incrementAndGet() == 1) {
+                                    firstResponse.countDown();
+                                } else {
+                                    secondResponse.countDown();
+                                }
                             }
 
                             @Override
@@ -504,7 +519,13 @@ public void onCompleted() {
                             }
                         });
         request.onNext(StringValue.of("first"));
+        assertTrue(
+                firstResponse.await(5, TimeUnit.SECONDS),
+                "The first response must arrive while the request stream remains open");
         request.onNext(StringValue.of("second"));
+        assertTrue(
+                secondResponse.await(5, TimeUnit.SECONDS),
+                "The second response must arrive before request half-close");
         request.onCompleted();
         assertTrue(closed.await(5, TimeUnit.SECONDS));
         if (failure.get() != null) {
@@ -545,6 +566,12 @@ public void handle(Request request, Response response) {
                     return;
                 }
 
+                if (definition.getMethodDescriptor().getType()
+                        == MethodDescriptor.MethodType.BIDI_STREAMING) {
+                    dispatchBidirectional(definition, request, response);
+                    return;
+                }
+
                 byte[] frames;
                 try (InputStream input = request.getEntity().getStream()) {
                     frames = input.readNBytes(MAX_STREAM_BYTES + 1);
@@ -559,6 +586,52 @@ public void handle(Request request, Response response) {
             }
         }
 
+        private <RequestT, ResponseT> void dispatchBidirectional(
+                ServerMethodDefinition<RequestT, ResponseT> definition,
+                Request request,
+                Response response)
+                throws IOException {
+            MethodDescriptor<RequestT, ResponseT> method = definition.getMethodDescriptor();
+            SpikeServerCall<RequestT, ResponseT> serverCall = new SpikeServerCall<>(method, true);
+            ServerCall.Listener<RequestT> listener =
+                    definition
+                            .getServerCallHandler()
+                            .startCall(serverCall, readMetadata(request.getHeaders()));
+            if (listener == null) {
+                throw new IOException("gRPC SDK returned no call listener");
+            }
+            serverCall.writeResponseHeaders(response);
+            Thread.startVirtualThread(
+                    () -> {
+                        try (InputStream input = request.getEntity().getStream()) {
+                            byte[] payload;
+                            long requestBytes = 0;
+                            while ((payload = readGrpcMessage(input, MAX_MESSAGE_BYTES)) != null) {
+                                requestBytes += payload.length + 5L;
+                                if (requestBytes > MAX_STREAM_BYTES) {
+                                    throw new IOException(
+                                            "gRPC request stream exceeds "
+                                                    + MAX_STREAM_BYTES
+                                                    + " bytes");
+                                }
+                                listener.onMessage(
+                                        method.parseRequest(new ByteArrayInputStream(payload)));
+                            }
+                            listener.onHalfClose();
+                        } catch (Exception e) {
+                            listener.onCancel();
+                            serverCall.close(Status.fromThrowable(e), new Metadata());
+                        }
+                    });
+            response.setEntity(
+                    new OutputRepresentation(GRPC_MEDIA_TYPE) {
+                        @Override
+                        public void write(OutputStream output) throws IOException {
+                            serverCall.writeStreamingResponse(response, output);
+                        }
+                    });
+        }
+
         private <RequestT, ResponseT> void dispatch(
                 ServerMethodDefinition<RequestT, ResponseT> definition,
                 Request request,
@@ -587,20 +660,32 @@ private <RequestT, ResponseT> void dispatch(
     private static final class SpikeServerCall<RequestT, ResponseT>
             extends ServerCall<RequestT, ResponseT> {
 
+        private static final int MAX_BUFFERED_RESPONSES = 8;
+
         private final MethodDescriptor<RequestT, ResponseT> method;
 
         private final List<ResponseT> responseMessages = new ArrayList<>();
 
+        private final LinkedBlockingQueue<ResponseT> streamingResponses =
+                new LinkedBlockingQueue<>(MAX_BUFFERED_RESPONSES);
+
         private final Metadata responseHeaders = new Metadata();
 
         private final CountDownLatch closed = new CountDownLatch(1);
 
-        private Status status;
+        private volatile Status status;
 
-        private Metadata trailers = new Metadata();
+        private volatile Metadata trailers = new Metadata();
+
+        private final boolean streaming;
 
         private SpikeServerCall(MethodDescriptor<RequestT, ResponseT> method) {
+            this(method, false);
+        }
+
+        private SpikeServerCall(MethodDescriptor<RequestT, ResponseT> method, boolean streaming) {
             this.method = method;
+            this.streaming = streaming;
         }
 
         @Override
@@ -613,11 +698,30 @@ public void sendHeaders(Metadata headers) {
 
         @Override
         public void sendMessage(ResponseT message) {
-            responseMessages.add(message);
+            if (streaming) {
+                try {
+                    if (!streamingResponses.offer(message, 5, TimeUnit.SECONDS)) {
+                        close(
+                                Status.RESOURCE_EXHAUSTED.withDescription(
+                                        "Timed out waiting for the bounded gRPC response queue"),
+                                new Metadata());
+                        throw new IllegalStateException(
+                                "Timed out waiting for the bounded gRPC response queue");
+                    }
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new IllegalStateException("Interrupted writing a gRPC response", e);
+                }
+            } else {
+                responseMessages.add(message);
+            }
         }
 
         @Override
-        public void close(Status status, Metadata trailers) {
+        public synchronized void close(Status status, Metadata trailers) {
+            if (closed.getCount() == 0) {
+                return;
+            }
             this.status = status;
             this.trailers = trailers;
             closed.countDown();
@@ -676,6 +780,55 @@ private void writeResponse(Response response) throws IOException {
             }
             writeMetadata(trailers, response.getTrailers());
         }
+
+        private void writeResponseHeaders(Response response) {
+            response.setStatus(org.restlet.data.Status.SUCCESS_OK);
+            writeMetadata(responseHeaders, response.getHeaders());
+        }
+
+        private void writeStreamingResponse(Response response, OutputStream output)
+                throws IOException {
+            long responseBytes = 0;
+            try {
+                while (closed.getCount() != 0 || !streamingResponses.isEmpty()) {
+                    ResponseT message;
+                    try {
+                        message = streamingResponses.poll(100, TimeUnit.MILLISECONDS);
+                    } catch (InterruptedException e) {
+                        Thread.currentThread().interrupt();
+                        throw new IOException("Interrupted reading gRPC response queue", e);
+                    }
+                    if (message == null) {
+                        continue;
+                    }
+                    try (InputStream payload = method.streamResponse(message)) {
+                        byte[] bytes = payload.readNBytes(MAX_MESSAGE_BYTES + 1);
+                        if (bytes.length > MAX_MESSAGE_BYTES) {
+                            throw new IOException(
+                                    "gRPC response exceeds " + MAX_MESSAGE_BYTES + " bytes");
+                        }
+                        responseBytes += bytes.length + 5L;
+                        if (responseBytes > MAX_STREAM_BYTES) {
+                            throw new IOException(
+                                    "gRPC response stream exceeds " + MAX_STREAM_BYTES + " bytes");
+                        }
+                        output.write(frame(bytes));
+                        output.flush();
+                    }
+                }
+            } finally {
+                if (status == null) {
+                    status = Status.INTERNAL.withDescription("SDK call did not close");
+                    trailers = new Metadata();
+                }
+                if (status.getDescription() != null) {
+                    response.getTrailers().add("grpc-message", status.getDescription());
+                }
+                response.getTrailers()
+                        .add("grpc-status", Integer.toString(status.getCode().value()));
+                writeMetadata(trailers, response.getTrailers());
+            }
+        }
     }
 
     private static void setGrpcStatus(Response response, Status status) {
@@ -917,6 +1070,10 @@ private static final class RestletClientStream implements ClientStream {
 
         private final List<byte[]> requestPayloads = new ArrayList<>();
 
+        private volatile PipedInputStream bidirectionalRequestInput;
+
+        private volatile PipedOutputStream bidirectionalRequestOutput;
+
         private int requestStreamBytes;
 
         private int maxInboundMessageSize = MAX_MESSAGE_BYTES;
@@ -948,6 +1105,17 @@ private RestletClientStream(
         public void start(ClientStreamListener listener) {
             this.listener = listener;
             onStart.run();
+            if (method.getType() == MethodDescriptor.MethodType.BIDI_STREAMING) {
+                try {
+                    PipedInputStream input = new PipedInputStream(STREAM_PIPE_BUFFER_BYTES);
+                    bidirectionalRequestInput = input;
+                    bidirectionalRequestOutput = new PipedOutputStream(input);
+                } catch (IOException e) {
+                    close(Status.INTERNAL.withCause(e), new Metadata());
+                    return;
+                }
+                Thread.startVirtualThread(this::executeBidirectionalRequest);
+            }
             listener.onReady();
         }
 
@@ -960,11 +1128,20 @@ public void request(int numMessages) {
 
         @Override
         public void cancel(Status reason) {
+            Status cancellation = reason;
+            PipedOutputStream requestOutput = bidirectionalRequestOutput;
+            if (requestOutput != null) {
+                try {
+                    requestOutput.close();
+                } catch (IOException e) {
+                    cancellation = reason.withCause(e);
+                }
+            }
             Request request = activeRequest;
             if (request != null) {
                 request.abort();
             }
-            close(reason, new Metadata());
+            close(cancellation, new Metadata());
         }
 
         @Override
@@ -972,6 +1149,10 @@ public void writeMessage(InputStream message) {
             if (closed) {
                 throw new IllegalStateException("gRPC stream is already closed");
             }
+            if (method.getType() == MethodDescriptor.MethodType.BIDI_STREAMING) {
+                writeBidirectionalMessage(message);
+                return;
+            }
             if (method.getType() == MethodDescriptor.MethodType.UNARY
                     && !requestPayloads.isEmpty()) {
                 throw new IllegalStateException("R0 unary probe accepts one request message");
@@ -1001,11 +1182,148 @@ public void writeMessage(InputStream message) {
             requestPayloads.add(payload);
         }
 
+        private synchronized void writeBidirectionalMessage(InputStream message) {
+            byte[] payload;
+            try (InputStream input = message) {
+                payload = input.readNBytes(maxOutboundMessageSize + 1);
+            } catch (IOException e) {
+                close(Status.INTERNAL.withCause(e), new Metadata());
+                return;
+            }
+            if (payload.length > maxOutboundMessageSize) {
+                close(
+                        Status.RESOURCE_EXHAUSTED.withDescription(
+                                "gRPC request exceeds " + maxOutboundMessageSize + " bytes"),
+                        new Metadata());
+                return;
+            }
+            requestStreamBytes += payload.length + 5;
+            if (requestStreamBytes > MAX_STREAM_BYTES) {
+                close(
+                        Status.RESOURCE_EXHAUSTED.withDescription(
+                                "gRPC request stream exceeds " + MAX_STREAM_BYTES + " bytes"),
+                        new Metadata());
+                return;
+            }
+            try {
+                bidirectionalRequestOutput.write(frame(payload));
+                bidirectionalRequestOutput.flush();
+            } catch (IOException e) {
+                close(Status.UNAVAILABLE.withCause(e), new Metadata());
+            }
+        }
+
+        private void executeBidirectionalRequest() {
+            Response response = null;
+            try {
+                OutputRepresentation requestEntity =
+                        new OutputRepresentation(GRPC_MEDIA_TYPE) {
+                            @Override
+                            public void write(OutputStream output) throws IOException {
+                                byte[] payload;
+                                while ((payload =
+                                                readGrpcMessage(
+                                                        bidirectionalRequestInput,
+                                                        maxOutboundMessageSize))
+                                        != null) {
+                                    output.write(frame(payload));
+                                    output.flush();
+                                }
+                            }
+                        };
+                Request request =
+                        new Request(
+                                Method.POST,
+                                address.target + "/" + method.getFullMethodName(),
+                                requestEntity);
+                activeRequest = request;
+                request.getHeaders().add("te", "trailers");
+                writeMetadata(requestMetadata, request.getHeaders());
+                response = client.handle(request);
+                lastResponseProtocol.set(response.getProtocol());
+
+                listener.headersRead(readMetadata(response.getHeaders()));
+                if (response.getEntity() != null) {
+                    try (InputStream input = response.getEntity().getStream()) {
+                        byte[] payload;
+                        while ((payload = readGrpcMessage(input, maxInboundMessageSize)) != null) {
+                            byte[] messagePayload = payload;
+                            listener.messagesAvailable(
+                                    new StreamListener.MessageProducer() {
+                                        private boolean consumed;
+
+                                        @Override
+                                        public InputStream next() {
+                                            if (consumed) {
+                                                return null;
+                                            }
+                                            consumed = true;
+                                            return new ByteArrayInputStream(messagePayload);
+                                        }
+                                    });
+                        }
+                    }
+                }
+
+                Metadata trailers = readMetadata(response.getTrailers());
+                String statusText = response.getTrailers().getFirstValue("grpc-status", true);
+                if (statusText == null) {
+                    statusText = response.getHeaders().getFirstValue("grpc-status", true);
+                }
+                if (statusText == null) {
+                    close(Status.UNKNOWN.withDescription("Missing grpc-status"), trailers);
+                    return;
+                }
+                Status status;
+                try {
+                    status = Status.fromCodeValue(Integer.parseInt(statusText));
+                } catch (NumberFormatException e) {
+                    status = Status.UNKNOWN.withDescription("Invalid grpc-status: " + statusText);
+                }
+                String statusMessage = response.getTrailers().getFirstValue("grpc-message", true);
+                if (statusMessage == null) {
+                    statusMessage = response.getHeaders().getFirstValue("grpc-message", true);
+                }
+                if (statusMessage != null) {
+                    status = status.withDescription(statusMessage);
+                }
+                if (!response.getStatus().isSuccess() || !status.isOk()) {
+                    close(status, trailers);
+                    return;
+                }
+                close(status, ClientStreamListener.RpcProgress.PROCESSED, trailers);
+            } catch (Exception e) {
+                close(
+                        Status.UNAVAILABLE.withCause(e),
+                        ClientStreamListener.RpcProgress.PROCESSED,
+                        new Metadata());
+            } finally {
+                try {
+                    bidirectionalRequestInput.close();
+                } catch (IOException e) {
+                    if (!closed) {
+                        close(Status.UNAVAILABLE.withCause(e), new Metadata());
+                    }
+                }
+                if (response != null && response.getEntity() != null) {
+                    response.getEntity().release();
+                }
+            }
+        }
+
         @Override
         public void halfClose() {
             if (closed) {
                 return;
             }
+            if (method.getType() == MethodDescriptor.MethodType.BIDI_STREAMING) {
+                try {
+                    bidirectionalRequestOutput.close();
+                } catch (IOException e) {
+                    close(Status.INTERNAL.withCause(e), new Metadata());
+                }
+                return;
+            }
             if (method.getType() == MethodDescriptor.MethodType.UNARY
                     && requestPayloads.size() != 1) {
                 close(
@@ -1114,7 +1432,16 @@ private synchronized void close(
         }
 
         @Override
-        public void flush() {}
+        public void flush() {
+            PipedOutputStream requestOutput = bidirectionalRequestOutput;
+            if (requestOutput != null && !closed) {
+                try {
+                    requestOutput.flush();
+                } catch (IOException e) {
+                    close(Status.INTERNAL.withCause(e), new Metadata());
+                }
+            }
+        }
 
         @Override
         public boolean isReady() {
@@ -1208,6 +1535,30 @@ private static byte[] unframe(byte[] frame, int maxMessageSize) throws IOExcepti
         return java.util.Arrays.copyOfRange(frame, 5, frame.length);
     }
 
+    private static byte[] readGrpcMessage(InputStream input, int maxMessageSize)
+            throws IOException {
+        int compressionFlag = input.read();
+        if (compressionFlag == -1) {
+            return null;
+        }
+        if (compressionFlag != 0) {
+            throw new IOException("Compressed gRPC messages are not supported");
+        }
+        byte[] lengthBytes = input.readNBytes(4);
+        if (lengthBytes.length != 4) {
+            throw new IOException("Truncated gRPC message length");
+        }
+        int length = ByteBuffer.wrap(lengthBytes).order(ByteOrder.BIG_ENDIAN).getInt();
+        if (length < 0 || length > maxMessageSize) {
+            throw new IOException("Invalid gRPC message length: " + length);
+        }
+        byte[] payload = input.readNBytes(length);
+        if (payload.length != length) {
+            throw new IOException("Truncated gRPC message payload");
+        }
+        return payload;
+    }
+
     private static List<byte[]> unframeMessages(byte[] bytes, int maxMessageSize)
             throws IOException {
         List<byte[]> messages = new ArrayList<>();
diff --git a/readme.md b/readme.md
index aa301aab0f..d5d1d2ef89 100644
--- a/readme.md
+++ b/readme.md
@@ -58,11 +58,14 @@ compatibility seam, not SDK replay: `McpStreamableServerSession.replay` is empty
 The probe does not establish production SSE lifecycle, reconnection, or full Streamable HTTP
 conformance.
 
-The gRPC probes now also invoke SDK `BIDI_STREAMING` methods in both directions and exchange two
-request/response messages. This validates SDK service/method handling and framing for the finite
-exchange only. The Restlet-backed client buffers request messages until half-close, and the
-Restlet-hosted server dispatches buffered requests before writing responses; this is **not**
-full-duplex streaming or evidence of gRPC flow control, demand, or cancellation.
+The gRPC probes now also invoke SDK `BIDI_STREAMING` methods in both directions. Each sends one
+request, waits for its response while the request stream is still open, then sends a second request
+and half-closes. The Restlet-backed client streams request frames from a bounded pipe while reading
+the HTTP/2 response, and the Restlet-hosted server reads request frames concurrently with writing
+queued responses. This validates finite full-duplex message exchange through Restlet's current
+HTTP/2 client/server connectors and the SDK APIs. The transport adapters and gRPC framing remain
+test-only; gRPC demand semantics, fine-grained flow control, cancellation, and long-lived stream
+lifecycle are not covered.
 
 To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
 reference revision, then run the following PowerShell commands (adjust the checkout path):

From ccdccb1eef5da86e9eea2556e0efdfc317c0d0ef Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 18:17:13 -0400
Subject: [PATCH 14/18] Honor gRPC receive demand in R0 transport probes

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrpcSdkTransportSpikeTestCase.java        | 120 +++++++++++++++++-
 readme.md                                     |   6 +-
 2 files changed, 121 insertions(+), 5 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index 9b5abf9da4..eeb9f96e21 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -9,6 +9,7 @@
 package org.restlet.engine.connector;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -18,6 +19,7 @@
 import io.grpc.Attributes;
 import io.grpc.CallOptions;
 import io.grpc.ChannelLogger;
+import io.grpc.ClientCall;
 import io.grpc.Deadline;
 import io.grpc.InternalChannelz;
 import io.grpc.InternalLogId;
@@ -316,6 +318,7 @@ public void onCompleted() {
 
         assertClientStreaming(channel);
         assertFullDuplexBidirectionalStreaming(channel);
+        assertBidirectionalResponseDemand(channel);
     }
 
     @Test
@@ -449,6 +452,7 @@ public void onCompleted() {
 
         assertClientStreaming(grpcClientChannel);
         assertFullDuplexBidirectionalStreaming(grpcClientChannel);
+        assertBidirectionalResponseDemand(grpcClientChannel);
     }
 
     private static void assertClientStreaming(ManagedChannel channel) throws InterruptedException {
@@ -534,6 +538,51 @@ public void onCompleted() {
         assertEquals(List.of("echo:first", "echo:second"), responses);
     }
 
+    private static void assertBidirectionalResponseDemand(ManagedChannel channel)
+            throws InterruptedException {
+        ClientCall<StringValue, StringValue> call =
+                channel.newCall(BIDI_STREAM_METHOD, CallOptions.DEFAULT);
+        CountDownLatch firstResponse = new CountDownLatch(1);
+        CountDownLatch secondResponse = new CountDownLatch(1);
+        CountDownLatch closed = new CountDownLatch(1);
+        AtomicReference<Throwable> failure = new AtomicReference<>();
+        AtomicInteger responses = new AtomicInteger();
+        call.start(
+                new ClientCall.Listener<>() {
+                    @Override
+                    public void onMessage(StringValue message) {
+                        if (responses.incrementAndGet() == 1) {
+                            firstResponse.countDown();
+                        } else {
+                            secondResponse.countDown();
+                        }
+                    }
+
+                    @Override
+                    public void onClose(Status status, Metadata trailers) {
+                        if (!status.isOk()) {
+                            failure.set(status.asRuntimeException(trailers));
+                        }
+                        closed.countDown();
+                    }
+                },
+                new Metadata());
+        call.request(1);
+        call.sendMessage(StringValue.of("first"));
+        assertTrue(firstResponse.await(5, TimeUnit.SECONDS));
+        call.sendMessage(StringValue.of("second"));
+        assertFalse(
+                secondResponse.await(200, TimeUnit.MILLISECONDS),
+                "A second response must wait for additional receive demand");
+        call.request(1);
+        assertTrue(secondResponse.await(5, TimeUnit.SECONDS));
+        call.halfClose();
+        assertTrue(closed.await(5, TimeUnit.SECONDS));
+        if (failure.get() != null) {
+            throw new AssertionError("gRPC demand probe failed", failure.get());
+        }
+    }
+
     private static final class RestletGrpcServer extends org.restlet.Restlet {
 
         private final ServerServiceDefinition service;
@@ -606,7 +655,14 @@ private <RequestT, ResponseT> void dispatchBidirectional(
                         try (InputStream input = request.getEntity().getStream()) {
                             byte[] payload;
                             long requestBytes = 0;
-                            while ((payload = readGrpcMessage(input, MAX_MESSAGE_BYTES)) != null) {
+                            while (true) {
+                                payload = readGrpcMessage(input, MAX_MESSAGE_BYTES);
+                                if (payload == null) {
+                                    break;
+                                }
+                                if (!serverCall.awaitRequestDemand()) {
+                                    return;
+                                }
                                 requestBytes += payload.length + 5L;
                                 if (requestBytes > MAX_STREAM_BYTES) {
                                     throw new IOException(
@@ -673,6 +729,8 @@ private static final class SpikeServerCall<RequestT, ResponseT>
 
         private final CountDownLatch closed = new CountDownLatch(1);
 
+        private final MessageDemand requestDemand = new MessageDemand();
+
         private volatile Status status;
 
         private volatile Metadata trailers = new Metadata();
@@ -689,7 +747,9 @@ private SpikeServerCall(MethodDescriptor<RequestT, ResponseT> method, boolean st
         }
 
         @Override
-        public void request(int numMessages) {}
+        public void request(int numMessages) {
+            requestDemand.request(numMessages);
+        }
 
         @Override
         public void sendHeaders(Metadata headers) {
@@ -724,6 +784,7 @@ public synchronized void close(Status status, Metadata trailers) {
             }
             this.status = status;
             this.trailers = trailers;
+            requestDemand.close();
             closed.countDown();
         }
 
@@ -746,6 +807,10 @@ private boolean awaitClose() throws IOException {
             }
         }
 
+        private boolean awaitRequestDemand() throws IOException {
+            return requestDemand.acquire();
+        }
+
         private void writeResponse(Response response) throws IOException {
             if (status == null) {
                 status = Status.INTERNAL.withDescription("SDK call did not close");
@@ -837,6 +902,44 @@ private static void setGrpcStatus(Response response, Status status) {
         response.getTrailers().add("grpc-status", Integer.toString(status.getCode().value()));
     }
 
+    private static final class MessageDemand {
+
+        private long permits;
+
+        private boolean closed;
+
+        private synchronized void request(int count) {
+            if (count <= 0) {
+                throw new IllegalArgumentException("numMessages must be positive");
+            }
+            if (!closed) {
+                permits = Math.min(Integer.MAX_VALUE, permits + (long) count);
+                notifyAll();
+            }
+        }
+
+        private synchronized boolean acquire() throws IOException {
+            while (permits == 0 && !closed) {
+                try {
+                    wait();
+                } catch (InterruptedException e) {
+                    Thread.currentThread().interrupt();
+                    throw new IOException("Interrupted waiting for gRPC message demand", e);
+                }
+            }
+            if (closed) {
+                return false;
+            }
+            permits--;
+            return true;
+        }
+
+        private synchronized void close() {
+            closed = true;
+            notifyAll();
+        }
+    }
+
     private static final class RestletSocketAddress extends SocketAddress {
 
         private static final long serialVersionUID = 1L;
@@ -1070,6 +1173,8 @@ private static final class RestletClientStream implements ClientStream {
 
         private final List<byte[]> requestPayloads = new ArrayList<>();
 
+        private final MessageDemand responseDemand = new MessageDemand();
+
         private volatile PipedInputStream bidirectionalRequestInput;
 
         private volatile PipedOutputStream bidirectionalRequestOutput;
@@ -1124,6 +1229,7 @@ public void request(int numMessages) {
             if (numMessages <= 0) {
                 throw new IllegalArgumentException("numMessages must be positive");
             }
+            responseDemand.request(numMessages);
         }
 
         @Override
@@ -1246,7 +1352,14 @@ public void write(OutputStream output) throws IOException {
                 if (response.getEntity() != null) {
                     try (InputStream input = response.getEntity().getStream()) {
                         byte[] payload;
-                        while ((payload = readGrpcMessage(input, maxInboundMessageSize)) != null) {
+                        while (true) {
+                            payload = readGrpcMessage(input, maxInboundMessageSize);
+                            if (payload == null) {
+                                break;
+                            }
+                            if (!responseDemand.acquire()) {
+                                return;
+                            }
                             byte[] messagePayload = payload;
                             listener.messagesAvailable(
                                     new StreamListener.MessageProducer() {
@@ -1423,6 +1536,7 @@ private synchronized void close(
                 Status status, ClientStreamListener.RpcProgress progress, Metadata trailers) {
             if (!closed && listener != null) {
                 closed = true;
+                responseDemand.close();
                 try {
                     listener.closed(status, progress, trailers);
                 } finally {
diff --git a/readme.md b/readme.md
index d5d1d2ef89..65cc36e457 100644
--- a/readme.md
+++ b/readme.md
@@ -64,8 +64,10 @@ and half-closes. The Restlet-backed client streams request frames from a bounded
 the HTTP/2 response, and the Restlet-hosted server reads request frames concurrently with writing
 queued responses. This validates finite full-duplex message exchange through Restlet's current
 HTTP/2 client/server connectors and the SDK APIs. The transport adapters and gRPC framing remain
-test-only; gRPC demand semantics, fine-grained flow control, cancellation, and long-lived stream
-lifecycle are not covered.
+test-only. The client bridge honors SDK receive credits and the probe confirms the second response
+is withheld until another message is requested; both bridge directions hold at most one already
+framed message beyond the available credit. This is a bounded SDK-demand probe, not complete HTTP/2
+or gRPC flow-control conformance. Cancellation and long-lived stream lifecycle remain untested.
 
 To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
 reference revision, then run the following PowerShell commands (adjust the checkout path):

From a817742cc36dd6fa1e5a2d08fae76cbeec42ba96 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 18:41:34 -0400
Subject: [PATCH 15/18] Verify active gRPC cancellation and worker cleanup

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
---
 .../GrpcSdkTransportSpikeTestCase.java        | 253 +++++++++++++-----
 readme.md                                     |  15 +-
 2 files changed, 192 insertions(+), 76 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index eeb9f96e21..3b36fd3732 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -138,6 +138,10 @@ class GrpcSdkTransportSpikeTestCase {
 
     private final AtomicReference<Protocol> lastGrpcResponseProtocol = new AtomicReference<>();
 
+    private final CountDownLatch remoteCancellation = new CountDownLatch(1);
+
+    private final AtomicInteger remoteCancellationCount = new AtomicInteger();
+
     @BeforeEach
     void setUp() {
         Engine.clearThreadLocalVariables();
@@ -245,28 +249,7 @@ public void onCompleted() {
                                                 }))
                         .addMethod(
                                 BIDI_STREAM_METHOD,
-                                ServerCalls.asyncBidiStreamingCall(
-                                        result ->
-                                                new io.grpc.stub.StreamObserver<>() {
-                                                    @Override
-                                                    public void onNext(StringValue value) {
-                                                        result.onNext(
-                                                                StringValue.of(
-                                                                        "echo:"
-                                                                                + value
-                                                                                        .getValue()));
-                                                    }
-
-                                                    @Override
-                                                    public void onError(Throwable error) {
-                                                        result.onError(error);
-                                                    }
-
-                                                    @Override
-                                                    public void onCompleted() {
-                                                        result.onCompleted();
-                                                    }
-                                                }))
+                                ServerCalls.asyncBidiStreamingCall(this::echoBidirectional))
                         .build();
         grpcServer = NettyServerBuilder.forPort(0).addService(service).build().start();
 
@@ -319,6 +302,10 @@ public void onCompleted() {
         assertClientStreaming(channel);
         assertFullDuplexBidirectionalStreaming(channel);
         assertBidirectionalResponseDemand(channel);
+        assertActiveCancellation(channel);
+        RestletClientStream cancelledStream = transportFactory.transport.lastBidirectionalStream;
+        assertTrue(cancelledStream.responseReaderFinished.await(5, TimeUnit.SECONDS));
+        assertTrue(cancelledStream.requestWriterFinished.await(5, TimeUnit.SECONDS));
     }
 
     @Test
@@ -383,28 +370,7 @@ public void onCompleted() {
                                                 }))
                         .addMethod(
                                 BIDI_STREAM_METHOD,
-                                ServerCalls.asyncBidiStreamingCall(
-                                        result ->
-                                                new io.grpc.stub.StreamObserver<>() {
-                                                    @Override
-                                                    public void onNext(StringValue value) {
-                                                        result.onNext(
-                                                                StringValue.of(
-                                                                        "echo:"
-                                                                                + value
-                                                                                        .getValue()));
-                                                    }
-
-                                                    @Override
-                                                    public void onError(Throwable error) {
-                                                        result.onError(error);
-                                                    }
-
-                                                    @Override
-                                                    public void onCompleted() {
-                                                        result.onCompleted();
-                                                    }
-                                                }))
+                                ServerCalls.asyncBidiStreamingCall(this::echoBidirectional))
                         .build();
         Context serverContext = new Context();
         serverContext.getParameters().add("http.transport.protocol", "HTTP2");
@@ -453,6 +419,105 @@ public void onCompleted() {
         assertClientStreaming(grpcClientChannel);
         assertFullDuplexBidirectionalStreaming(grpcClientChannel);
         assertBidirectionalResponseDemand(grpcClientChannel);
+        assertActiveCancellation(grpcClientChannel);
+        SpikeServerCall<?, ?> cancelledCall = adapter.lastBidirectionalCall;
+        assertTrue(cancelledCall.requestReaderFinished.await(5, TimeUnit.SECONDS));
+        assertTrue(cancelledCall.responseWriterFinished.await(5, TimeUnit.SECONDS));
+    }
+
+    private io.grpc.stub.StreamObserver<StringValue> echoBidirectional(
+            io.grpc.stub.StreamObserver<StringValue> result) {
+        if (!(result instanceof io.grpc.stub.ServerCallStreamObserver<?> serverObserver)) {
+            throw new IllegalStateException("The SDK did not supply a server call observer");
+        }
+        serverObserver.setOnCancelHandler(
+                () -> {
+                    remoteCancellationCount.incrementAndGet();
+                    remoteCancellation.countDown();
+                });
+        return new io.grpc.stub.StreamObserver<>() {
+            @Override
+            public void onNext(StringValue value) {
+                result.onNext(StringValue.of("echo:" + value.getValue()));
+            }
+
+            @Override
+            public void onError(Throwable error) {
+                if (!serverObserver.isCancelled()) {
+                    result.onError(error);
+                }
+            }
+
+            @Override
+            public void onCompleted() {
+                result.onCompleted();
+            }
+        };
+    }
+
+    private void assertActiveCancellation(ManagedChannel channel) throws InterruptedException {
+        ClientCall<StringValue, StringValue> call =
+                channel.newCall(BIDI_STREAM_METHOD, CallOptions.DEFAULT);
+        CountDownLatch firstResponse = new CountDownLatch(1);
+        CountDownLatch closed = new CountDownLatch(1);
+        AtomicInteger terminalCount = new AtomicInteger();
+        AtomicReference<Status> terminalStatus = new AtomicReference<>();
+        call.start(
+                new ClientCall.Listener<>() {
+                    @Override
+                    public void onMessage(StringValue message) {
+                        firstResponse.countDown();
+                    }
+
+                    @Override
+                    public void onClose(Status status, Metadata trailers) {
+                        terminalStatus.set(status);
+                        terminalCount.incrementAndGet();
+                        closed.countDown();
+                    }
+                },
+                new Metadata());
+        try {
+            call.request(1);
+            call.sendMessage(StringValue.of("cancel-me"));
+            assertTrue(firstResponse.await(5, TimeUnit.SECONDS));
+            call.cancel("R0 active-stream cancellation", null);
+            assertTrue(closed.await(5, TimeUnit.SECONDS));
+            assertEquals(Status.Code.CANCELLED, terminalStatus.get().getCode());
+            assertTrue(
+                    remoteCancellation.await(5, TimeUnit.SECONDS),
+                    "Cancellation must reach the remote SDK service without request half-close");
+            call.cancel("Repeated R0 cancellation", null);
+            assertEquals(
+                    "echo:after-cancel",
+                    ClientCalls.blockingUnaryCall(
+                                    channel,
+                                    ECHO_METHOD,
+                                    CallOptions.DEFAULT,
+                                    StringValue.of("after-cancel"))
+                            .getValue());
+            assertEquals(1, terminalCount.get());
+            assertEquals(1, remoteCancellationCount.get());
+        } finally {
+            call.cancel("R0 cancellation probe cleanup", null);
+        }
+    }
+
+    @Test
+    void closingDemandReleasesBlockedReceiver() throws Exception {
+        MessageDemand demand = new MessageDemand();
+        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+            var receiver = executor.submit(demand::acquire);
+            try {
+                assertTrue(demand.waiting.await(5, TimeUnit.SECONDS));
+                assertFalse(receiver.isDone());
+            } finally {
+                demand.close();
+            }
+            assertFalse(receiver.get(5, TimeUnit.SECONDS));
+            demand.request(1);
+            assertFalse(demand.acquire(), "Closed demand must not reopen after another request");
+        }
     }
 
     private static void assertClientStreaming(ManagedChannel channel) throws InterruptedException {
@@ -587,6 +652,8 @@ private static final class RestletGrpcServer extends org.restlet.Restlet {
 
         private final ServerServiceDefinition service;
 
+        private volatile SpikeServerCall<?, ?> lastBidirectionalCall;
+
         private final java.util.concurrent.atomic.AtomicReference<String> lastRequestProtocol =
                 new java.util.concurrent.atomic.AtomicReference<>();
 
@@ -642,6 +709,7 @@ private <RequestT, ResponseT> void dispatchBidirectional(
                 throws IOException {
             MethodDescriptor<RequestT, ResponseT> method = definition.getMethodDescriptor();
             SpikeServerCall<RequestT, ResponseT> serverCall = new SpikeServerCall<>(method, true);
+            lastBidirectionalCall = serverCall;
             ServerCall.Listener<RequestT> listener =
                     definition
                             .getServerCallHandler()
@@ -675,15 +743,22 @@ private <RequestT, ResponseT> void dispatchBidirectional(
                             }
                             listener.onHalfClose();
                         } catch (Exception e) {
-                            listener.onCancel();
+                            serverCall.cancelled = true;
                             serverCall.close(Status.fromThrowable(e), new Metadata());
+                            listener.onCancel();
+                        } finally {
+                            serverCall.requestReaderFinished.countDown();
                         }
                     });
             response.setEntity(
                     new OutputRepresentation(GRPC_MEDIA_TYPE) {
                         @Override
                         public void write(OutputStream output) throws IOException {
-                            serverCall.writeStreamingResponse(response, output);
+                            try {
+                                serverCall.writeStreamingResponse(response, output);
+                            } finally {
+                                serverCall.responseWriterFinished.countDown();
+                            }
                         }
                     });
         }
@@ -729,10 +804,16 @@ private static final class SpikeServerCall<RequestT, ResponseT>
 
         private final CountDownLatch closed = new CountDownLatch(1);
 
+        private final CountDownLatch requestReaderFinished = new CountDownLatch(1);
+
+        private final CountDownLatch responseWriterFinished = new CountDownLatch(1);
+
         private final MessageDemand requestDemand = new MessageDemand();
 
         private volatile Status status;
 
+        private volatile boolean cancelled;
+
         private volatile Metadata trailers = new Metadata();
 
         private final boolean streaming;
@@ -790,7 +871,7 @@ public synchronized void close(Status status, Metadata trailers) {
 
         @Override
         public boolean isCancelled() {
-            return false;
+            return cancelled;
         }
 
         @Override
@@ -904,6 +985,8 @@ private static void setGrpcStatus(Response response, Status status) {
 
     private static final class MessageDemand {
 
+        private final CountDownLatch waiting = new CountDownLatch(1);
+
         private long permits;
 
         private boolean closed;
@@ -921,6 +1004,7 @@ private synchronized void request(int count) {
         private synchronized boolean acquire() throws IOException {
             while (permits == 0 && !closed) {
                 try {
+                    waiting.countDown();
                     wait();
                 } catch (InterruptedException e) {
                     Thread.currentThread().interrupt();
@@ -953,6 +1037,8 @@ private RestletSocketAddress(String target) {
 
     private static final class RestletTransportFactory implements ClientTransportFactory {
 
+        private volatile RestletClientTransport transport;
+
         private final Client client;
 
         private final AtomicReference<Protocol> lastResponseProtocol;
@@ -979,8 +1065,10 @@ public ConnectionClientTransport newClientTransport(
             if (!(address instanceof RestletSocketAddress restletAddress)) {
                 throw new IllegalArgumentException("Unsupported address: " + address);
             }
-            return new RestletClientTransport(
-                    client, restletAddress, options.getAuthority(), lastResponseProtocol);
+            transport =
+                    new RestletClientTransport(
+                            client, restletAddress, options.getAuthority(), lastResponseProtocol);
+            return transport;
         }
 
         @Override
@@ -1008,6 +1096,8 @@ public Collection<Class<? extends SocketAddress>> getSupportedSocketAddressTypes
 
     private static final class RestletClientTransport implements ConnectionClientTransport {
 
+        private volatile RestletClientStream lastBidirectionalStream;
+
         private final Client client;
 
         private final RestletSocketAddress address;
@@ -1082,15 +1172,20 @@ public ClientStream newStream(
                 throw new UnsupportedOperationException(
                         "R0 SPI probe does not support call credentials or compression");
             }
-            return new RestletClientStream(
-                    client,
-                    address,
-                    authority,
-                    method,
-                    headers,
-                    lastResponseProtocol,
-                    this::streamStarted,
-                    this::streamFinished);
+            RestletClientStream stream =
+                    new RestletClientStream(
+                            client,
+                            address,
+                            authority,
+                            method,
+                            headers,
+                            lastResponseProtocol,
+                            this::streamStarted,
+                            this::streamFinished);
+            if (method.getType() == MethodDescriptor.MethodType.BIDI_STREAMING) {
+                lastBidirectionalStream = stream;
+            }
+            return stream;
         }
 
         @Override
@@ -1175,6 +1270,10 @@ private static final class RestletClientStream implements ClientStream {
 
         private final MessageDemand responseDemand = new MessageDemand();
 
+        private final CountDownLatch requestWriterFinished = new CountDownLatch(1);
+
+        private final CountDownLatch responseReaderFinished = new CountDownLatch(1);
+
         private volatile PipedInputStream bidirectionalRequestInput;
 
         private volatile PipedOutputStream bidirectionalRequestOutput;
@@ -1234,20 +1333,20 @@ public void request(int numMessages) {
 
         @Override
         public void cancel(Status reason) {
-            Status cancellation = reason;
+            close(reason, new Metadata());
+            Request request = activeRequest;
+            if (request != null) {
+                request.abort();
+            }
             PipedOutputStream requestOutput = bidirectionalRequestOutput;
             if (requestOutput != null) {
                 try {
                     requestOutput.close();
                 } catch (IOException e) {
-                    cancellation = reason.withCause(e);
+                    throw new IllegalStateException(
+                            "Unable to close cancelled gRPC request pipe", e);
                 }
             }
-            Request request = activeRequest;
-            if (request != null) {
-                request.abort();
-            }
-            close(cancellation, new Metadata());
         }
 
         @Override
@@ -1326,14 +1425,18 @@ private void executeBidirectionalRequest() {
                         new OutputRepresentation(GRPC_MEDIA_TYPE) {
                             @Override
                             public void write(OutputStream output) throws IOException {
-                                byte[] payload;
-                                while ((payload =
-                                                readGrpcMessage(
-                                                        bidirectionalRequestInput,
-                                                        maxOutboundMessageSize))
-                                        != null) {
-                                    output.write(frame(payload));
-                                    output.flush();
+                                try {
+                                    byte[] payload;
+                                    while ((payload =
+                                                    readGrpcMessage(
+                                                            bidirectionalRequestInput,
+                                                            maxOutboundMessageSize))
+                                            != null) {
+                                        output.write(frame(payload));
+                                        output.flush();
+                                    }
+                                } finally {
+                                    requestWriterFinished.countDown();
                                 }
                             }
                         };
@@ -1343,6 +1446,9 @@ public void write(OutputStream output) throws IOException {
                                 address.target + "/" + method.getFullMethodName(),
                                 requestEntity);
                 activeRequest = request;
+                if (closed) {
+                    return;
+                }
                 request.getHeaders().add("te", "trailers");
                 writeMetadata(requestMetadata, request.getHeaders());
                 response = client.handle(request);
@@ -1421,6 +1527,7 @@ public InputStream next() {
                 if (response != null && response.getEntity() != null) {
                     response.getEntity().release();
                 }
+                responseReaderFinished.countDown();
             }
         }
 
diff --git a/readme.md b/readme.md
index 65cc36e457..5cf0017ef9 100644
--- a/readme.md
+++ b/readme.md
@@ -67,7 +67,15 @@ HTTP/2 client/server connectors and the SDK APIs. The transport adapters and gRP
 test-only. The client bridge honors SDK receive credits and the probe confirms the second response
 is withheld until another message is requested; both bridge directions hold at most one already
 framed message beyond the available credit. This is a bounded SDK-demand probe, not complete HTTP/2
-or gRPC flow-control conformance. Cancellation and long-lived stream lifecycle remain untested.
+or gRPC flow-control conformance.
+
+Active bidi cancellation is now exercised in both directions after the first response, while the
+request stream remains open. The client observes `CANCELLED` once, the remote SDK cancellation
+handler runs once, both bridge I/O workers finish, and a subsequent unary call succeeds on the same
+channel. The client bridge records cancellation before aborting HTTP I/O so an abort failure cannot
+replace the cancellation status. A separate regression verifies that closing demand wakes a blocked
+receiver and does not reopen on later credits. Pre-header cancellation races, server-initiated
+cancellation, and long-lived stream lifecycle remain outside this bounded probe.
 
 To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
 reference revision, then run the following PowerShell commands (adjust the checkout path):
@@ -87,8 +95,9 @@ prototype over Restlet HTTP/2; this compares MCP semantics, not transport implem
 The reference process is stopped after the test. Startup failures fail the test rather than
 falling back to recorded responses.
 
-Without the opt-in properties, eleven tests pass and the live comparison is skipped; with them,
-all twelve run. Recorded and live reports are written separately under `org.restlet/target` as
+Without the opt-in properties, twelve tests pass and the live comparison is skipped; with them,
+all thirteen run. Add `Http2FullDuplexTestCase,Http2CancellationTestCase` to the selector to include
+the two core connector regressions. Recorded and live reports are written separately under `org.restlet/target` as
 `mcp-ikanos-recorded.json` and `mcp-ikanos-differential.json`; reference-process logs are kept in
 per-run `mcp-ikanos-*` directories there. Review changed observations explicitly before updating
 the checked-in baseline. No Ikanos or additional production dependency is added to Restlet.

From d5d9b17d24bd2b1b4c651647e264e3a696b9efc9 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Wed, 21 Oct 2026 19:35:16 -0400
Subject: [PATCH 16/18] Complete R0 SDK feasibility and core transport gates

Verify socket-less grpc-java runtime hosting, native status and metadata, pre-header cancellation, active shutdown and SDK module isolation. Fix multiplexed response-head delivery and headers-only completion. Record scoped protocol decisions and delivery follow-ups.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Signed-off-by: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
---
 changes.md                                    |   7 +
 .../restlet/engine/netty/NettyClientCall.java |   6 +-
 .../restlet/engine/netty/NettyServerCall.java |  20 +-
 .../GrpcSdkServerHostSpikeTestCase.java       | 617 ++++++++++++++++++
 .../GrpcSdkTransportSpikeTestCase.java        | 496 ++++++++++++--
 .../connector/Http2FullDuplexTestCase.java    |  55 ++
 .../McpSdkTransportSpikeTestCase.java         |   8 +
 ...cpStreamableSdkTransportSpikeTestCase.java |  11 +
 .../connector/RpcSdkBoundaryTestCase.java     | 116 ++++
 readme.md                                     | 101 ++-
 10 files changed, 1384 insertions(+), 53 deletions(-)
 create mode 100644 org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkServerHostSpikeTestCase.java
 create mode 100644 org.restlet/src/test/java/org/restlet/engine/connector/RpcSdkBoundaryTestCase.java

diff --git a/changes.md b/changes.md
index fea3b6525b..16b515c9d1 100644
--- a/changes.md
+++ b/changes.md
@@ -62,6 +62,13 @@ Changes log
           leftover of the Servlet mode, which is no longer supported. `Protocol.valueOf("war")`
           now returns a new, unknown protocol. Use CLAP or FILE references instead.
     - Enhancements
+        - HTTP/2 and HTTP/3 clients deliver response headers without waiting for the first
+          response body byte. This allows idle duplex and SSE responses to expose their
+          headers before the peer sends a message.
+        - Empty HTTP/2 and HTTP/3 server responses with no entity or trailers end with their
+          initial headers, rather than a subsequent empty DATA frame.
+        - Added test-only MCP and gRPC SDK feasibility probes over the Restlet HTTP/2
+          connectors. These do not introduce production RPC extensions.
         - Added the `EventStreamRepresentation`, `ServerSentEvent` and `EventStreamReader` APIs for
           streaming and reading Server-Sent Events over the HTTP connectors, including optional
           comment heartbeats and reconnects honoring `retry:` and `Last-Event-ID`. The
diff --git a/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java b/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java
index 09d9afc98c..074bcdeea3 100644
--- a/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java
+++ b/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java
@@ -517,7 +517,11 @@ private Representation getResponseEntity(Status status) {
                         : HeaderUtils.getContentLength(responseHeaders);
 
         if (hasBody(status)) {
-            InputStream stream = nonEmpty(getResponseEntityStream());
+            InputStream stream = getResponseEntityStream();
+            // Multiplexed streams may remain idle after their response headers arrive.
+            if (!kind.isStream()) {
+                stream = nonEmpty(stream);
+            }
             if (stream != null) {
                 result = new InputRepresentation(stream, null);
                 result.setSize(size);
diff --git a/org.restlet/src/main/java/org/restlet/engine/netty/NettyServerCall.java b/org.restlet/src/main/java/org/restlet/engine/netty/NettyServerCall.java
index 96793418b0..aa27fe27f6 100644
--- a/org.restlet/src/main/java/org/restlet/engine/netty/NettyServerCall.java
+++ b/org.restlet/src/main/java/org/restlet/engine/netty/NettyServerCall.java
@@ -19,6 +19,7 @@
 import io.netty.channel.ChannelFutureListener;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelPipeline;
+import io.netty.handler.codec.http.DefaultFullHttpResponse;
 import io.netty.handler.codec.http.DefaultHttpContent;
 import io.netty.handler.codec.http.DefaultHttpResponse;
 import io.netty.handler.codec.http.DefaultLastHttpContent;
@@ -124,6 +125,9 @@ class NettyServerCall {
     /** Indicates whether the response head was written. */
     private volatile boolean responseHeadWritten;
 
+    /** Indicates that an empty multiplexed response ended with its initial headers. */
+    private boolean responseEndedWithHead;
+
     /** Indicates whether the exchange was completed. */
     private volatile boolean completed;
 
@@ -608,7 +612,8 @@ private void writeHead(boolean emptyBody) {
         responseHeadWritten = true;
 
         int code = statusCode;
-        HttpResponse head = newResponseHead(code);
+        responseEndedWithHead = kind.isStream() && emptyBody && responseTrailers.isEmpty();
+        HttpResponse head = newResponseHead(code, responseEndedWithHead);
         boolean bodyAllowed =
                 code != 204 && code != 304 && code >= 200 && !"HEAD".equals(getMethod());
         boolean hasTrailers = bodyAllowed && !responseTrailers.isEmpty();
@@ -628,13 +633,17 @@ private void writeHead(boolean emptyBody) {
     }
 
     /** Creates the response head with the status and the response headers. */
-    private HttpResponse newResponseHead(int code) {
+    private HttpResponse newResponseHead(int code, boolean endWithHead) {
         String reason = reasonPhrase;
         HttpResponseStatus status =
                 (reason != null && !reason.isEmpty())
                         ? new HttpResponseStatus(code, reason)
                         : HttpResponseStatus.valueOf(code);
-        HttpResponse head = new DefaultHttpResponse(HttpVersion.HTTP_1_1, status);
+        HttpResponse head =
+                endWithHead
+                        ? new DefaultFullHttpResponse(
+                                HttpVersion.HTTP_1_1, status, Unpooled.EMPTY_BUFFER)
+                        : new DefaultHttpResponse(HttpVersion.HTTP_1_1, status);
 
         for (Header header : responseHeaders) {
             String name =
@@ -691,6 +700,11 @@ void complete() {
                 requestBody.close();
                 return;
             }
+            if (responseEndedWithHead) {
+                channel.flush();
+                requestBody.close();
+                return;
+            }
 
             boolean keepAlive = HttpUtil.isKeepAlive(request) && requestBody.isFullyConsumed();
             LastHttpContent lastContent = LastHttpContent.EMPTY_LAST_CONTENT;
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkServerHostSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkServerHostSpikeTestCase.java
new file mode 100644
index 0000000000..efa1254a66
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkServerHostSpikeTestCase.java
@@ -0,0 +1,617 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+package org.restlet.engine.connector;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import com.google.common.util.concurrent.Futures;
+import com.google.common.util.concurrent.ListenableFuture;
+import com.google.protobuf.StringValue;
+import io.grpc.Attributes;
+import io.grpc.CallOptions;
+import io.grpc.InternalChannelz;
+import io.grpc.InternalInstrumented;
+import io.grpc.InternalLogId;
+import io.grpc.InternalMetadata;
+import io.grpc.Metadata;
+import io.grpc.MethodDescriptor;
+import io.grpc.ServerServiceDefinition;
+import io.grpc.ServerStreamTracer;
+import io.grpc.Status;
+import io.grpc.StatusRuntimeException;
+import io.grpc.internal.AbstractServerStream;
+import io.grpc.internal.InternalServer;
+import io.grpc.internal.ReadableBuffers;
+import io.grpc.internal.ServerImplBuilder;
+import io.grpc.internal.ServerListener;
+import io.grpc.internal.ServerTransport;
+import io.grpc.internal.ServerTransportListener;
+import io.grpc.internal.StatsTraceContext;
+import io.grpc.internal.TransportTracer;
+import io.grpc.internal.WritableBuffer;
+import io.grpc.netty.shaded.io.grpc.netty.NettyChannelBuilder;
+import io.grpc.protobuf.ProtoUtils;
+import io.grpc.stub.ClientCalls;
+import io.grpc.stub.ServerCalls;
+import java.io.ByteArrayOutputStream;
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.SocketAddress;
+import java.nio.charset.StandardCharsets;
+import java.util.ArrayList;
+import java.util.Base64;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import org.junit.jupiter.api.Test;
+import org.restlet.Context;
+import org.restlet.Request;
+import org.restlet.Response;
+import org.restlet.Server;
+import org.restlet.data.MediaType;
+import org.restlet.data.Protocol;
+import org.restlet.engine.Engine;
+import org.restlet.representation.ByteArrayRepresentation;
+
+class GrpcSdkServerHostSpikeTestCase {
+
+    private static final int MAX_BYTES = 1024 * 1024;
+
+    private static final MethodDescriptor<StringValue, StringValue> ECHO =
+            MethodDescriptor.<StringValue, StringValue>newBuilder()
+                    .setType(MethodDescriptor.MethodType.UNARY)
+                    .setFullMethodName("restlet.r0.Native/Echo")
+                    .setRequestMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
+                    .build();
+
+    private static final MethodDescriptor<StringValue, StringValue> COLLECT =
+            ECHO.toBuilder()
+                    .setType(MethodDescriptor.MethodType.CLIENT_STREAMING)
+                    .setFullMethodName("restlet.r0.Native/Collect")
+                    .build();
+
+    @Test
+    void hostsSdkRuntimeAndFramingWithoutAnSdkListener() throws Exception {
+        Engine.clearThreadLocalVariables();
+        Engine.register(false);
+        Engine.getInstance().getRegisteredServers().add(new HttpServerHelper(null));
+        SocketlessHost host = new SocketlessHost();
+        Context context = new Context();
+        context.getParameters().add("http.transport.protocol", "HTTP2");
+        Server http = new Server(context, Protocol.HTTP, 0, host);
+        AtomicInteger intercepted = new AtomicInteger();
+        AtomicInteger handled = new AtomicInteger();
+        try (var applications = Executors.newVirtualThreadPerTaskExecutor()) {
+            io.grpc.Server sdk =
+                    new ServerImplBuilder(
+                                    (factories, recorder) -> {
+                                        host.tracers = List.copyOf(factories);
+                                        return host;
+                                    })
+                            .executor(applications)
+                            .intercept(
+                                    new io.grpc.ServerInterceptor() {
+                                        @Override
+                                        public <Q, S> io.grpc.ServerCall.Listener<Q> interceptCall(
+                                                io.grpc.ServerCall<Q, S> call,
+                                                Metadata headers,
+                                                io.grpc.ServerCallHandler<Q, S> next) {
+                                            intercepted.incrementAndGet();
+                                            assertEquals(
+                                                    "localhost:" + http.getActualPort(),
+                                                    call.getAuthority());
+                                            return next.startCall(call, headers);
+                                        }
+                                    })
+                            .addService(
+                                    ServerServiceDefinition.builder("restlet.r0.Native")
+                                            .addMethod(
+                                                    ECHO,
+                                                    ServerCalls.asyncUnaryCall(
+                                                            (StringValue request,
+                                                                    io.grpc.stub.StreamObserver<
+                                                                                    StringValue>
+                                                                            out) -> {
+                                                                handled.incrementAndGet();
+                                                                if ("bad"
+                                                                        .equals(
+                                                                                request
+                                                                                        .getValue())) {
+                                                                    out.onError(
+                                                                            Status.INVALID_ARGUMENT
+                                                                                    .withDescription(
+                                                                                            "native % error: caf\u00e9")
+                                                                                    .asRuntimeException());
+                                                                } else {
+                                                                    out.onNext(
+                                                                            StringValue.of(
+                                                                                    "native:"
+                                                                                            + request
+                                                                                                    .getValue()));
+                                                                    out.onCompleted();
+                                                                }
+                                                            }))
+                                            .addMethod(
+                                                    COLLECT,
+                                                    ServerCalls.asyncClientStreamingCall(
+                                                            out -> {
+                                                                handled.incrementAndGet();
+                                                                return new io.grpc.stub
+                                                                                .StreamObserver<
+                                                                        StringValue>() {
+                                                                    private final List<String>
+                                                                            values =
+                                                                                    new ArrayList<>();
+
+                                                                    @Override
+                                                                    public void onNext(
+                                                                            StringValue value) {
+                                                                        values.add(
+                                                                                value.getValue());
+                                                                    }
+
+                                                                    @Override
+                                                                    public void onError(
+                                                                            Throwable error) {
+                                                                        out.onError(error);
+                                                                    }
+
+                                                                    @Override
+                                                                    public void onCompleted() {
+                                                                        out.onNext(
+                                                                                StringValue.of(
+                                                                                        String.join(
+                                                                                                ",",
+                                                                                                values)));
+                                                                        out.onCompleted();
+                                                                    }
+                                                                };
+                                                            }))
+                                            .build())
+                            .build();
+            try {
+                sdk.start();
+                http.start();
+                var channel =
+                        NettyChannelBuilder.forAddress("localhost", http.getActualPort())
+                                .usePlaintext()
+                                .build();
+                try {
+                    assertEquals(
+                            "native:hello",
+                            ClientCalls.blockingUnaryCall(
+                                            channel,
+                                            ECHO,
+                                            CallOptions.DEFAULT,
+                                            StringValue.of("hello"))
+                                    .getValue());
+                    var error =
+                            assertThrows(
+                                    StatusRuntimeException.class,
+                                    () ->
+                                            ClientCalls.blockingUnaryCall(
+                                                    channel,
+                                                    ECHO,
+                                                    CallOptions.DEFAULT,
+                                                    StringValue.of("bad")));
+                    assertEquals(
+                            Status.Code.INVALID_ARGUMENT,
+                            error.getStatus().getCode(),
+                            error.getStatus().toString());
+                    assertEquals("native % error: caf\u00e9", error.getStatus().getDescription());
+                    var unknown =
+                            ECHO.toBuilder().setFullMethodName("restlet.r0.Native/Missing").build();
+                    var missing =
+                            assertThrows(
+                                    StatusRuntimeException.class,
+                                    () ->
+                                            ClientCalls.blockingUnaryCall(
+                                                    channel,
+                                                    unknown,
+                                                    CallOptions.DEFAULT,
+                                                    StringValue.of("unknown")));
+                    assertEquals(Status.Code.UNIMPLEMENTED, missing.getStatus().getCode());
+                    CountDownLatch collected = new CountDownLatch(1);
+                    var result = new java.util.concurrent.atomic.AtomicReference<String>();
+                    var failure = new java.util.concurrent.atomic.AtomicReference<Throwable>();
+                    var requests =
+                            ClientCalls.asyncClientStreamingCall(
+                                    channel.newCall(COLLECT, CallOptions.DEFAULT),
+                                    new io.grpc.stub.StreamObserver<>() {
+                                        @Override
+                                        public void onNext(StringValue value) {
+                                            result.set(value.getValue());
+                                        }
+
+                                        @Override
+                                        public void onError(Throwable error) {
+                                            failure.set(error);
+                                            collected.countDown();
+                                        }
+
+                                        @Override
+                                        public void onCompleted() {
+                                            collected.countDown();
+                                        }
+                                    });
+                    requests.onNext(StringValue.of("first"));
+                    requests.onNext(StringValue.of("second"));
+                    requests.onCompleted();
+                    assertTrue(collected.await(5, TimeUnit.SECONDS));
+                    org.junit.jupiter.api.Assertions.assertNull(failure.get());
+                    assertEquals("first,second", result.get());
+                    assertEquals(3, handled.get());
+                    assertEquals(3, intercepted.get());
+                } finally {
+                    channel.shutdownNow();
+                    assertTrue(channel.awaitTermination(5, TimeUnit.SECONDS));
+                }
+            } finally {
+                sdk.shutdownNow();
+                assertTrue(sdk.awaitTermination(5, TimeUnit.SECONDS));
+                assertTrue(http.isStarted(), "SDK shutdown must not stop the borrowed HTTP server");
+                http.stop();
+                host.timer.shutdownNow();
+                assertTrue(host.timer.awaitTermination(5, TimeUnit.SECONDS));
+                for (HostTransport transport : host.transports) {
+                    assertTrue(transport.events.awaitTermination(5, TimeUnit.SECONDS));
+                }
+            }
+        } finally {
+            try {
+                http.stop();
+            } finally {
+                host.timer.shutdownNow();
+                host.transports.forEach(transport -> transport.events.shutdownNow());
+                Engine.clearThreadLocalVariables();
+            }
+        }
+    }
+
+    private static final class SocketlessHost extends org.restlet.Restlet
+            implements InternalServer {
+
+        private final ScheduledExecutorService timer = Executors.newSingleThreadScheduledExecutor();
+
+        private final List<HostTransport> transports =
+                new java.util.concurrent.CopyOnWriteArrayList<>();
+
+        private volatile ServerListener listener;
+
+        private List<? extends ServerStreamTracer.Factory> tracers = List.of();
+
+        @Override
+        public void start(ServerListener listener) {
+            this.listener = listener;
+        }
+
+        @Override
+        public void shutdown() {
+            listener.serverShutdown();
+        }
+
+        @Override
+        public SocketAddress getListenSocketAddress() {
+            return new InetSocketAddress("localhost", 0);
+        }
+
+        @Override
+        public List<? extends SocketAddress> getListenSocketAddresses() {
+            return List.of(getListenSocketAddress());
+        }
+
+        @Override
+        public InternalInstrumented<InternalChannelz.SocketStats> getListenSocketStats() {
+            return null;
+        }
+
+        @Override
+        public List<InternalInstrumented<InternalChannelz.SocketStats>> getListenSocketStatsList() {
+            return List.of();
+        }
+
+        @Override
+        public void handle(Request request, Response response) {
+            String method = request.getResourceRef().getPath().substring(1);
+            Metadata headers = fromHttp(request);
+            HostTransport transport = new HostTransport(timer);
+            transports.add(transport);
+            transport.listener = listener.transportCreated(transport);
+            Attributes attributes = transport.listener.transportReady(Attributes.EMPTY);
+            SdkStream stream =
+                    new SdkStream(
+                            transport,
+                            attributes,
+                            request.getHostRef().getAuthority(),
+                            StatsTraceContext.newServerContext(tracers, method, headers));
+            transport.stream = stream;
+            response.setOnSent((sentRequest, sentResponse) -> transport.finish());
+            try {
+                transport.listener.streamCreated(stream, method, headers);
+                byte[] bytes;
+                try (var input = request.getEntity().getStream()) {
+                    bytes = input.readNBytes(MAX_BYTES + 1);
+                }
+                if (bytes.length > MAX_BYTES) {
+                    throw new IOException("Native SDK host request exceeds its R0 byte budget");
+                }
+                transport.events.execute(
+                        () -> {
+                            stream.state.onStreamAllocated();
+                            stream.state.inboundDataReceived(ReadableBuffers.wrap(bytes), true);
+                        });
+                if (!stream.done.await(5, TimeUnit.SECONDS)) {
+                    throw new IOException("Native SDK host did not complete");
+                }
+                if (stream.body.size() == 0 && !stream.headersSent) {
+                    var empty = new org.restlet.representation.EmptyRepresentation();
+                    empty.setMediaType(new MediaType("application/grpc"));
+                    response.setEntity(empty);
+                } else {
+                    response.setEntity(
+                            new ByteArrayRepresentation(
+                                    stream.body.toByteArray(), new MediaType("application/grpc")));
+                }
+                toHttp(stream.headers, response.getHeaders());
+                toHttp(
+                        stream.trailers,
+                        stream.headersSent ? response.getTrailers() : response.getHeaders());
+            } catch (IOException e) {
+                stream.cancel(Status.INTERNAL.withCause(e));
+                throw new IllegalStateException("Native SDK host failed", e);
+            } catch (InterruptedException e) {
+                Thread.currentThread().interrupt();
+                stream.cancel(Status.CANCELLED.withCause(e));
+                throw new IllegalStateException("Native SDK host interrupted", e);
+            }
+        }
+    }
+
+    private static final class HostTransport implements ServerTransport {
+
+        private final ScheduledExecutorService timer;
+
+        private final ExecutorService events =
+                Executors.newSingleThreadExecutor(Thread.ofVirtual().factory());
+
+        private final InternalLogId id =
+                InternalLogId.allocate(HostTransport.class, "R0 logical call");
+
+        private ServerTransportListener listener;
+
+        private SdkStream stream;
+
+        private boolean finishing;
+
+        private HostTransport(ScheduledExecutorService timer) {
+            this.timer = timer;
+        }
+
+        @Override
+        public void shutdown() {}
+
+        @Override
+        public synchronized void shutdownNow(Status reason) {
+            if (!finishing && stream != null) {
+                stream.cancel(reason);
+            }
+        }
+
+        private synchronized void finish() {
+            if (finishing) {
+                return;
+            }
+            finishing = true;
+            events.execute(
+                    () -> {
+                        try {
+                            stream.state.complete();
+                            listener.transportTerminated();
+                        } finally {
+                            events.shutdown();
+                        }
+                    });
+        }
+
+        @Override
+        public ScheduledExecutorService getScheduledExecutorService() {
+            return timer;
+        }
+
+        @Override
+        public ListenableFuture<InternalChannelz.SocketStats> getStats() {
+            return Futures.immediateFuture(null);
+        }
+
+        @Override
+        public InternalLogId getLogId() {
+            return id;
+        }
+    }
+
+    private static final class SdkStream extends AbstractServerStream {
+
+        private final ByteArrayOutputStream body = new ByteArrayOutputStream();
+
+        private final Metadata headers = new Metadata();
+
+        private final CountDownLatch done = new CountDownLatch(1);
+
+        private final HostTransport transport;
+
+        private final Attributes attributes;
+
+        private final String authority;
+
+        private final State state;
+
+        private volatile Metadata trailers = new Metadata();
+
+        private boolean headersSent;
+
+        private SdkStream(
+                HostTransport transport,
+                Attributes attributes,
+                String authority,
+                StatsTraceContext stats) {
+            super(hint -> new Buffer(Math.max(1, Math.min(hint, 16 * 1024))), stats);
+            this.transport = transport;
+            this.attributes = attributes;
+            this.authority = authority;
+            state = new State(stats);
+        }
+
+        @Override
+        protected TransportState transportState() {
+            return state;
+        }
+
+        @Override
+        public Attributes getAttributes() {
+            return attributes;
+        }
+
+        @Override
+        public String getAuthority() {
+            return authority;
+        }
+
+        @Override
+        public int streamId() {
+            return -1;
+        }
+
+        @Override
+        protected Sink abstractServerStreamSink() {
+            return new Sink() {
+                @Override
+                public void writeHeaders(Metadata metadata, boolean flush) {
+                    headers.merge(metadata);
+                    headersSent = true;
+                }
+
+                @Override
+                public void writeFrame(WritableBuffer frame, boolean flush, int messages) {
+                    Buffer buffer = (Buffer) frame;
+                    if (body.size() + buffer.readableBytes() > MAX_BYTES) {
+                        throw new IllegalStateException(
+                                "Native SDK host response exceeds R0 budget");
+                    }
+                    body.write(buffer.bytes, 0, buffer.used);
+                    buffer.release();
+                }
+
+                @Override
+                public void writeTrailers(Metadata metadata, boolean sent, Status status) {
+                    trailers = metadata;
+                    done.countDown();
+                }
+
+                @Override
+                public void cancel(Status status) {
+                    state.runOnTransportThread(() -> state.transportReportStatus(status));
+                    Metadata metadata = new Metadata();
+                    metadata.put(io.grpc.InternalStatus.CODE_KEY, status);
+                    trailers = metadata;
+                    done.countDown();
+                }
+            };
+        }
+
+        private final class State extends AbstractServerStream.TransportState {
+            private State(StatsTraceContext stats) {
+                super(MAX_BYTES, stats, new TransportTracer());
+            }
+
+            @Override
+            public void runOnTransportThread(Runnable task) {
+                transport.events.execute(task);
+            }
+
+            @Override
+            public void bytesRead(int bytes) {}
+
+            @Override
+            public void deframeFailed(Throwable cause) {
+                SdkStream.this.cancel(Status.fromThrowable(cause));
+            }
+        }
+    }
+
+    private static final class Buffer implements WritableBuffer {
+
+        private final byte[] bytes;
+
+        private int used;
+
+        private Buffer(int capacity) {
+            bytes = new byte[capacity];
+        }
+
+        @Override
+        public void write(byte value) {
+            bytes[used++] = value;
+        }
+
+        @Override
+        public void write(byte[] source, int offset, int length) {
+            System.arraycopy(source, offset, bytes, used, length);
+            used += length;
+        }
+
+        @Override
+        public int writableBytes() {
+            return bytes.length - used;
+        }
+
+        @Override
+        public int readableBytes() {
+            return used;
+        }
+
+        @Override
+        public void release() {}
+    }
+
+    private static Metadata fromHttp(Request request) {
+        List<byte[]> serialized = new ArrayList<>();
+        for (var header : request.getHeaders()) {
+            String name = header.getName().toLowerCase(java.util.Locale.ROOT);
+            serialized.add(name.getBytes(StandardCharsets.US_ASCII));
+            serialized.add(
+                    name.endsWith("-bin")
+                            ? Base64.getDecoder().decode(header.getValue())
+                            : header.getValue().getBytes(StandardCharsets.US_ASCII));
+        }
+        return InternalMetadata.newMetadata(serialized.toArray(byte[][]::new));
+    }
+
+    private static void toHttp(
+            Metadata metadata, org.restlet.util.Series<org.restlet.data.Header> headers) {
+        byte[][] serialized = InternalMetadata.serialize(metadata);
+        if (serialized == null) {
+            return;
+        }
+        for (int i = 0; i < serialized.length; i += 2) {
+            String name = new String(serialized[i], StandardCharsets.US_ASCII);
+            headers.add(
+                    name,
+                    name.endsWith("-bin")
+                            ? Base64.getEncoder().withoutPadding().encodeToString(serialized[i + 1])
+                            : new String(serialized[i + 1], StandardCharsets.US_ASCII));
+        }
+    }
+}
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index 3b36fd3732..c03b2a31fc 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -10,6 +10,7 @@
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertThrows;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
@@ -69,6 +70,8 @@
 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 org.restlet.Client;
 import org.restlet.Context;
 import org.restlet.Request;
@@ -126,6 +129,24 @@ class GrpcSdkTransportSpikeTestCase {
                     .setResponseMarshaller(ProtoUtils.marshaller(StringValue.getDefaultInstance()))
                     .build();
 
+    private static final MethodDescriptor<StringValue, StringValue> CONTROL_METHOD =
+            ECHO_METHOD.toBuilder()
+                    .setType(MethodDescriptor.MethodType.SERVER_STREAMING)
+                    .setFullMethodName("restlet.r0.Echo/Control")
+                    .build();
+
+    private static final Metadata.Key<String> TEXT_METADATA =
+            Metadata.Key.of("x-r0-text", Metadata.ASCII_STRING_MARSHALLER);
+
+    private static final Metadata.Key<byte[]> BINARY_METADATA =
+            Metadata.Key.of("x-r0-bin", Metadata.BINARY_BYTE_MARSHALLER);
+
+    private static final Metadata.Key<byte[]> STATUS_DETAILS =
+            Metadata.Key.of("grpc-status-details-bin", Metadata.BINARY_BYTE_MARSHALLER);
+
+    private static final Metadata.Key<String> AUTHORITY_METADATA =
+            Metadata.Key.of("x-r0-authority", Metadata.ASCII_STRING_MARSHALLER);
+
     private Client client;
 
     private io.grpc.Server grpcServer;
@@ -142,6 +163,10 @@ class GrpcSdkTransportSpikeTestCase {
 
     private final AtomicInteger remoteCancellationCount = new AtomicInteger();
 
+    private RestletTransportFactory interopFactory;
+
+    private RestletGrpcServer interopServer;
+
     @BeforeEach
     void setUp() {
         Engine.clearThreadLocalVariables();
@@ -170,6 +195,362 @@ void tearDown() throws Exception {
         Engine.clearThreadLocalVariables();
     }
 
+    @Test
+    void rejectsUnsupportedTransportControlsExplicitly() throws Exception {
+        client = new Client(Protocol.HTTP);
+        RestletTransportFactory factory =
+                new RestletTransportFactory(client, lastGrpcResponseProtocol);
+        try {
+            var transport =
+                    factory.newClientTransport(
+                            new RestletSocketAddress("http://localhost:1"),
+                            new ClientTransportFactory.ClientTransportOptions()
+                                    .setAuthority("localhost:1"),
+                            null);
+            var stream =
+                    transport.newStream(
+                            ECHO_METHOD,
+                            new Metadata(),
+                            CallOptions.DEFAULT,
+                            new io.grpc.ClientStreamTracer[0]);
+            assertThrows(
+                    UnsupportedOperationException.class,
+                    () -> stream.setAuthority("other.example"));
+            assertThrows(
+                    UnsupportedOperationException.class,
+                    () -> stream.setDeadline(Deadline.after(1, TimeUnit.SECONDS)));
+            assertThrows(
+                    UnsupportedOperationException.class,
+                    () -> stream.setCompressor(new io.grpc.Codec.Gzip()));
+            assertThrows(
+                    IllegalArgumentException.class,
+                    () ->
+                            factory.newClientTransport(
+                                    new java.net.InetSocketAddress("localhost", 1),
+                                    new ClientTransportFactory.ClientTransportOptions(),
+                                    null));
+            assertThrows(
+                    UnsupportedOperationException.class,
+                    () ->
+                            factory.newClientTransport(
+                                    new RestletSocketAddress("http://localhost:1"),
+                                    new ClientTransportFactory.ClientTransportOptions()
+                                            .setAuthority("virtual.example:1"),
+                                    null));
+            AtomicReference<Status> pingFailure = new AtomicReference<>();
+            transport.ping(
+                    new io.grpc.internal.ClientTransport.PingCallback() {
+                        @Override
+                        public void onSuccess(long roundTripTimeNanos) {
+                            throw new AssertionError("The probe must not pretend to support PING");
+                        }
+
+                        @Override
+                        public void onFailure(Status cause) {
+                            pingFailure.set(cause);
+                        }
+                    },
+                    Runnable::run);
+            assertEquals(Status.Code.UNIMPLEMENTED, pingFailure.get().getCode());
+        } finally {
+            factory.close();
+            assertTrue(factory.scheduledExecutor.awaitTermination(5, TimeUnit.SECONDS));
+            assertFalse(client.isStarted(), "Borrowed connectors must not be started or stopped");
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void preservesMetadataAndTerminalStatus(boolean restletHosted) throws Exception {
+        openInteropChannel(controlService(), restletHosted);
+        for (String mode : List.of("success", "trailers-only", "late-error", "empty")) {
+            Metadata headers = new Metadata();
+            headers.put(TEXT_METADATA, "first");
+            headers.put(TEXT_METADATA, "second");
+            headers.put(BINARY_METADATA, new byte[] {0, 1, (byte) 255});
+            CallObservation observed = observeCall(channel, mode, headers);
+            assertEquals(1, observed.terminals());
+            assertEquals(
+                    mode.equals("trailers-only") || mode.equals("late-error")
+                            ? Status.Code.PERMISSION_DENIED
+                            : Status.Code.OK,
+                    observed.status().getCode(),
+                    mode + ": " + observed.status());
+            assertEquals(List.of("first", "second"), metadataValues(observed.trailers()));
+            assertEquals(channel.authority(), observed.trailers().get(AUTHORITY_METADATA));
+            org.junit.jupiter.api.Assertions.assertArrayEquals(
+                    new byte[] {0, 1, (byte) 255}, observed.trailers().get(STATUS_DETAILS));
+            assertEquals(
+                    mode.equals("success") || mode.equals("late-error")
+                            ? List.of("delivered")
+                            : List.of(),
+                    observed.messages());
+            if (!mode.equals("trailers-only")) {
+                assertEquals(List.of("first", "second"), metadataValues(observed.headers()));
+                org.junit.jupiter.api.Assertions.assertArrayEquals(
+                        new byte[] {0, 1, (byte) 255}, observed.headers().get(BINARY_METADATA));
+            }
+        }
+        channel.shutdown();
+        assertTrue(channel.awaitTermination(5, TimeUnit.SECONDS));
+        if (client != null) {
+            assertTrue(client.isStarted(), "Channel shutdown must not stop its borrowed connector");
+        }
+    }
+
+    private void openInteropChannel(ServerServiceDefinition service, boolean restletHosted)
+            throws Exception {
+        if (restletHosted) {
+            Context context = new Context();
+            context.getParameters().add("http.transport.protocol", "HTTP2");
+            interopServer = new RestletGrpcServer(service);
+            restletServer = new Server(context, Protocol.HTTP, 0, interopServer);
+            restletServer.start();
+            channel =
+                    NettyChannelBuilder.forAddress("localhost", restletServer.getActualPort())
+                            .usePlaintext()
+                            .build();
+        } else {
+            grpcServer = NettyServerBuilder.forPort(0).addService(service).build().start();
+            Context context = new Context();
+            context.getParameters().add("httpClientTransportMode", "HTTP2");
+            client = new Client(context, Protocol.HTTP);
+            client.start();
+            String target = "http://localhost:" + grpcServer.getPort();
+            interopFactory = new RestletTransportFactory(client, lastGrpcResponseProtocol);
+            channel =
+                    new ManagedChannelImplBuilder(
+                                    new RestletSocketAddress(target),
+                                    "localhost:" + grpcServer.getPort(),
+                                    () -> interopFactory,
+                                    () -> 0)
+                            .build();
+        }
+    }
+
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void cancelsBeforeHeadersAndShutsDownActiveCalls(boolean restletHosted) throws Exception {
+        CountDownLatch received = new CountDownLatch(2);
+        CountDownLatch cancelled = new CountDownLatch(2);
+        AtomicInteger cancellationCount = new AtomicInteger();
+        AtomicReference<Throwable> unexpectedError = new AtomicReference<>();
+        ServerServiceDefinition service =
+                ServerServiceDefinition.builder("restlet.r0.Echo")
+                        .addMethod(
+                                BIDI_STREAM_METHOD,
+                                ServerCalls.asyncBidiStreamingCall(
+                                        result -> {
+                                            if (!(result
+                                                    instanceof
+                                                    io.grpc.stub.ServerCallStreamObserver<?>
+                                                            observer)) {
+                                                throw new IllegalStateException(
+                                                        "The SDK did not supply a server call observer");
+                                            }
+                                            observer.setOnCancelHandler(
+                                                    () -> {
+                                                        cancellationCount.incrementAndGet();
+                                                        cancelled.countDown();
+                                                    });
+                                            return new io.grpc.stub.StreamObserver<StringValue>() {
+                                                @Override
+                                                public void onNext(StringValue value) {
+                                                    received.countDown();
+                                                }
+
+                                                @Override
+                                                public void onError(Throwable error) {
+                                                    if (Status.fromThrowable(error).getCode()
+                                                            != Status.Code.CANCELLED) {
+                                                        unexpectedError.set(error);
+                                                    }
+                                                }
+
+                                                @Override
+                                                public void onCompleted() {
+                                                    result.onCompleted();
+                                                }
+                                            };
+                                        }))
+                        .build();
+        openInteropChannel(service, restletHosted);
+        List<ClientCall<StringValue, StringValue>> calls = new ArrayList<>();
+        CountDownLatch closed = new CountDownLatch(2);
+        AtomicInteger terminalCount = new AtomicInteger();
+        AtomicInteger headerCount = new AtomicInteger();
+        AtomicReference<Status.Code> explicitCancellation = new AtomicReference<>();
+        List<Status.Code> statuses = new java.util.concurrent.CopyOnWriteArrayList<>();
+        for (int i = 0; i < 2; i++) {
+            boolean cancelDirectly = i == 0;
+            var call = channel.newCall(BIDI_STREAM_METHOD, CallOptions.DEFAULT);
+            calls.add(call);
+            call.start(
+                    new ClientCall.Listener<>() {
+                        @Override
+                        public void onHeaders(Metadata headers) {
+                            headerCount.incrementAndGet();
+                        }
+
+                        @Override
+                        public void onClose(Status status, Metadata trailers) {
+                            if (cancelDirectly) {
+                                explicitCancellation.set(status.getCode());
+                            }
+                            statuses.add(status.getCode());
+                            terminalCount.incrementAndGet();
+                            closed.countDown();
+                        }
+                    },
+                    new Metadata());
+            call.request(1);
+            call.sendMessage(StringValue.of("hold-before-headers"));
+        }
+        assertTrue(received.await(5, TimeUnit.SECONDS));
+        assertEquals(0, headerCount.get(), "The SDK must not report headers before they are sent");
+        calls.getFirst().cancel("pre-header cancellation", null);
+        channel.shutdownNow();
+        assertTrue(closed.await(5, TimeUnit.SECONDS));
+        assertTrue(cancelled.await(5, TimeUnit.SECONDS));
+        assertTrue(channel.awaitTermination(5, TimeUnit.SECONDS));
+        assertEquals(2, terminalCount.get());
+        assertEquals(2, cancellationCount.get());
+        assertEquals(Status.Code.CANCELLED, explicitCancellation.get());
+        assertNull(unexpectedError.get());
+        assertTrue(
+                statuses.stream()
+                        .allMatch(
+                                status ->
+                                        status == Status.Code.CANCELLED
+                                                || status == Status.Code.UNAVAILABLE),
+                statuses.toString());
+        if (interopFactory != null) {
+            assertTrue(
+                    interopFactory.transport.lastBidirectionalStream.responseReaderFinished.await(
+                            5, TimeUnit.SECONDS));
+            assertTrue(
+                    interopFactory.transport.lastBidirectionalStream.requestWriterFinished.await(
+                            5, TimeUnit.SECONDS));
+            assertTrue(interopFactory.scheduledExecutor.awaitTermination(5, TimeUnit.SECONDS));
+            assertTrue(client.isStarted());
+        } else {
+            assertTrue(
+                    interopServer.lastBidirectionalCall.requestReaderFinished.await(
+                            5, TimeUnit.SECONDS));
+            assertTrue(
+                    interopServer.lastBidirectionalCall.responseWriterFinished.await(
+                            5, TimeUnit.SECONDS));
+            assertTrue(restletServer.isStarted());
+        }
+    }
+
+    private static ServerServiceDefinition controlService() {
+        return ServerServiceDefinition.builder("restlet.r0.Echo")
+                .addMethod(
+                        CONTROL_METHOD,
+                        (call, headers) -> {
+                            call.request(1);
+                            return new ServerCall.Listener<StringValue>() {
+                                private String mode;
+
+                                @Override
+                                public void onMessage(StringValue request) {
+                                    mode = request.getValue();
+                                }
+
+                                @Override
+                                public void onHalfClose() {
+                                    Metadata trailers = new Metadata();
+                                    trailers.put(AUTHORITY_METADATA, call.getAuthority());
+                                    for (String value : metadataValues(headers)) {
+                                        trailers.put(TEXT_METADATA, value);
+                                    }
+                                    trailers.put(STATUS_DETAILS, headers.get(BINARY_METADATA));
+                                    if (!"trailers-only".equals(mode)) {
+                                        Metadata responseHeaders = new Metadata();
+                                        for (String value : metadataValues(headers)) {
+                                            responseHeaders.put(TEXT_METADATA, value);
+                                        }
+                                        responseHeaders.put(
+                                                BINARY_METADATA, headers.get(BINARY_METADATA));
+                                        call.sendHeaders(responseHeaders);
+                                    }
+                                    if ("success".equals(mode) || "late-error".equals(mode)) {
+                                        call.sendMessage(StringValue.of("delivered"));
+                                    }
+                                    call.close(
+                                            "trailers-only".equals(mode)
+                                                            || "late-error".equals(mode)
+                                                    ? Status.PERMISSION_DENIED.withDescription(
+                                                            "native-error")
+                                                    : Status.OK,
+                                            trailers);
+                                }
+                            };
+                        })
+                .build();
+    }
+
+    private static List<String> metadataValues(Metadata metadata) {
+        Iterable<String> values = metadata.getAll(TEXT_METADATA);
+        return values == null
+                ? List.of()
+                : java.util.stream.StreamSupport.stream(values.spliterator(), false).toList();
+    }
+
+    private record CallObservation(
+            List<String> messages,
+            Metadata headers,
+            Metadata trailers,
+            Status status,
+            int terminals) {}
+
+    private static CallObservation observeCall(
+            ManagedChannel channel, String mode, Metadata headers) throws InterruptedException {
+        var call = channel.newCall(CONTROL_METHOD, CallOptions.DEFAULT);
+        List<String> messages = new java.util.concurrent.CopyOnWriteArrayList<>();
+        AtomicReference<Metadata> initial = new AtomicReference<>(new Metadata());
+        AtomicReference<Metadata> trailers = new AtomicReference<>();
+        AtomicReference<Status> status = new AtomicReference<>();
+        AtomicInteger terminals = new AtomicInteger();
+        CountDownLatch done = new CountDownLatch(1);
+        call.start(
+                new ClientCall.Listener<>() {
+                    @Override
+                    public void onHeaders(Metadata value) {
+                        initial.set(value);
+                    }
+
+                    @Override
+                    public void onMessage(StringValue message) {
+                        messages.add(message.getValue());
+                    }
+
+                    @Override
+                    public void onClose(Status value, Metadata metadata) {
+                        terminals.incrementAndGet();
+                        status.set(value);
+                        trailers.set(metadata);
+                        done.countDown();
+                    }
+                },
+                headers);
+        try {
+            call.request(2);
+            call.sendMessage(StringValue.of(mode));
+            call.halfClose();
+            assertTrue(done.await(5, TimeUnit.SECONDS), mode);
+            return new CallObservation(
+                    List.copyOf(messages),
+                    initial.get(),
+                    trailers.get(),
+                    status.get(),
+                    terminals.get());
+        } finally {
+            call.cancel("probe cleanup", null);
+        }
+    }
+
     @Test
     void invokesOfficialGrpcServerThroughRestletHttp2Client() throws Exception {
         ServerServiceDefinition service =
@@ -284,7 +665,10 @@ public void onCompleted() {
                                         ECHO_METHOD,
                                         CallOptions.DEFAULT,
                                         StringValue.of("bad")));
-        assertEquals(Status.Code.INVALID_ARGUMENT, failure.getStatus().getCode());
+        assertEquals(
+                Status.Code.INVALID_ARGUMENT,
+                failure.getStatus().getCode(),
+                failure.getStatus().toString());
         assertEquals("2.0", lastGrpcResponseProtocol.get().getVersion());
 
         var stream =
@@ -708,8 +1092,11 @@ private <RequestT, ResponseT> void dispatchBidirectional(
                 Response response)
                 throws IOException {
             MethodDescriptor<RequestT, ResponseT> method = definition.getMethodDescriptor();
-            SpikeServerCall<RequestT, ResponseT> serverCall = new SpikeServerCall<>(method, true);
+            SpikeServerCall<RequestT, ResponseT> serverCall =
+                    new SpikeServerCall<>(method, true, request.getHostRef().getAuthority());
             lastBidirectionalCall = serverCall;
+            response.setOnSent(
+                    (sentRequest, sentResponse) -> serverCall.responseWriterFinished.countDown());
             ServerCall.Listener<RequestT> listener =
                     definition
                             .getServerCallHandler()
@@ -754,11 +1141,7 @@ private <RequestT, ResponseT> void dispatchBidirectional(
                     new OutputRepresentation(GRPC_MEDIA_TYPE) {
                         @Override
                         public void write(OutputStream output) throws IOException {
-                            try {
-                                serverCall.writeStreamingResponse(response, output);
-                            } finally {
-                                serverCall.responseWriterFinished.countDown();
-                            }
+                            serverCall.writeStreamingResponse(response, output);
                         }
                     });
         }
@@ -771,7 +1154,8 @@ private <RequestT, ResponseT> void dispatch(
                 throws IOException {
             MethodDescriptor<RequestT, ResponseT> method = definition.getMethodDescriptor();
             Metadata requestHeaders = readMetadata(request.getHeaders());
-            SpikeServerCall<RequestT, ResponseT> serverCall = new SpikeServerCall<>(method);
+            SpikeServerCall<RequestT, ResponseT> serverCall =
+                    new SpikeServerCall<>(method, false, request.getHostRef().getAuthority());
             ServerCall.Listener<RequestT> listener =
                     definition.getServerCallHandler().startCall(serverCall, requestHeaders);
             if (listener == null) {
@@ -818,13 +1202,18 @@ private static final class SpikeServerCall<RequestT, ResponseT>
 
         private final boolean streaming;
 
-        private SpikeServerCall(MethodDescriptor<RequestT, ResponseT> method) {
-            this(method, false);
-        }
+        private final String authority;
 
-        private SpikeServerCall(MethodDescriptor<RequestT, ResponseT> method, boolean streaming) {
+        private SpikeServerCall(
+                MethodDescriptor<RequestT, ResponseT> method, boolean streaming, String authority) {
             this.method = method;
             this.streaming = streaming;
+            this.authority = authority;
+        }
+
+        @Override
+        public String getAuthority() {
+            return authority;
         }
 
         @Override
@@ -899,7 +1288,7 @@ private void writeResponse(Response response) throws IOException {
             }
             response.setStatus(org.restlet.data.Status.SUCCESS_OK);
             writeMetadata(responseHeaders, response.getHeaders());
-            if (!responseMessages.isEmpty() && status.isOk()) {
+            if (!responseMessages.isEmpty()) {
                 ByteArrayOutputStream framedMessages = new ByteArrayOutputStream();
                 for (ResponseT responseMessage : responseMessages) {
                     try (InputStream payload = method.streamResponse(responseMessage)) {
@@ -1065,6 +1454,12 @@ public ConnectionClientTransport newClientTransport(
             if (!(address instanceof RestletSocketAddress restletAddress)) {
                 throw new IllegalArgumentException("Unsupported address: " + address);
             }
+            if (!new org.restlet.data.Reference(restletAddress.target)
+                    .getAuthority()
+                    .equals(options.getAuthority())) {
+                throw new UnsupportedOperationException(
+                        "R0 spike cannot separate connection address from HTTP/TLS authority");
+            }
             transport =
                     new RestletClientTransport(
                             client, restletAddress, options.getAuthority(), lastResponseProtocol);
@@ -1111,6 +1506,9 @@ private static final class RestletClientTransport implements ConnectionClientTra
 
         private final AtomicInteger activeStreams = new AtomicInteger();
 
+        private final Set<RestletClientStream> streams =
+                java.util.concurrent.ConcurrentHashMap.newKeySet();
+
         private final java.util.concurrent.atomic.AtomicBoolean terminated =
                 new java.util.concurrent.atomic.AtomicBoolean();
 
@@ -1150,6 +1548,9 @@ public void shutdown(Status status) {
         @Override
         public void shutdownNow(Status status) {
             shutdown(status);
+            for (RestletClientStream stream : Set.copyOf(streams)) {
+                stream.cancel(status);
+            }
         }
 
         @Override
@@ -1214,16 +1615,21 @@ public Attributes getAttributes() {
             return Attributes.EMPTY;
         }
 
-        private void streamStarted() {
+        private synchronized void streamStarted(RestletClientStream stream) {
+            streams.add(stream);
             if (activeStreams.getAndIncrement() == 0) {
                 Listener currentListener = listener;
                 if (currentListener != null) {
                     currentListener.transportInUse(true);
                 }
             }
+            if (shutdown) {
+                stream.cancel(Status.UNAVAILABLE.withDescription("Transport is shut down"));
+            }
         }
 
-        private void streamFinished() {
+        private synchronized void streamFinished(RestletClientStream stream) {
+            streams.remove(stream);
             if (activeStreams.decrementAndGet() == 0) {
                 Listener currentListener = listener;
                 if (currentListener != null) {
@@ -1258,9 +1664,9 @@ private static final class RestletClientStream implements ClientStream {
 
         private final AtomicReference<Protocol> lastResponseProtocol;
 
-        private final Runnable onStart;
+        private final java.util.function.Consumer<RestletClientStream> onStart;
 
-        private final Runnable onClose;
+        private final java.util.function.Consumer<RestletClientStream> onClose;
 
         private volatile ClientStreamListener listener;
 
@@ -1293,8 +1699,8 @@ private RestletClientStream(
                 MethodDescriptor<?, ?> method,
                 Metadata requestMetadata,
                 AtomicReference<Protocol> lastResponseProtocol,
-                Runnable onStart,
-                Runnable onClose) {
+                java.util.function.Consumer<RestletClientStream> onStart,
+                java.util.function.Consumer<RestletClientStream> onClose) {
             this.client = client;
             this.address = address;
             this.authority = authority;
@@ -1308,7 +1714,10 @@ private RestletClientStream(
         @Override
         public void start(ClientStreamListener listener) {
             this.listener = listener;
-            onStart.run();
+            onStart.accept(this);
+            if (closed) {
+                return;
+            }
             if (method.getType() == MethodDescriptor.MethodType.BIDI_STREAMING) {
                 try {
                     PipedInputStream input = new PipedInputStream(STREAM_PIPE_BUFFER_BYTES);
@@ -1605,27 +2014,29 @@ public void halfClose() {
                 if (statusMessage != null) {
                     status = status.withDescription(statusMessage);
                 }
-                if (!status.isOk()) {
-                    close(status, trailers);
-                    return;
-                }
-                if (responsePayload == null) {
-                    throw new IOException("gRPC response did not contain a message");
+                if (response.getHeaders().getFirstValue("grpc-status", true) != null) {
+                    trailers.merge(readMetadata(response.getHeaders()));
+                } else {
+                    listener.headersRead(readMetadata(response.getHeaders()));
                 }
-                listener.headersRead(readMetadata(response.getHeaders()));
-                List<byte[]> messages = unframeMessages(responsePayload, maxInboundMessageSize);
-                listener.messagesAvailable(
-                        new StreamListener.MessageProducer() {
-                            private int next;
-
-                            @Override
-                            public InputStream next() {
-                                if (next == messages.size()) {
-                                    return null;
+                List<byte[]> messages =
+                        responsePayload == null
+                                ? List.of()
+                                : unframeMessages(responsePayload, maxInboundMessageSize);
+                if (!messages.isEmpty()) {
+                    listener.messagesAvailable(
+                            new StreamListener.MessageProducer() {
+                                private int next;
+
+                                @Override
+                                public InputStream next() {
+                                    if (next == messages.size()) {
+                                        return null;
+                                    }
+                                    return new ByteArrayInputStream(messages.get(next++));
                                 }
-                                return new ByteArrayInputStream(messages.get(next++));
-                            }
-                        });
+                            });
+                }
                 close(status, ClientStreamListener.RpcProgress.PROCESSED, trailers);
             } catch (Exception e) {
                 close(
@@ -1647,7 +2058,7 @@ private synchronized void close(
                 try {
                     listener.closed(status, progress, trailers);
                 } finally {
-                    onClose.run();
+                    onClose.accept(this);
                 }
             }
         }
@@ -1800,7 +2211,7 @@ private static List<byte[]> unframeMessages(byte[] bytes, int maxMessageSize)
 
     private static void writeMetadata(Metadata metadata, Series<Header> headers) {
         for (String name : metadata.keys()) {
-            if (name.startsWith("grpc-")) {
+            if (name.startsWith("grpc-") && !"grpc-status-details-bin".equals(name)) {
                 continue;
             }
             if (name.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
@@ -1838,7 +2249,8 @@ private static Metadata readMetadata(Series<Header> headers) {
                         "grpc-accept-encoding");
         for (Header header : headers) {
             String name = header.getName().toLowerCase(java.util.Locale.ROOT);
-            if (excluded.contains(name) || name.startsWith("grpc-")) {
+            if (excluded.contains(name)
+                    || (name.startsWith("grpc-") && !"grpc-status-details-bin".equals(name))) {
                 continue;
             }
             if (name.endsWith(Metadata.BINARY_HEADER_SUFFIX)) {
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/Http2FullDuplexTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/Http2FullDuplexTestCase.java
index 8e053de9a0..59a28ff5a0 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/Http2FullDuplexTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/Http2FullDuplexTestCase.java
@@ -58,6 +58,61 @@ void tearDown() throws Exception {
         Engine.clearThreadLocalVariables();
     }
 
+    @Test
+    void receivesResponseHeadersBeforeTheFirstBodyByte() throws Exception {
+        CountDownLatch headFlushed = new CountDownLatch(1);
+        CountDownLatch sendBody = new CountDownLatch(1);
+        Restlet delayedBody =
+                new Restlet() {
+                    @Override
+                    public void handle(Request request, Response response) {
+                        response.getHeaders().add("x-response-phase", "headers");
+                        response.setEntity(
+                                new OutputRepresentation(MediaType.APPLICATION_OCTET_STREAM) {
+                                    @Override
+                                    public void write(OutputStream output) throws IOException {
+                                        output.flush();
+                                        headFlushed.countDown();
+                                        try {
+                                            if (!sendBody.await(10, TimeUnit.SECONDS)) {
+                                                throw new IOException(
+                                                        "Timed out waiting to send body");
+                                            }
+                                        } catch (InterruptedException e) {
+                                            Thread.currentThread().interrupt();
+                                            throw new IOException(
+                                                    "Interrupted waiting to send body", e);
+                                        }
+                                        output.write("late".getBytes(StandardCharsets.UTF_8));
+                                    }
+                                });
+                    }
+                };
+        Context serverContext = new Context();
+        serverContext.getParameters().add("http.transport.protocol", "HTTP2");
+        server = new Server(serverContext, Protocol.HTTP, 0, delayedBody);
+        server.start();
+        Context clientContext = new Context();
+        clientContext.getParameters().add("httpClientTransportMode", "HTTP2");
+        client = new Client(clientContext, Protocol.HTTP);
+        client.start();
+        Request request = new Request(Method.GET, "http://localhost:" + server.getActualPort());
+        try (var executor = Executors.newVirtualThreadPerTaskExecutor()) {
+            var responseFuture = executor.submit(() -> client.handle(request));
+            try {
+                assertTrue(headFlushed.await(5, TimeUnit.SECONDS));
+                Response response = responseFuture.get(2, TimeUnit.SECONDS);
+                assertEquals(
+                        "headers", response.getHeaders().getFirstValue("x-response-phase", true));
+                sendBody.countDown();
+                assertEquals("late", response.getEntityAsText());
+            } finally {
+                sendBody.countDown();
+                request.abort();
+            }
+        }
+    }
+
     @Test
     void receivesResponseWhileRequestEntityIsStillBeingWritten() throws Exception {
         CountDownLatch requestWriteStarted = new CountDownLatch(1);
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
index 0ff8179503..490875f9be 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -190,6 +190,10 @@ void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
         assertTrue(listedTools.tools().stream().anyMatch(item -> item.name().equals("echo")));
         assertEquals("echo:hello", ((McpSchema.TextContent) result.content().getFirst()).text());
         assertEquals("2.0", clientTransport.lastResponseProtocol.get().getVersion());
+        sdkClient.closeGracefully().block(REQUEST_TIMEOUT);
+        sdkClient = null;
+        assertTrue(client.isStarted());
+        assertTrue(server.isStarted());
 
         String profileRequestBody =
                 "{\"jsonrpc\":\"2.0\",\"id\":7,\"method\":\"tools/list\",\"params\":{\"_meta\":{\"io.modelcontextprotocol/protocolVersion\":\"2026-07-28\"}}}";
@@ -210,6 +214,10 @@ void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
                             java.nio.charset.StandardCharsets.UTF_8);
             assertTrue(body.contains("\"echo\""));
         }
+        sdkServer.closeGracefully().block(REQUEST_TIMEOUT);
+        sdkServer = null;
+        assertTrue(client.isStarted());
+        assertTrue(server.isStarted());
     }
 
     @Test
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
index c401dd4eff..a4512abd8a 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
@@ -174,6 +174,17 @@ void servesListeningSseAndReplaysEventsAfterLastEventId() throws Exception {
         assertEquals(
                 org.restlet.data.Status.CLIENT_ERROR_BAD_REQUEST,
                 expiredReplayResponse.getStatus());
+        sdkClient.closeGracefully().block(REQUEST_TIMEOUT);
+        sdkClient = null;
+        assertTrue(transport.sessions.isEmpty());
+        assertTrue(transport.eventHistory.isEmpty());
+        assertTrue(transport.listeningTransports.isEmpty());
+        assertTrue(client.isStarted());
+        assertTrue(server.isStarted());
+        sdkServer.closeGracefully().block(REQUEST_TIMEOUT);
+        sdkServer = null;
+        assertTrue(client.isStarted());
+        assertTrue(server.isStarted());
     }
 
     @BeforeEach
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/RpcSdkBoundaryTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/RpcSdkBoundaryTestCase.java
new file mode 100644
index 0000000000..94d03585d9
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/RpcSdkBoundaryTestCase.java
@@ -0,0 +1,116 @@
+/**
+ * Copyright 2005-2026 Qlik
+ *<p>
+ * The content of this file is subject to the terms of the Apache 2.0 open
+ * source license available at https://www.opensource.org/licenses/apache-2.0
+ *<p>
+ * Restlet is a registered trademark of QlikTech International AB.
+ */
+package org.restlet.engine.connector;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+import java.io.File;
+import java.lang.module.Configuration;
+import java.lang.module.ModuleFinder;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.ServiceLoader;
+import org.junit.jupiter.api.Test;
+import org.restlet.Client;
+
+class RpcSdkBoundaryTestCase {
+
+    @Test
+    void resolvesPinnedSdkModulesWithoutOfficialNetworkTransports() throws Exception {
+        Map<String, Class<?>> modules =
+                Map.of(
+                        "io.grpc",
+                        io.grpc.Status.class,
+                        "io.grpc.internal",
+                        io.grpc.internal.ManagedChannelImplBuilder.class,
+                        "io.grpc.protobuf",
+                        io.grpc.protobuf.ProtoUtils.class,
+                        "io.grpc.stub",
+                        io.grpc.stub.ClientCalls.class,
+                        "io.modelcontextprotocol.sdk.mcp.core",
+                        io.modelcontextprotocol.server.McpServer.class,
+                        "io.modelcontextprotocol.sdk.mcp.json.jackson2",
+                        io.modelcontextprotocol.json.jackson2.JacksonMcpJsonMapperSupplier.class);
+        for (var entry : modules.entrySet()) {
+            Path jar =
+                    Path.of(
+                            entry.getValue()
+                                    .getProtectionDomain()
+                                    .getCodeSource()
+                                    .getLocation()
+                                    .toURI());
+            var descriptor = ModuleFinder.of(jar).findAll().iterator().next().descriptor();
+            assertEquals(entry.getKey(), descriptor.name());
+            assertTrue(descriptor.isAutomatic(), entry.getKey());
+        }
+
+        String classPath =
+                System.getProperty(
+                        "surefire.test.class.path", System.getProperty("java.class.path"));
+        List<Path> dependencies =
+                Arrays.stream(classPath.split(File.pathSeparator))
+                        .map(Path::of)
+                        .filter(Files::isRegularFile)
+                        .filter(path -> path.toString().endsWith(".jar"))
+                        .filter(
+                                path ->
+                                        !path.getFileName()
+                                                .toString()
+                                                .startsWith("grpc-netty-shaded-"))
+                        .toList();
+        var paths = new java.util.ArrayList<>(dependencies);
+        paths.add(
+                Path.of(Client.class.getProtectionDomain().getCodeSource().getLocation().toURI()));
+        ModuleFinder finder = ModuleFinder.of(paths.toArray(Path[]::new));
+        var roots = new java.util.HashSet<>(modules.keySet());
+        roots.add("org.restlet");
+        Configuration configuration =
+                ModuleLayer.boot().configuration().resolveAndBind(finder, ModuleFinder.of(), roots);
+        ModuleLayer layer =
+                ModuleLayer.boot()
+                        .defineModulesWithOneLoader(
+                                configuration, ClassLoader.getPlatformClassLoader());
+        assertTrue(layer.findModule("org.restlet").isPresent());
+        assertTrue(
+                layer.findModule("org.restlet").orElseThrow().getDescriptor().requires().stream()
+                        .noneMatch(
+                                requirement ->
+                                        requirement.name().startsWith("io.grpc")
+                                                || requirement
+                                                        .name()
+                                                        .startsWith("io.modelcontextprotocol")));
+        assertFalse(layer.findModule("io.grpc.netty.shaded").isPresent());
+        assertFalse(layer.findModule("io.grpc.netty").isPresent());
+        assertFalse(layer.findModule("io.grpc.okhttp").isPresent());
+        for (var entry : modules.entrySet()) {
+            Class<?> loaded =
+                    layer.findLoader(entry.getKey()).loadClass(entry.getValue().getName());
+            assertEquals(entry.getKey(), loaded.getModule().getName());
+            assertEquals(layer, loaded.getModule().getLayer());
+            loaded.getDeclaredConstructors();
+        }
+
+        Class<?> supplier =
+                layer.findLoader("io.modelcontextprotocol.sdk.mcp.core")
+                        .loadClass("io.modelcontextprotocol.json.McpJsonMapperSupplier");
+        var providers = ServiceLoader.load(layer, supplier).stream().toList();
+        assertEquals(1, providers.size());
+        assertEquals(
+                "io.modelcontextprotocol.sdk.mcp.json.jackson2",
+                providers.getFirst().get().getClass().getModule().getName());
+        Class<?> channelProvider =
+                layer.findLoader("io.grpc").loadClass("io.grpc.ManagedChannelProvider");
+        assertEquals(0, ServiceLoader.load(layer, channelProvider).stream().count());
+    }
+}
diff --git a/readme.md b/readme.md
index 5cf0017ef9..1d4555f414 100644
--- a/readme.md
+++ b/readme.md
@@ -15,10 +15,13 @@ Restlet applications run directly in JVMs with minimal dependencies, resulting i
 ## R0 SDK interoperability probes
 
 The MCP and gRPC interoperability spikes are **test-only**, not production RPC extensions.
+R0 is a feasibility/decision phase, not delivery of all features in R1-R6. Its outcome is
+to proceed with narrowly scoped SDK integrations and defer unsupported profiles/features,
+not to promote these fixtures into production adapters.
 Run the focused suite from the repository root:
 
 ```powershell
-.\mvnw.cmd -pl org.restlet '-Dtest=GrpcSdkTransportSpikeTestCase,McpSdkTransportSpikeTestCase,McpStreamableSdkTransportSpikeTestCase' test
+.\mvnw.cmd -pl org.restlet '-Dtest=GrpcSdkTransportSpikeTestCase,GrpcSdkServerHostSpikeTestCase,RpcSdkBoundaryTestCase,McpSdkTransportSpikeTestCase,McpStreamableSdkTransportSpikeTestCase' test
 ```
 
 The MCP suite compares a 20-request corpus with
@@ -74,8 +77,85 @@ request stream remains open. The client observes `CANCELLED` once, the remote SD
 handler runs once, both bridge I/O workers finish, and a subsequent unary call succeeds on the same
 channel. The client bridge records cancellation before aborting HTTP I/O so an abort failure cannot
 replace the cancellation status. A separate regression verifies that closing demand wakes a blocked
-receiver and does not reopen on later credits. Pre-header cancellation races, server-initiated
-cancellation, and long-lived stream lifecycle remain outside this bounded probe.
+receiver and does not reopen on later credits. Additional probes cancel before response headers
+and shut down a channel with two active calls, checking remote cancellation, terminal callbacks,
+I/O completion and borrowed-connector ownership. Server-side completion is observed through
+`Response.onSent`, including cancellation before the response writer starts. Cancellation before
+HTTP request registration, server-initiated cancellation and long-lived stream lifecycle are
+not exhaustively covered.
+
+### SDK-owned server runtime and measured core fixes
+
+`GrpcSdkServerHostSpikeTestCase` separately hosts the real `ServerImplBuilder` runtime over
+Restlet, using `AbstractServerStream` for **SDK-owned framing and deframing**, dispatch,
+interceptors, status encoding and half-close. The official Netty client verifies unary success,
+client-streaming aggregation, a trailers-only SDK error with a percent/non-ASCII description,
+and SDK `UNIMPLEMENTED` dispatch for an unknown method. It verifies SDK/executor termination
+without stopping the borrowed Restlet server. No SDK listener is bound. This initial host
+buffers at most 1 MiB per direction and models each HTTP call as a logical SDK transport;
+it is not a connection-aware, streaming production host.
+
+The older bidirectional fixture still implements frames and directly invokes SDK handlers.
+It is useful transport/demand/cancellation evidence, **not** proof that the complete SDK
+server runtime supports full-duplex over the proposed production seam. In particular, neither
+fixture is a production fallback for SDK framing/flow control.
+
+The closing probes reproduced and fixed two protocol-neutral core gaps:
+
+- HTTP/2 clients previously peeked at the body before delivering headers. Multiplexed responses
+  now expose headers without waiting for data; HTTP/1.1 keeps its existing empty-body handling.
+  A regression withholds the first body byte until after the caller receives the headers.
+- Empty multiplexed server responses with no entity/trailers now end with their initial
+  HEADERS, rather than a later empty DATA frame. The native SDK client previously reported
+  `INTERNAL` instead of the trailers-only SDK error. The same test now preserves its exact
+  status and description. Responses with late trailers retain the existing streaming path.
+
+Both paths also serve HTTP/3, but native HTTP/3 validation remains platform-dependent.
+Late first trailers were already supported and have an existing core regression.
+
+### R0 supported-feature matrix and decisions
+
+| Area | Measured result | Decision / boundary |
+|---|---|---|
+| gRPC client internal SPI | Pinned `ManagedChannelImplBuilder` transport compiles and interoperates over Restlet HTTP/2 | Proceed with unary extension work; keep the version pinned |
+| gRPC SDK server host | Real SDK runtime, codecs, interceptors, unary, client half-close and trailers-only errors | Socket-less hosting is feasible; bounded buffering is not the production design |
+| gRPC metadata/status | Repeated ASCII, binary metadata and `grpc-status-details-bin`, empty success, errors after a delivered message, exactly one observed terminal callback, in both directions | Preserve native metadata/status; do not drop messages preceding errors |
+| gRPC demand/cancellation | Finite bidi exchange, receive-credit withholding, established/pre-header cancellation, active channel shutdown and worker completion | Bounded diagnostic evidence only; full SDK readiness, byte-budget and long-lived conformance remain R6 |
+| gRPC addressing | Exact origin authority reaches the SDK service; mismatched authorities and ordinary resolved socket addresses are rejected | No claim of TLS/SNI override, DNS/LB/subchannel or connection-aware integration |
+| gRPC connection controls | PING reports `UNIMPLEMENTED`; deadlines, compression and authority overrides throw explicitly in the prototype | Unsupported, not silently emulated; connection draining/GOAWAY/keepalive need a supported core seam |
+| MCP SDK-supported profiles | Stateless HTTP/2, Streamable initialize/POST SSE, bounded GET notifications/replay and official STDIO subprocess round-trip | Proceed with SDK-backed extension work; production STDIO mechanics and lifecycle belong to R1/R2 |
+| MCP Ikanos profile | 19/20 exact corpus responses; revision/session mismatch, null-ID SDK restriction and one parser diagnostic difference are explicit | **Do not migrate Ikanos** or advertise full profile equivalence; fixture compatibility code is not a second dispatcher |
+| MCP ownership | Client/server SDK closure leaves borrowed connectors started; Streamable DELETE removes session, replay history and listening state | Bounded ownership proof, not indefinite SSE/process lifecycle certification |
+| SDK module path | Actual named layer resolves Restlet, gRPC and MCP without `grpc-netty-shaded`; Jackson mapper service loads there; no default SDK gRPC channel provider remains | No production RPC dependency/module added; extension module/API delivery remains R1 |
+| Smithy | Not part of spikes A/B; `1.7.0` is still an unvalidated candidate | Pin and prototype client/server APIs in R5/R6 before accepting the proposed API shape |
+
+The pinned automatic module names are `io.grpc`, `io.grpc.internal`, `io.grpc.protobuf`,
+`io.grpc.stub`, `io.modelcontextprotocol.sdk.mcp.core` and
+`io.modelcontextprotocol.sdk.mcp.json.jackson2`. `RpcSdkBoundaryTestCase` checks the actual
+jar descriptors, loads SDK classes from the named layer and instantiates the MCP mapper supplier.
+This is not an extension module-path test: those modules do not exist yet.
+
+R0 authorizes the next **implementation phase**, not release or Ikanos migration. Keep independent
+protocol APIs, explicit connector ownership and finite limits; do not add a shared RPC layer or
+an SDK-owned HTTP engine. Generated gRPC stubs, SDK-owned streaming transports, complete HTTP
+validation, idle disconnect notification, connection policies, native-image behavior and production
+lifecycle remain delivery/conformance gates. Ikanos still targets Java 21 while this Restlet build
+requires Java 25, so runtime/build/container migration is a separate adoption prerequisite.
+No Ikanos source was copied into these new probes; existing attribution is retained.
+
+Delivery tracking: [MCP #1558](https://github.com/restlet/restlet-framework-java/issues/1558),
+[gRPC #1561](https://github.com/restlet/restlet-framework-java/issues/1561),
+[Smithy #1559](https://github.com/restlet/restlet-framework-java/issues/1559) and
+[core seams #1560](https://github.com/restlet/restlet-framework-java/issues/1560).
+Separate Ikanos adoption gates are
+[MCP #838](https://github.com/naftiko/ikanos/issues/838),
+[gRPC #837](https://github.com/naftiko/ikanos/issues/837) and
+[Smithy #839](https://github.com/naftiko/ikanos/issues/839).
+
+Closing validation on Java 25: the live-enabled SDK suite combined with
+`*Http*TestCase,*EventStream*TestCase` passed **107 tests, zero failures/errors/skips**.
+This includes native HTTP/3 tests on this host, TLS/HTTP transport selection, the STDIO
+subprocess and the actual Ikanos comparison. It is not a full-repository test run.
 
 To recheck the same corpus against the actual Ikanos endpoint, prepare an Ikanos checkout at the
 reference revision, then run the following PowerShell commands (adjust the checkout path):
@@ -85,7 +165,7 @@ $ikanos = (Resolve-Path '..\ikanos').Path
 $classpath = Join-Path (Get-Location) 'org.restlet\target\ikanos-classpath.txt'
 mvn -f "$ikanos\pom.xml" -pl modules\ikanos-engine -am compile
 mvn -f "$ikanos\pom.xml" -pl modules\ikanos-engine dependency:build-classpath "-Dmdep.outputFile=$classpath" -DincludeScope=test
-.\mvnw.cmd -pl org.restlet '-Dtest=GrpcSdkTransportSpikeTestCase,McpSdkTransportSpikeTestCase,McpStreamableSdkTransportSpikeTestCase' "-Drestlet.mcp.ikanos.home=$ikanos" "-Drestlet.mcp.ikanos.classpathFile=$classpath" test
+.\mvnw.cmd -pl org.restlet '-Dtest=GrpcSdkTransportSpikeTestCase,GrpcSdkServerHostSpikeTestCase,RpcSdkBoundaryTestCase,McpSdkTransportSpikeTestCase,McpStreamableSdkTransportSpikeTestCase' "-Drestlet.mcp.ikanos.home=$ikanos" "-Drestlet.mcp.ikanos.classpathFile=$classpath" test
 ```
 
 The opt-in test source-launches a separate JVM with Ikanos' classpath. It boots a real capability
@@ -95,9 +175,16 @@ prototype over Restlet HTTP/2; this compares MCP semantics, not transport implem
 The reference process is stopped after the test. Startup failures fail the test rather than
 falling back to recorded responses.
 
-Without the opt-in properties, twelve tests pass and the live comparison is skipped; with them,
-all thirteen run. Add `Http2FullDuplexTestCase,Http2CancellationTestCase` to the selector to include
-the two core connector regressions. Recorded and live reports are written separately under `org.restlet/target` as
+The SDK-focused selector contains twenty tests: eight transport gRPC cases, one native SDK-host
+case, one module-boundary case, seven MCP stateless/STDIO/profile cases and three MCP Streamable
+cases. Without opt-in properties the live comparison is skipped. Add
+`Http2FullDuplexTestCase,Http2CancellationTestCase,HttpTrailersTestCase,Http2TrailerHeadersTestCase`
+to include seven connector regression cases; add `*Http*TestCase,*EventStream*TestCase` instead for
+broader HTTP/TLS/SSE coverage. The official STDIO subprocess has a five-second initialization
+budget and has intermittently timed out in combined runs; an isolated pass does not turn a failed
+combined run into a clean one.
+
+Recorded and live reports are written separately under `org.restlet/target` as
 `mcp-ikanos-recorded.json` and `mcp-ikanos-differential.json`; reference-process logs are kept in
 per-run `mcp-ikanos-*` directories there. Review changed observations explicitly before updating
 the checked-in baseline. No Ikanos or additional production dependency is added to Restlet.

From 6f70567603e842fcd3d7a5888da19fd8abda4c09 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Fri, 30 Oct 2026 15:37:10 -0400
Subject: [PATCH 17/18] fix: keep delayed trailers of empty multiplexed
 responses

Defer the automatic release of a zero-length HTTP/2 or HTTP/3 response
entity until the response completes, so the stream is not reset before
its trailing HEADERS arrive.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../restlet/engine/netty/NettyClientCall.java | 34 +++++++++++
 .../connector/HttpTrailersTestCase.java       | 61 +++++++++++++++++++
 2 files changed, 95 insertions(+)

diff --git a/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java b/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java
index 074bcdeea3..e5b81846d5 100644
--- a/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java
+++ b/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java
@@ -155,6 +155,9 @@ class NettyClientCall {
     /** Indicates whether the channel was released. */
     private boolean released;
 
+    /** The empty multiplexed response entity to release once the response completes. */
+    private Representation pendingEmptyEntity;
+
     /**
      * Constructor.
      *
@@ -484,6 +487,12 @@ private void updateResponse(org.restlet.Response response, Status status) {
         response.setEntity(entity);
 
         if (entity != null && (entity.isEmpty() || !hasBody(response.getStatus()))) {
+            if (kind.isStream()
+                    && hasBody(response.getStatus())
+                    && deferEmptyEntityRelease(entity)) {
+                // Releasing now would reset the stream and lose any trailers still to come.
+                return;
+            }
             entity.release();
             if (Status.SUCCESS_RESET_CONTENT.equals(response.getStatus())
                     || response.getStatus().isInformational()) {
@@ -492,6 +501,25 @@ private void updateResponse(org.restlet.Response response, Status status) {
         }
     }
 
+    /**
+     * Defers the release of an empty multiplexed response entity until the response completes.
+     *
+     * @param entity The empty response entity.
+     * @return True if the release was deferred, false if the response is already complete.
+     */
+    private boolean deferEmptyEntityRelease(Representation entity) {
+        lock.lock();
+        try {
+            if (responseComplete) {
+                return false;
+            }
+            pendingEmptyEntity = entity;
+            return true;
+        } finally {
+            lock.unlock();
+        }
+    }
+
     /** Indicates whether a response with the given status to this request has a body. */
     private boolean hasBody(Status status) {
         return !Method.HEAD.getName().equals(method)
@@ -795,12 +823,18 @@ void onResponseComplete(io.netty.handler.codec.http.HttpHeaders trailers) {
         if (stream != null) {
             stream.end();
         }
+        Representation emptyEntity;
         lock.lock();
         try {
             responseComplete = true;
+            emptyEntity = pendingEmptyEntity;
+            pendingEmptyEntity = null;
         } finally {
             lock.unlock();
         }
+        if (emptyEntity != null) {
+            emptyEntity.release();
+        }
         maybeRelease();
     }
 
diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/HttpTrailersTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/HttpTrailersTestCase.java
index d3dbd8eba1..1a16093cea 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/HttpTrailersTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/HttpTrailersTestCase.java
@@ -9,10 +9,13 @@
 package org.restlet.engine.connector;
 
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import java.io.IOException;
 import java.io.OutputStream;
 import java.nio.charset.StandardCharsets;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.TimeUnit;
 import java.util.concurrent.atomic.AtomicReference;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeEach;
@@ -145,4 +148,62 @@ public void write(OutputStream output) throws IOException {
         assertEquals("firstsecond", response.getEntityAsText());
         assertEquals("late", response.getTrailers().getFirstValue(RESPONSE_TRAILER, true));
     }
+
+    @Test
+    void keepsDelayedHttp2TrailersOfAZeroLengthResponse() throws Exception {
+        CountDownLatch headFlushed = new CountDownLatch(1);
+        CountDownLatch sendTrailers = new CountDownLatch(1);
+        Restlet delayedTrailers =
+                new Restlet() {
+                    @Override
+                    public void handle(Request request, Response response) {
+                        OutputRepresentation entity =
+                                new OutputRepresentation(MediaType.APPLICATION_OCTET_STREAM) {
+                                    @Override
+                                    public void write(OutputStream output) throws IOException {
+                                        output.flush();
+                                        headFlushed.countDown();
+                                        try {
+                                            if (!sendTrailers.await(10, TimeUnit.SECONDS)) {
+                                                throw new IOException(
+                                                        "Timed out waiting to send trailers");
+                                            }
+                                        } catch (InterruptedException e) {
+                                            Thread.currentThread().interrupt();
+                                            throw new IOException(
+                                                    "Interrupted waiting to send trailers", e);
+                                        }
+                                        response.getTrailers().add(RESPONSE_TRAILER, "delayed");
+                                    }
+                                };
+                        entity.setSize(0);
+                        response.setEntity(entity);
+                    }
+                };
+        Context serverContext = new Context();
+        serverContext.getParameters().add("http.transport.protocol", "HTTP2");
+        server = new Server(serverContext, Protocol.HTTP, 0, delayedTrailers);
+        server.start();
+        Context clientContext = new Context();
+        clientContext.getParameters().add("httpClientTransportMode", "HTTP2");
+        client = new Client(clientContext, Protocol.HTTP);
+        client.start();
+
+        try {
+            Response response =
+                    client.handle(
+                            new Request(Method.GET, "http://localhost:" + server.getActualPort()));
+            assertTrue(headFlushed.await(5, TimeUnit.SECONDS));
+            assertEquals("0", response.getHeaders().getFirstValue("content-length", true));
+            sendTrailers.countDown();
+            long deadline = System.nanoTime() + TimeUnit.SECONDS.toNanos(5);
+            while (response.getTrailers().getFirstValue(RESPONSE_TRAILER, true) == null
+                    && System.nanoTime() < deadline) {
+                Thread.sleep(10);
+            }
+            assertEquals("delayed", response.getTrailers().getFirstValue(RESPONSE_TRAILER, true));
+        } finally {
+            sendTrailers.countDown();
+        }
+    }
 }

From 64fe93c5ba6f223b181a1e37e992eaa69137efb3 Mon Sep 17 00:00:00 2001
From: Jerome Louvel <374450+jlouvel@users.noreply.github.com>
Date: Fri, 30 Oct 2026 15:42:20 -0400
Subject: [PATCH 18/18] test: separate gRPC pre-header cancellation from active
 shutdown

Keep both calls active until channel shutdown, and await the I/O worker
completion of every call in both transport directions.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
---
 .../GrpcSdkTransportSpikeTestCase.java        | 246 +++++++++++-------
 1 file changed, 154 insertions(+), 92 deletions(-)

diff --git a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
index c03b2a31fc..442e734e96 100644
--- a/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -330,117 +330,171 @@ private void openInteropChannel(ServerServiceDefinition service, boolean restlet
 
     @ParameterizedTest
     @ValueSource(booleans = {false, true})
-    void cancelsBeforeHeadersAndShutsDownActiveCalls(boolean restletHosted) throws Exception {
-        CountDownLatch received = new CountDownLatch(2);
-        CountDownLatch cancelled = new CountDownLatch(2);
-        AtomicInteger cancellationCount = new AtomicInteger();
-        AtomicReference<Throwable> unexpectedError = new AtomicReference<>();
-        ServerServiceDefinition service =
-                ServerServiceDefinition.builder("restlet.r0.Echo")
-                        .addMethod(
-                                BIDI_STREAM_METHOD,
-                                ServerCalls.asyncBidiStreamingCall(
-                                        result -> {
-                                            if (!(result
-                                                    instanceof
-                                                    io.grpc.stub.ServerCallStreamObserver<?>
-                                                            observer)) {
-                                                throw new IllegalStateException(
-                                                        "The SDK did not supply a server call observer");
-                                            }
-                                            observer.setOnCancelHandler(
-                                                    () -> {
-                                                        cancellationCount.incrementAndGet();
-                                                        cancelled.countDown();
-                                                    });
-                                            return new io.grpc.stub.StreamObserver<StringValue>() {
-                                                @Override
-                                                public void onNext(StringValue value) {
-                                                    received.countDown();
-                                                }
+    void cancelsActiveCallBeforeHeaders(boolean restletHosted) throws Exception {
+        HoldingService holding = new HoldingService(1);
+        openInteropChannel(holding.definition(), restletHosted);
+        HeldCalls held = startHeldCalls(1);
+        assertTrue(holding.received.await(5, TimeUnit.SECONDS));
+        assertEquals(
+                0, held.headerCount.get(), "The SDK must not report headers before they are sent");
+        held.calls.getFirst().cancel("pre-header cancellation", null);
+        assertTrue(held.closed.await(5, TimeUnit.SECONDS));
+        assertTrue(holding.cancelled.await(5, TimeUnit.SECONDS));
+        assertEquals(List.of(Status.Code.CANCELLED), held.statuses);
+        assertEquals(1, holding.cancellationCount.get());
+        assertNull(holding.unexpectedError.get());
+        assertWorkersFinished(1);
+    }
 
-                                                @Override
-                                                public void onError(Throwable error) {
-                                                    if (Status.fromThrowable(error).getCode()
-                                                            != Status.Code.CANCELLED) {
-                                                        unexpectedError.set(error);
-                                                    }
-                                                }
+    @ParameterizedTest
+    @ValueSource(booleans = {false, true})
+    void shutsDownAllActiveCalls(boolean restletHosted) throws Exception {
+        HoldingService holding = new HoldingService(2);
+        openInteropChannel(holding.definition(), restletHosted);
+        HeldCalls held = startHeldCalls(2);
+        assertTrue(holding.received.await(5, TimeUnit.SECONDS));
+        assertEquals(
+                0, held.headerCount.get(), "The SDK must not report headers before they are sent");
+        channel.shutdownNow();
+        assertTrue(held.closed.await(5, TimeUnit.SECONDS));
+        assertTrue(holding.cancelled.await(5, TimeUnit.SECONDS));
+        assertTrue(channel.awaitTermination(5, TimeUnit.SECONDS));
+        assertEquals(2, held.statuses.size());
+        assertEquals(2, holding.cancellationCount.get());
+        assertNull(holding.unexpectedError.get());
+        assertTrue(
+                held.statuses.stream()
+                        .allMatch(
+                                status ->
+                                        status == Status.Code.CANCELLED
+                                                || status == Status.Code.UNAVAILABLE),
+                held.statuses.toString());
+        assertWorkersFinished(2);
+        if (interopFactory != null) {
+            assertTrue(interopFactory.scheduledExecutor.awaitTermination(5, TimeUnit.SECONDS));
+            assertTrue(client.isStarted());
+        } else {
+            assertTrue(restletServer.isStarted());
+        }
+    }
 
-                                                @Override
-                                                public void onCompleted() {
-                                                    result.onCompleted();
-                                                }
-                                            };
-                                        }))
-                        .build();
-        openInteropChannel(service, restletHosted);
-        List<ClientCall<StringValue, StringValue>> calls = new ArrayList<>();
-        CountDownLatch closed = new CountDownLatch(2);
-        AtomicInteger terminalCount = new AtomicInteger();
-        AtomicInteger headerCount = new AtomicInteger();
-        AtomicReference<Status.Code> explicitCancellation = new AtomicReference<>();
-        List<Status.Code> statuses = new java.util.concurrent.CopyOnWriteArrayList<>();
-        for (int i = 0; i < 2; i++) {
-            boolean cancelDirectly = i == 0;
+    /** Starts bidirectional calls that each send one message and wait for response headers. */
+    private HeldCalls startHeldCalls(int count) {
+        HeldCalls held = new HeldCalls(count);
+        for (int i = 0; i < count; i++) {
             var call = channel.newCall(BIDI_STREAM_METHOD, CallOptions.DEFAULT);
-            calls.add(call);
+            held.calls.add(call);
             call.start(
                     new ClientCall.Listener<>() {
                         @Override
                         public void onHeaders(Metadata headers) {
-                            headerCount.incrementAndGet();
+                            held.headerCount.incrementAndGet();
                         }
 
                         @Override
                         public void onClose(Status status, Metadata trailers) {
-                            if (cancelDirectly) {
-                                explicitCancellation.set(status.getCode());
-                            }
-                            statuses.add(status.getCode());
-                            terminalCount.incrementAndGet();
-                            closed.countDown();
+                            held.statuses.add(status.getCode());
+                            held.closed.countDown();
                         }
                     },
                     new Metadata());
             call.request(1);
             call.sendMessage(StringValue.of("hold-before-headers"));
         }
-        assertTrue(received.await(5, TimeUnit.SECONDS));
-        assertEquals(0, headerCount.get(), "The SDK must not report headers before they are sent");
-        calls.getFirst().cancel("pre-header cancellation", null);
-        channel.shutdownNow();
-        assertTrue(closed.await(5, TimeUnit.SECONDS));
-        assertTrue(cancelled.await(5, TimeUnit.SECONDS));
-        assertTrue(channel.awaitTermination(5, TimeUnit.SECONDS));
-        assertEquals(2, terminalCount.get());
-        assertEquals(2, cancellationCount.get());
-        assertEquals(Status.Code.CANCELLED, explicitCancellation.get());
-        assertNull(unexpectedError.get());
-        assertTrue(
-                statuses.stream()
-                        .allMatch(
-                                status ->
-                                        status == Status.Code.CANCELLED
-                                                || status == Status.Code.UNAVAILABLE),
-                statuses.toString());
+        return held;
+    }
+
+    /** Verifies that the I/O workers of every bidirectional call of the interop transport ended. */
+    private void assertWorkersFinished(int count) throws InterruptedException {
         if (interopFactory != null) {
-            assertTrue(
-                    interopFactory.transport.lastBidirectionalStream.responseReaderFinished.await(
-                            5, TimeUnit.SECONDS));
-            assertTrue(
-                    interopFactory.transport.lastBidirectionalStream.requestWriterFinished.await(
-                            5, TimeUnit.SECONDS));
-            assertTrue(interopFactory.scheduledExecutor.awaitTermination(5, TimeUnit.SECONDS));
-            assertTrue(client.isStarted());
+            List<RestletClientStream> streams = interopFactory.transport.bidirectionalStreams;
+            assertEquals(count, streams.size());
+            for (RestletClientStream stream : streams) {
+                assertTrue(stream.responseReaderFinished.await(5, TimeUnit.SECONDS));
+                assertTrue(stream.requestWriterFinished.await(5, TimeUnit.SECONDS));
+            }
         } else {
-            assertTrue(
-                    interopServer.lastBidirectionalCall.requestReaderFinished.await(
-                            5, TimeUnit.SECONDS));
-            assertTrue(
-                    interopServer.lastBidirectionalCall.responseWriterFinished.await(
-                            5, TimeUnit.SECONDS));
-            assertTrue(restletServer.isStarted());
+            List<SpikeServerCall<?, ?>> serverCalls = interopServer.bidirectionalCalls;
+            assertEquals(count, serverCalls.size());
+            for (SpikeServerCall<?, ?> serverCall : serverCalls) {
+                assertTrue(serverCall.requestReaderFinished.await(5, TimeUnit.SECONDS));
+                assertTrue(serverCall.responseWriterFinished.await(5, TimeUnit.SECONDS));
+            }
+        }
+    }
+
+    /** The client side of calls held open before their response headers. */
+    private static final class HeldCalls {
+
+        private final List<ClientCall<StringValue, StringValue>> calls = new ArrayList<>();
+
+        private final CountDownLatch closed;
+
+        private final AtomicInteger headerCount = new AtomicInteger();
+
+        private final List<Status.Code> statuses =
+                new java.util.concurrent.CopyOnWriteArrayList<>();
+
+        private HeldCalls(int count) {
+            this.closed = new CountDownLatch(count);
+        }
+    }
+
+    /** A bidirectional service that receives messages but never sends response headers. */
+    private static final class HoldingService {
+
+        private final CountDownLatch received;
+
+        private final CountDownLatch cancelled;
+
+        private final AtomicInteger cancellationCount = new AtomicInteger();
+
+        private final AtomicReference<Throwable> unexpectedError = new AtomicReference<>();
+
+        private HoldingService(int count) {
+            this.received = new CountDownLatch(count);
+            this.cancelled = new CountDownLatch(count);
+        }
+
+        private ServerServiceDefinition definition() {
+            return ServerServiceDefinition.builder("restlet.r0.Echo")
+                    .addMethod(
+                            BIDI_STREAM_METHOD,
+                            ServerCalls.asyncBidiStreamingCall(
+                                    result -> {
+                                        if (!(result
+                                                instanceof
+                                                io.grpc.stub.ServerCallStreamObserver<?>
+                                                        observer)) {
+                                            throw new IllegalStateException(
+                                                    "The SDK did not supply a server call observer");
+                                        }
+                                        observer.setOnCancelHandler(
+                                                () -> {
+                                                    cancellationCount.incrementAndGet();
+                                                    cancelled.countDown();
+                                                });
+                                        return new io.grpc.stub.StreamObserver<StringValue>() {
+                                            @Override
+                                            public void onNext(StringValue value) {
+                                                received.countDown();
+                                            }
+
+                                            @Override
+                                            public void onError(Throwable error) {
+                                                if (Status.fromThrowable(error).getCode()
+                                                        != Status.Code.CANCELLED) {
+                                                    unexpectedError.set(error);
+                                                }
+                                            }
+
+                                            @Override
+                                            public void onCompleted() {
+                                                result.onCompleted();
+                                            }
+                                        };
+                                    }))
+                    .build();
         }
     }
 
@@ -1038,6 +1092,9 @@ private static final class RestletGrpcServer extends org.restlet.Restlet {
 
         private volatile SpikeServerCall<?, ?> lastBidirectionalCall;
 
+        private final List<SpikeServerCall<?, ?>> bidirectionalCalls =
+                new java.util.concurrent.CopyOnWriteArrayList<>();
+
         private final java.util.concurrent.atomic.AtomicReference<String> lastRequestProtocol =
                 new java.util.concurrent.atomic.AtomicReference<>();
 
@@ -1095,6 +1152,7 @@ private <RequestT, ResponseT> void dispatchBidirectional(
             SpikeServerCall<RequestT, ResponseT> serverCall =
                     new SpikeServerCall<>(method, true, request.getHostRef().getAuthority());
             lastBidirectionalCall = serverCall;
+            bidirectionalCalls.add(serverCall);
             response.setOnSent(
                     (sentRequest, sentResponse) -> serverCall.responseWriterFinished.countDown());
             ServerCall.Listener<RequestT> listener =
@@ -1493,6 +1551,9 @@ private static final class RestletClientTransport implements ConnectionClientTra
 
         private volatile RestletClientStream lastBidirectionalStream;
 
+        private final List<RestletClientStream> bidirectionalStreams =
+                new java.util.concurrent.CopyOnWriteArrayList<>();
+
         private final Client client;
 
         private final RestletSocketAddress address;
@@ -1585,6 +1646,7 @@ public ClientStream newStream(
                             this::streamFinished);
             if (method.getType() == MethodDescriptor.MethodType.BIDI_STREAMING) {
                 lastBidirectionalStream = stream;
+                bidirectionalStreams.add(stream);
             }
             return stream;
         }