@@ -106,7 +106,7 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        module: [acp-core, acp-streamable-http-jetty]
+        module: [acp-core, acp-http-core]
 
     steps:
       - uses: actions/checkout@11d5960a326750d5838078e36cf38b85af677262 # v4
 
@@ -50,6 +50,36 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Added
 
+- **One framework-neutral ACP endpoint and a host contract: `acp-http-core`.** Every protocol rule
+  of the Streamable HTTP and WebSocket transports now lives in one place,
+  `com.agentclientprotocol.sdk.http.server.AcpHttpEndpoint`: routing, sessions, the bounded SSE
+  mailboxes and WebSocket send queue, the status and close-code table, the `Origin` check,
+  keep-alive and drain. A server adapter (a host) only adapts I/O through the contract types
+  `AcpHttpExchange`, `AcpHttpReply` (`Body`, `Empty`, `EventStream`), `SseFrame`, `AcpWsHandshake`,
+  `AcpWsOutbound` and `AcpWsHandler`, all `@UnstableAcpApi`: applications use the hosts the SDK
+  ships. The one neutral WebSocket connection replaces the Jetty-native one.
+- **WebSocket on the servlet, on the application's own server.** `StreamableHttpAcpServlet` (new
+  module `acp-http-servlet`, no Jetty dependency) upgrades `Upgrade: websocket` requests on its own
+  path through Jakarta WebSocket 2.1 (`ServerContainer.upgradeHttpToWebSocket`), on Tomcat, Jetty
+  and Undertow. A container without a Jakarta WebSocket implementation answers the upgrade 501.
+  Its outbound frames are serialized, one write at a time, as Tomcat requires.
+- **Spring Boot: ACP on `server.port`, under the application's security.** A servlet web
+  application now serves Streamable HTTP, SSE and WebSocket on its own server, through its filter
+  chain: Spring Security rules on `/acp` apply to HTTP and to the WebSocket handshake, and the
+  principal reaches the endpoint (`AcpHttpExchange.principal()`). The endpoint is an
+  `AcpHttpEndpoint` bean. With `server.compression.enabled`, `text/event-stream` is no longer
+  compressed.
+- **Shutdown drains open streams.** Closing the endpoint (servlet, listener, Spring's
+  `SmartLifecycle` before graceful shutdown) gives each open SSE stream a closing comment
+  (`: shutting down`) and completes it, and closes each WebSocket with 1001 (going away), so a
+  framework's graceful shutdown never waits for them.
+- **SSE responses carry `X-Accel-Buffering: no`**, so nginx and similar proxies do not buffer
+  them, besides `Cache-Control: no-cache`.
+- **A shared transport TCK in `acp-test`:** `com.agentclientprotocol.sdk.test.http.AcpHttpTransportTck`,
+  the suite every host runs (the servlet on Tomcat 11 and Jetty 12.1, the embedded listener, Spring
+  MVC), with `HttpProbes` for raw HTTP and WebSocket checks. `acp-test` now depends on
+  `junit-jupiter-api`, `assertj-core` and `acp-http-core`.
+
 - **`AcpTransportThreads` in `acp-integration`: the threads a framework's network transports run
   on.** `AcpClientTransports.create(settings, prefix, threads)` and
   `AcpListeners.listener(settings, factory, threads)` take one: `executor(Executor)` for the
@@ -472,6 +502,25 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ### Changed
 
+- **Breaking: the HTTP transport is split into three modules.** `acp-http-core` (the endpoint and
+  `StreamableHttpAcpAgentTransportOptions`), `acp-http-servlet` (`StreamableHttpAcpServlet`) and
+  `acp-streamable-http-jetty` (`StreamableHttpAcpAgentTransport`, now embedded Jetty running the
+  servlet with Jetty's Jakarta WebSocket implementation). Class names and packages of the public
+  types are unchanged. Migration: an application mounting the servlet in its own container, a
+  Spring MVC application included, depends on `acp-http-servlet` instead of
+  `acp-streamable-http-jetty`, and no longer gets Jetty; an application using the SDK's listener
+  keeps `acp-streamable-http-jetty`. Do not add `acp-streamable-http-jetty` to a Spring Boot
+  application on Tomcat: its Jakarta WebSocket 2.1 API jar would shadow Tomcat 11's 2.2 one.
+- **Breaking: `StreamableHttpAcpServlet` is a host of `AcpHttpEndpoint`.** It gained the
+  constructor `StreamableHttpAcpServlet(AcpHttpEndpoint)` and `endpoint()`; the package-private
+  routing, connection and SSE classes moved to `acp-http-core`. A subclass overriding `doGet`,
+  `doPost` or `doDelete` no longer intercepts anything: `service` hands every request to the
+  endpoint. Migration: wrap the `AcpHttpEndpoint` instead.
+- **Breaking: the shutdown close code of a WebSocket is 1001 (going away)**, not 1000. Clients
+  that treated 1000 as the server's shutdown treat 1001 the same way.
+- `AcpListeners.endpoint(AcpAgentSettings, AcpAgentFactory)` returns the endpoint for a framework
+  that mounts it itself.
+
 - **Breaking: new record components for the bind address and allowed origins.**
   `StreamableHttpAcpAgentTransportOptions` gained `host` and `allowedOrigins`,
   `AcpAgentSettings.Http` gained `allowedOrigins`, and `AcpAgentSettings.Listener` gained `host`
 
@@ -460,7 +460,8 @@ that authenticates in front. Browser requests whose `Origin` is not a loopback o
 | `com.agentclientprotocol.sdk.client` | Client SDK (`AcpClient`, `AcpAsyncClient`, `AcpSyncClient`) |
 | `com.agentclientprotocol.sdk.client.transport` | Client transports (`StdioAcpClientTransport`, `WebSocketAcpClientTransport`, `StreamableHttpAcpClientTransport`) |
 | `com.agentclientprotocol.sdk.agent` | Agent SDK (`AcpAgent`, `AcpAsyncAgent`, `AcpSyncAgent`, `AcpAgentFactory`) |
-| `com.agentclientprotocol.sdk.agent.transport` | Agent transports (`StdioAcpAgentTransport`; `StreamableHttpAcpAgentTransport` and `StreamableHttpAcpServlet` from acp-streamable-http-jetty) |
+| `com.agentclientprotocol.sdk.agent.transport` | Agent transports (`StdioAcpAgentTransport`; `StreamableHttpAcpServlet` from acp-http-servlet; `StreamableHttpAcpAgentTransport` from acp-streamable-http-jetty; `StreamableHttpAcpAgentTransportOptions` from acp-http-core) |
+| `com.agentclientprotocol.sdk.http.server` | The host contract from acp-http-core (`AcpHttpEndpoint`, `AcpHttpExchange`, `AcpHttpReply`, `AcpWsHandshake`), for writing a server adapter; unstable |
 | `com.agentclientprotocol.sdk.agent.support` | Annotation-based agent runtime (`AcpAgentSupport`), with its `resolver`, `handler`, `interceptor` and `invocation` extension points |
 | `com.agentclientprotocol.sdk.annotation` | Agent annotations (`@AcpAgent`, `@Prompt`, etc.) |
 | `com.agentclientprotocol.sdk.capabilities` | Capability negotiation (`NegotiatedCapabilities`) |
@@ -476,7 +477,9 @@ that authenticates in front. Browser requests whose `Origin` is not a loopback o
 | [`acp-core`](https://central.sonatype.com/artifact/com.agentclientprotocol/acp-core) | Client and Agent SDKs, stdio, WebSocket, and Streamable HTTP client transports; needs one JSON module |
 | `acp-json-jackson2` | JSON implementation on Jackson 2 (`JacksonAcpJsonMapper`); brought in by the transport and agent-support modules |
 | `acp-json-jackson3` | JSON implementation on Jackson 3 (`Jackson3AcpJsonMapper`) |
-| `acp-streamable-http-jetty` | Jetty-backed Streamable HTTP agent transport for listener-backed remote agents; also accepts WebSocket upgrades on the same path |
+| `acp-http-core` | The framework-neutral ACP endpoint behind every HTTP host: routing, sessions, SSE mailboxes, the status and close-code table, the `Origin` check and shutdown, and the host contract (`com.agentclientprotocol.sdk.http.server`) |
+| `acp-http-servlet` | The endpoint as a Servlet 6 servlet, `StreamableHttpAcpServlet`, with WebSocket upgrades on the same path through Jakarta WebSocket 2.1: Spring MVC, Tomcat, Jetty, Undertow |
+| `acp-streamable-http-jetty` | The SDK's own listener, `StreamableHttpAcpAgentTransport`: embedded Jetty 12.1 running the servlet, for agents served from a plain Java program |
 | [`acp-annotations`](https://central.sonatype.com/artifact/com.agentclientprotocol/acp-annotations) | `@AcpAgent`, `@Prompt`, and other annotations |
 | [`acp-agent-support`](https://central.sonatype.com/artifact/com.agentclientprotocol/acp-agent-support) | Annotation-based agent runtime |
 | [`acp-test`](https://central.sonatype.com/artifact/com.agentclientprotocol/acp-test) | In-memory transport and mock utilities for testing |
@@ -491,7 +494,7 @@ that authenticates in front. Browser requests whose `Origin` is not a loopback o
 | Stdio | `StdioAcpClientTransport` | `StdioAcpAgentTransport` | acp-core |
 | WebSocket | `WebSocketAcpClientTransport` | `StreamableHttpAcpAgentTransport` (upgrade on the same path) | acp-core / acp-streamable-http-jetty |
 | Streamable HTTP | `StreamableHttpAcpClientTransport` | `StreamableHttpAcpAgentTransport` | acp-core / acp-streamable-http-jetty |
-| Streamable HTTP in your own Servlet 6 container | `StreamableHttpAcpClientTransport` | `StreamableHttpAcpServlet` (HTTP/SSE only; the WebSocket upgrade needs `StreamableHttpAcpAgentTransport`) | acp-core / acp-streamable-http-jetty |
+| Streamable HTTP and WebSocket in your own Servlet 6 container | `StreamableHttpAcpClientTransport`, `WebSocketAcpClientTransport` | `StreamableHttpAcpServlet` (WebSocket where the container has Jakarta WebSocket 2.1) | acp-core / acp-http-servlet |
 
 ---
 
 
@@ -0,0 +1,89 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project xmlns="http://maven.apache.org/POM/4.0.0"
+         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
+    <modelVersion>4.0.0</modelVersion>
+
+    <parent>
+        <groupId>com.agentclientprotocol</groupId>
+        <artifactId>acp-java-sdk</artifactId>
+        <version>0.19.0-SNAPSHOT</version>
+    </parent>
+
+    <artifactId>acp-http-core</artifactId>
+    <packaging>jar</packaging>
+
+    <name>ACP HTTP Core</name>
+    <description>The framework-neutral ACP Streamable HTTP and WebSocket endpoint: routing, sessions, SSE mailboxes, the status and close-code table, the Origin check and shutdown, behind the host contract every server adapter implements</description>
+
+    <properties>
+        <!-- Coverage floors: measured line 83%, branch 67% (the TCK covers the rest from the host
+             modules), less 2 points (parent pom, JaCoCo) -->
+        <jacoco.minimum.line>0.81</jacoco.minimum.line>
+        <jacoco.minimum.branch>0.65</jacoco.minimum.branch>
+        <!-- JaCoCo's prepare-agent sets argLine; empty when JaCoCo is skipped. -->
+        <argLine/>
+    </properties>
+
+    <dependencies>
+        <dependency>
+            <groupId>org.jspecify</groupId>
+            <artifactId>jspecify</artifactId>
+        </dependency>
+        <dependency>
+            <groupId>com.agentclientprotocol</groupId>
+            <artifactId>acp-core</artifactId>
+        </dependency>
+        <!-- The JSON implementation: Jackson 2 by default. Add acp-json-jackson3 to use Jackson 3. -->
+        <dependency>
+            <groupId>com.agentclientprotocol</groupId>
+            <artifactId>acp-json-jackson2</artifactId>
+        </dependency>
+
+        <dependency>
+            <groupId>org.junit.jupiter</groupId>
+            <artifactId>junit-jupiter</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>com.tngtech.archunit</groupId>
+            <artifactId>archunit-junit5</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.assertj</groupId>
+            <artifactId>assertj-core</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>ch.qos.logback</groupId>
+            <artifactId>logback-classic</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.jetbrains.lincheck</groupId>
+            <artifactId>lincheck</artifactId>
+            <scope>test</scope>
+        </dependency>
+        <dependency>
+            <groupId>io.projectreactor</groupId>
+            <artifactId>reactor-test</artifactId>
+            <scope>test</scope>
+        </dependency>
+    </dependencies>
+
+    <build>
+        <plugins>
+            <!-- Lincheck (the *LincheckTest classes) attaches its instrumentation agent at
+                 runtime; see acp-core. @{argLine} keeps JaCoCo's agent. -->
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-surefire-plugin</artifactId>
+                <configuration>
+                    <argLine>@{argLine} -XX:+IgnoreUnrecognizedVMOptions -XX:+EnableDynamicAgentLoading</argLine>
+                </configuration>
+            </plugin>
+        </plugins>
+    </build>
+
+</project>
@@ -14,7 +14,10 @@
 
 /**
  * The limits and timings of an ACP Streamable HTTP and WebSocket endpoint, for
- * {@link StreamableHttpAcpAgentTransport} and {@link StreamableHttpAcpServlet} alike. Every
+ * every host of the endpoint alike: the SDK's listener ({@code StreamableHttpAcpAgentTransport},
+ * module {@code acp-streamable-http-jetty}), its servlet ({@code StreamableHttpAcpServlet},
+ * module {@code acp-http-servlet}) and the framework integrations, all of which serve
+ * {@link com.agentclientprotocol.sdk.http.server.AcpHttpEndpoint}. Every
  * buffer the endpoint keeps for a client is bounded by one of these, so a slow or hostile
  * client cannot make the agent's memory grow without bound. Pass one to the listener's or the
  * servlet's constructor when a default does not fit; start from {@link #builder()}, or use
@@ -46,9 +49,8 @@
  * open at once, each open SSE stream holding one; applied by the listener only, since a
  * servlet container configures its own HTTP/2; default 1024
  * @param shutdownTimeout how long closing the endpoint
- * ({@link StreamableHttpAcpServlet#closeGracefully()},
- * {@link StreamableHttpAcpAgentTransport#closeGracefully()} and
- * {@link StreamableHttpAcpServlet#destroy()}) waits for its connections'
+ * ({@code closeGracefully()} of the endpoint, the servlet and the listener, and the servlet's
+ * {@code destroy()}) waits for its connections'
  * agents to close before it closes the rest at once; closing never waits for a client, since
  * the SSE responses are completed, not drained; default 5 seconds
  * @param executor the application's executor that the listener's Jetty server runs its tasks
 
@@ -0,0 +1,17 @@
+/*
+ * Copyright 2025-2026 the original author or authors.
+ */
+
+/**
+ * The options of the ACP Streamable HTTP and WebSocket endpoint (acp-http-core); this module's
+ * part of the package shared with acp-core, acp-http-servlet and acp-streamable-http-jetty.
+ *
+ * <p>
+ * The package is null-marked: every type is non-null unless annotated
+ * {@link org.jspecify.annotations.Nullable @Nullable}.
+ * </p>
+ */
+@NullMarked
+package com.agentclientprotocol.sdk.agent.transport;
+
+import org.jspecify.annotations.NullMarked;
@@ -0,0 +1,109 @@
+/*
+ * Copyright 2025-2026 the original author or authors.
+ */
+
+package com.agentclientprotocol.sdk.http.server;
+
+import java.util.function.Consumer;
+
+import com.agentclientprotocol.sdk.agent.AcpAgentFactory;
+import com.agentclientprotocol.sdk.agent.transport.StreamableHttpAcpAgentTransportOptions;
+import com.agentclientprotocol.sdk.annotation.UnstableAcpApi;
+import com.agentclientprotocol.sdk.json.AcpJsonMapper;
+import reactor.core.publisher.Mono;
+
+/**
+ * The ACP Streamable HTTP and WebSocket endpoint, independent of any server: one per mounted
+ * path, holding every client connection on it and creating one agent per connection with an
+ * {@link AcpAgentFactory}. A host (a servlet, a framework's router) mounts it and adapts I/O;
+ * every protocol rule is here.
+ *
+ * <p>A host:
+ * <ul>
+ * <li>hands every request on the path to {@link #handle}, or a WebSocket upgrade request
+ * ({@link AcpHttpExchange#isWebSocketUpgrade()}) to {@link #webSocketHandshake}, and writes the
+ * answer as it is;</li>
+ * <li>calls {@link #start()} when its server starts serving the path, and
+ * {@link #closeGracefully()} <em>before</em> its server's own graceful shutdown, since open SSE
+ * streams and WebSockets never finish by themselves;</li>
+ * <li>never blocks an I/O thread on the endpoint: {@link #handle} returns a {@link Mono} and
+ * the agent's work runs on the SDK's schedulers.</li>
+ * </ul>
+ *
+ * <p>The endpoint answers 403 to a request whose {@code Origin} is neither a loopback origin nor
+ * listed in {@link StreamableHttpAcpAgentTransportOptions#allowedOrigins()}, over HTTP and on the
+ * handshake. It has no authentication: the host's framework security protects the path, and
+ * hands the principal over in {@link AcpHttpExchange#principal()}.
+ *
+ * @author Mark Pollack
+ */
+@UnstableAcpApi
+public interface AcpHttpEndpoint {
+
+	/**
+	 * Creates an endpoint.
+	 * @param jsonMapper the mapper that reads and writes the messages
+	 * @param agentFactory creates the agent for each connection
+	 * @param options the endpoint's limits, timings and allowed origins
+	 * @return the endpoint, not started
+	 * @throws IllegalArgumentException if an argument is null
+	 */
+	static AcpHttpEndpoint create(AcpJsonMapper jsonMapper, AcpAgentFactory agentFactory,
+			StreamableHttpAcpAgentTransportOptions options) {
+		return new DefaultAcpHttpEndpoint(jsonMapper, agentFactory, options);
+	}
+
+	/**
+	 * Returns the options the endpoint was created with; a host applies the ones that concern
+	 * its server, such as the inbound size limit.
+	 * @return the options
+	 */
+	StreamableHttpAcpAgentTransportOptions options();
+
+	/**
+	 * Answers one HTTP request: a POST carrying a JSON-RPC message, a GET opening an SSE stream,
+	 * or a DELETE closing a connection. The returned Mono never errors: every refusal, and any
+	 * unexpected failure (500), is a reply.
+	 * @param exchange the request
+	 * @return the reply to write
+	 */
+	Mono<AcpHttpReply> handle(AcpHttpExchange exchange);
+
+	/**
+	 * Decides a WebSocket upgrade request: refused (with the reply to write) or accepted.
+	 * @param handshake the upgrade request
+	 * @return the decision
+	 */
+	AcpWsHandshake webSocketHandshake(AcpHttpExchange handshake);
+
+	/**
+	 * Starts the SSE keep-alive. Idempotent; the endpoint serves requests without it too.
+	 */
+	void start();
+
+	/**
+	 * Closes every connection: new connections are refused (503), an {@code initialize} still in
+	 * flight is answered 503, open SSE streams get a closing comment and complete, WebSockets are
+	 * closed with 1001 (going away), and each connection's agent is closed, cancelling in-flight
+	 * prompts. Nothing waits for a client. A connection whose agent has not closed within the
+	 * {@linkplain StreamableHttpAcpAgentTransportOptions#shutdownTimeout() shutdown timeout} is
+	 * closed at once. Only the first call has an effect.
+	 * @return a Mono that completes when every connection has closed
+	 */
+	Mono<Void> closeGracefully();
+
+	/**
+	 * Returns the number of open connections, HTTP and WebSocket, not counting those whose
+	 * {@code initialize} is still being answered.
+	 * @return the connection count
+	 */
+	int activeConnectionCount();
+
+	/**
+	 * Sets the handler for the transport errors of every connection, including those opened
+	 * before the call. The default logs them.
+	 * @param handler receives the connections' transport errors
+	 */
+	void setExceptionHandler(Consumer<Throwable> handler);
+
+}