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/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/main/java/org/restlet/engine/netty/NettyClientCall.java b/org.restlet/src/main/java/org/restlet/engine/netty/NettyClientCall.java
index 09d9afc98c..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)
@@ -517,7 +545,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);
@@ -791,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/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
new file mode 100644
index 0000000000..442e734e96
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/GrpcSdkTransportSpikeTestCase.java
@@ -0,0 +1,2331 @@
+/**
+ * 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.assertNull;
+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.ChannelLogger;
+import io.grpc.ClientCall;
+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.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;
+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.LinkedBlockingQueue;
+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.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+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.representation.OutputRepresentation;
+import org.restlet.util.Series;
+
+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 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 =
+            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 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 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 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 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;
+
+    private ManagedChannel grpcClientChannel;
+
+    private Server restletServer;
+
+    private ManagedChannel channel;
+
+    private final AtomicReference<Protocol> lastGrpcResponseProtocol = new AtomicReference<>();
+
+    private final CountDownLatch remoteCancellation = new CountDownLatch(1);
+
+    private final AtomicInteger remoteCancellationCount = new AtomicInteger();
+
+    private RestletTransportFactory interopFactory;
+
+    private RestletGrpcServer interopServer;
+
+    @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 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 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);
+    }
+
+    @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());
+        }
+    }
+
+    /** 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);
+            held.calls.add(call);
+            call.start(
+                    new ClientCall.Listener<>() {
+                        @Override
+                        public void onHeaders(Metadata headers) {
+                            held.headerCount.incrementAndGet();
+                        }
+
+                        @Override
+                        public void onClose(Status status, Metadata trailers) {
+                            held.statuses.add(status.getCode());
+                            held.closed.countDown();
+                        }
+                    },
+                    new Metadata());
+            call.request(1);
+            call.sendMessage(StringValue.of("hold-before-headers"));
+        }
+        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) {
+            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 {
+            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();
+        }
+    }
+
+    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 =
+                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();
+                                            }
+                                        }))
+                        .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());
+                                                        }
+                                                    });
+                                        }))
+                        .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();
+                                                    }
+                                                }))
+                        .addMethod(
+                                BIDI_STREAM_METHOD,
+                                ServerCalls.asyncBidiStreamingCall(this::echoBidirectional))
+                        .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(),
+                failure.getStatus().toString());
+        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());
+
+        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
+    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();
+                                            }
+                                        }))
+                        .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();
+                                        }))
+                        .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();
+                                                    }
+                                                }))
+                        .addMethod(
+                                BIDI_STREAM_METHOD,
+                                ServerCalls.asyncBidiStreamingCall(this::echoBidirectional))
+                        .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());
+        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());
+
+        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 {
+        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 void assertFullDuplexBidirectionalStreaming(ManagedChannel channel)
+            throws InterruptedException {
+        CountDownLatch closed = new CountDownLatch(1);
+        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),
+                        new io.grpc.stub.StreamObserver<>() {
+                            @Override
+                            public void onNext(StringValue value) {
+                                responses.add(value.getValue());
+                                if (responseCount.incrementAndGet() == 1) {
+                                    firstResponse.countDown();
+                                } else {
+                                    secondResponse.countDown();
+                                }
+                            }
+
+                            @Override
+                            public void onError(Throwable error) {
+                                failure.set(error);
+                                closed.countDown();
+                            }
+
+                            @Override
+                            public void onCompleted() {
+                                closed.countDown();
+                            }
+                        });
+        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) {
+            throw new AssertionError("gRPC bidirectional streaming request failed", failure.get());
+        }
+        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;
+
+        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<>();
+
+        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;
+                }
+
+                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);
+                }
+                if (frames.length > MAX_STREAM_BYTES) {
+                    throw new IOException(
+                            "gRPC request stream exceeds " + MAX_STREAM_BYTES + " bytes");
+                }
+                dispatch(definition, request, response, unframeMessages(frames, MAX_MESSAGE_BYTES));
+            } catch (Exception e) {
+                setGrpcStatus(response, Status.fromThrowable(e));
+            }
+        }
+
+        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, request.getHostRef().getAuthority());
+            lastBidirectionalCall = serverCall;
+            bidirectionalCalls.add(serverCall);
+            response.setOnSent(
+                    (sentRequest, sentResponse) -> serverCall.responseWriterFinished.countDown());
+            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 (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(
+                                            "gRPC request stream exceeds "
+                                                    + MAX_STREAM_BYTES
+                                                    + " bytes");
+                                }
+                                listener.onMessage(
+                                        method.parseRequest(new ByteArrayInputStream(payload)));
+                            }
+                            listener.onHalfClose();
+                        } catch (Exception e) {
+                            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);
+                        }
+                    });
+        }
+
+        private <RequestT, ResponseT> void dispatch(
+                ServerMethodDefinition<RequestT, ResponseT> definition,
+                Request request,
+                Response response,
+                List<byte[]> payloads)
+                throws IOException {
+            MethodDescriptor<RequestT, ResponseT> method = definition.getMethodDescriptor();
+            Metadata requestHeaders = readMetadata(request.getHeaders());
+            SpikeServerCall<RequestT, ResponseT> serverCall =
+                    new SpikeServerCall<>(method, false, request.getHostRef().getAuthority());
+            ServerCall.Listener<RequestT> listener =
+                    definition.getServerCallHandler().startCall(serverCall, requestHeaders);
+            if (listener == null) {
+                throw new IOException("gRPC SDK returned no call listener");
+            }
+            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");
+            }
+            serverCall.writeResponse(response);
+        }
+    }
+
+    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 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;
+
+        private final String authority;
+
+        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
+        public void request(int numMessages) {
+            requestDemand.request(numMessages);
+        }
+
+        @Override
+        public void sendHeaders(Metadata headers) {
+            responseHeaders.merge(headers);
+        }
+
+        @Override
+        public void sendMessage(ResponseT 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 synchronized void close(Status status, Metadata trailers) {
+            if (closed.getCount() == 0) {
+                return;
+            }
+            this.status = status;
+            this.trailers = trailers;
+            requestDemand.close();
+            closed.countDown();
+        }
+
+        @Override
+        public boolean isCancelled() {
+            return cancelled;
+        }
+
+        @Override
+        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 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");
+                trailers = new Metadata();
+            }
+            response.setStatus(org.restlet.data.Status.SUCCESS_OK);
+            writeMetadata(responseHeaders, response.getHeaders());
+            if (!responseMessages.isEmpty()) {
+                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(framedMessages.toByteArray(), 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 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) {
+        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 MessageDemand {
+
+        private final CountDownLatch waiting = new CountDownLatch(1);
+
+        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 {
+                    waiting.countDown();
+                    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;
+
+        private final String target;
+
+        private RestletSocketAddress(String target) {
+            this.target = target;
+        }
+    }
+
+    private static final class RestletTransportFactory implements ClientTransportFactory {
+
+        private volatile RestletClientTransport transport;
+
+        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);
+            }
+            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);
+            return transport;
+        }
+
+        @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 volatile RestletClientStream lastBidirectionalStream;
+
+        private final List<RestletClientStream> bidirectionalStreams =
+                new java.util.concurrent.CopyOnWriteArrayList<>();
+
+        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 Set<RestletClientStream> streams =
+                java.util.concurrent.ConcurrentHashMap.newKeySet();
+
+        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);
+            for (RestletClientStream stream : Set.copyOf(streams)) {
+                stream.cancel(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
+                    && method.getType() != MethodDescriptor.MethodType.SERVER_STREAMING
+                    && method.getType() != MethodDescriptor.MethodType.CLIENT_STREAMING
+                    && method.getType() != MethodDescriptor.MethodType.BIDI_STREAMING) {
+                throw new UnsupportedOperationException(
+                        "Unsupported gRPC method type: " + method.getType());
+            }
+            if (callOptions.getCredentials() != null || callOptions.getCompressor() != null) {
+                throw new UnsupportedOperationException(
+                        "R0 SPI probe does not support call credentials or compression");
+            }
+            RestletClientStream stream =
+                    new RestletClientStream(
+                            client,
+                            address,
+                            authority,
+                            method,
+                            headers,
+                            lastResponseProtocol,
+                            this::streamStarted,
+                            this::streamFinished);
+            if (method.getType() == MethodDescriptor.MethodType.BIDI_STREAMING) {
+                lastBidirectionalStream = stream;
+                bidirectionalStreams.add(stream);
+            }
+            return stream;
+        }
+
+        @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 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 synchronized void streamFinished(RestletClientStream stream) {
+            streams.remove(stream);
+            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 java.util.function.Consumer<RestletClientStream> onStart;
+
+        private final java.util.function.Consumer<RestletClientStream> onClose;
+
+        private volatile ClientStreamListener listener;
+
+        private volatile Request activeRequest;
+
+        private final List<byte[]> requestPayloads = new ArrayList<>();
+
+        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;
+
+        private int requestStreamBytes;
+
+        private int maxInboundMessageSize = MAX_MESSAGE_BYTES;
+
+        private int maxOutboundMessageSize = MAX_MESSAGE_BYTES;
+
+        private volatile boolean closed;
+
+        private RestletClientStream(
+                Client client,
+                RestletSocketAddress address,
+                String authority,
+                MethodDescriptor<?, ?> method,
+                Metadata requestMetadata,
+                AtomicReference<Protocol> lastResponseProtocol,
+                java.util.function.Consumer<RestletClientStream> onStart,
+                java.util.function.Consumer<RestletClientStream> 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.accept(this);
+            if (closed) {
+                return;
+            }
+            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();
+        }
+
+        @Override
+        public void request(int numMessages) {
+            if (numMessages <= 0) {
+                throw new IllegalArgumentException("numMessages must be positive");
+            }
+            responseDemand.request(numMessages);
+        }
+
+        @Override
+        public void cancel(Status 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) {
+                    throw new IllegalStateException(
+                            "Unable to close cancelled gRPC request pipe", e);
+                }
+            }
+        }
+
+        @Override
+        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");
+            }
+            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;
+            }
+            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 {
+                                try {
+                                    byte[] payload;
+                                    while ((payload =
+                                                    readGrpcMessage(
+                                                            bidirectionalRequestInput,
+                                                            maxOutboundMessageSize))
+                                            != null) {
+                                        output.write(frame(payload));
+                                        output.flush();
+                                    }
+                                } finally {
+                                    requestWriterFinished.countDown();
+                                }
+                            }
+                        };
+                Request request =
+                        new Request(
+                                Method.POST,
+                                address.target + "/" + method.getFullMethodName(),
+                                requestEntity);
+                activeRequest = request;
+                if (closed) {
+                    return;
+                }
+                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 (true) {
+                            payload = readGrpcMessage(input, maxInboundMessageSize);
+                            if (payload == null) {
+                                break;
+                            }
+                            if (!responseDemand.acquire()) {
+                                return;
+                            }
+                            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();
+                }
+                responseReaderFinished.countDown();
+            }
+        }
+
+        @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(
+                        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(
+                                        framedRequest.toByteArray(), 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(MAX_STREAM_BYTES + 1);
+                            if (framedResponse.length > MAX_STREAM_BYTES) {
+                                throw new IOException(
+                                        "gRPC response stream exceeds "
+                                                + MAX_STREAM_BYTES
+                                                + " bytes");
+                            }
+                            responsePayload = framedResponse;
+                        }
+                    }
+                }
+                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.getHeaders().getFirstValue("grpc-status", true) != null) {
+                    trailers.merge(readMetadata(response.getHeaders()));
+                } else {
+                    listener.headersRead(readMetadata(response.getHeaders()));
+                }
+                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++));
+                                }
+                            });
+                }
+                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;
+                responseDemand.close();
+                try {
+                    listener.closed(status, progress, trailers);
+                } finally {
+                    onClose.accept(this);
+                }
+            }
+        }
+
+        @Override
+        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() {
+            return !closed;
+        }
+
+        @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 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<>();
+        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-") && !"grpc-status-details-bin".equals(name)) {
+                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-") && !"grpc-status-details-bin".equals(name))) {
+                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/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/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();
+        }
+    }
 }
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
new file mode 100644
index 0000000000..490875f9be
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpSdkTransportSpikeTestCase.java
@@ -0,0 +1,824 @@
+/**
+ * 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.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;
+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;
+import io.modelcontextprotocol.json.TypeRef;
+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.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;
+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;
+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.data.Status;
+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 McpAsyncClient stdioClient;
+
+    private Server server;
+
+    private final AtomicInteger toolCalls = new AtomicInteger();
+
+    @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 (stdioClient != null) {
+            stdioClient.close();
+        }
+        if (sdkClient != null) {
+            sdkClient.close();
+        }
+        if (client != null) {
+            client.stop();
+        }
+        if (server != null) {
+            server.stop();
+        }
+        Engine.clearThreadLocalVariables();
+    }
+
+    private void startHttpServer(boolean ikanosProfile) throws Exception {
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
+        RestletHttpTransport transport = new RestletHttpTransport(mapper, ikanosProfile);
+        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) -> {
+                                    toolCalls.incrementAndGet();
+                                    return Mono.just(
+                                            McpSchema.CallToolResult.builder()
+                                                    .isError(
+                                                            "fail"
+                                                                    .equals(
+                                                                            call.arguments()
+                                                                                    .get("text")))
+                                                    .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();
+    }
+
+    @Test
+    void dispatchesMcpSdkClientAndServerThroughRestletHttp2() throws Exception {
+        startHttpServer(false);
+        McpJsonMapper mapper = McpJsonDefaults.getMapper();
+        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());
+        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\"}}}";
+        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\""));
+        }
+        sdkServer.closeGracefully().block(REQUEST_TIMEOUT);
+        sdkServer = null;
+        assertTrue(client.isStarted());
+        assertTrue(server.isStarted());
+    }
+
+    @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 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);
+        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);
+        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();
+        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 {
+
+        private final McpJsonMapper jsonMapper;
+
+        private volatile McpStatelessServerHandler handler;
+
+        private final boolean ikanosProfile;
+
+        private RestletHttpTransport(McpJsonMapper jsonMapper, boolean ikanosProfile) {
+            this.jsonMapper = jsonMapper;
+            this.ikanosProfile = ikanosProfile;
+        }
+
+        @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) {
+            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;
+            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);
+                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;
+            }
+
+            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;
+                }
+                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) {
+                        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 =
+                            currentHandler
+                                    .handleRequest(McpTransportContext.EMPTY, rpcRequest)
+                                    .block(REQUEST_TIMEOUT);
+                    if (rpcResponse == null) {
+                        response.setStatus(org.restlet.data.Status.SERVER_ERROR_INTERNAL);
+                        return;
+                    }
+                    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);
+                } 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 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 = 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());
+            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"));
+            }
+            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 (supportedMethod && !"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 {
+
+        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();
+        }
+    }
+}
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();
+    }
+}
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..a4512abd8a
--- /dev/null
+++ b/org.restlet/src/test/java/org/restlet/engine/connector/McpStreamableSdkTransportSpikeTestCase.java
@@ -0,0 +1,892 @@
+/**
+ * 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.assertNull;
+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;
+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 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;
+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.OutputRepresentation;
+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 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;
+
+    private McpAsyncClient sdkClient;
+
+    private io.modelcontextprotocol.server.McpAsyncServer sdkServer;
+
+    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());
+        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
+    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());
+        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 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 {
+
+        private final McpJsonMapper jsonMapper;
+
+        private final Map<String, McpStreamableServerSession> sessions = new ConcurrentHashMap<>();
+
+        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) {
+            this.jsonMapper = jsonMapper;
+        }
+
+        @Override
+        public void setSessionFactory(McpStreamableServerSession.Factory sessionFactory) {
+            this.sessionFactory = sessionFactory;
+        }
+
+        @Override
+        public Mono<Void> notifyClients(String sessionId, Object notification) {
+            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);
+                                listeningTransports.values().forEach(ListeningSseTransport::close);
+                                listeningStreamReady.clear();
+                            })
+                    .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 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);
+                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 {
+                        writeEventStreamResponse(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;
+            }
+            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);
+        }
+
+        private void writeJsonResponse(Response response, McpSchema.JSONRPCMessage message)
+                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 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;
+
+        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 final AtomicReference<Boolean> sawEventStreamResponse =
+                new AtomicReference<>(false);
+
+        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");
+                        }
+                        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, payload);
+                        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();
+        }
+    }
+}
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/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..551df86017
--- /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","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","_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","_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","_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"}}},
+    "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":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":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,"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":-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":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":{"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":"GET not supported"},
+    "differences": []
+  },
+  "DELETE": {
+    "reference": {"status":405,"body":"DELETE not supported"},
+    "prototype": {"status":405,"body":"DELETE not supported"},
+    "differences": []
+  }
+}
diff --git a/readme.md b/readme.md
index 27a4ac6d06..1d4555f414 100644
--- a/readme.md
+++ b/readme.md
@@ -12,6 +12,183 @@ 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.
+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,GrpcSdkServerHostSpikeTestCase,RpcSdkBoundaryTestCase,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`, 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.
+
+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.
+
+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.
+
+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. 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.
+
+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. 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):
+
+```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,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
+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.
+
+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.
+
 ## Learn more
 
 To learn more about Restlet Framework, please have a look at the following resources: