Remove MCP SDK dependency, add own JSON abstraction layer

Replace mcp-json and mcp-json-jackson2 dependencies with ACP's own
JSON abstraction in com.agentclientprotocol.sdk.json:

- AcpJsonMapper interface (replaces McpJsonMapper)
- TypeRef<T> for generic type capture (replaces MCP TypeRef)
- JacksonAcpJsonMapper implementation
- ServiceLoader-based discovery via AcpJsonMapperSupplier SPI

This eliminates the version conflict reported in #3 where
McpJsonMapper.getDefault() was removed in MCP 0.18.0+, causing
NoSuchMethodError for projects using modern MCP versions.

Also updates README dependency versions from 0.9.0 to 0.11.0.

Author: Mark Pollack

README.md

@@ -30,7 +30,7 @@ Three API styles for building agents:
 <dependency>
     <groupId>com.agentclientprotocol</groupId>
     <artifactId>acp-core</artifactId>
-    <version>0.9.0</version>
+    <version>0.11.0</version>
 </dependency>
 ```
 
@@ -39,7 +39,7 @@ For annotation-based agent development:
 <dependency>
     <groupId>com.agentclientprotocol</groupId>
     <artifactId>acp-agent-support</artifactId>
-    <version>0.9.0</version>
+    <version>0.11.0</version>
 </dependency>
 ```
 
@@ -48,7 +48,7 @@ For WebSocket server support (agents accepting WebSocket connections):
 <dependency>
     <groupId>com.agentclientprotocol</groupId>
     <artifactId>acp-websocket-jetty</artifactId>
-    <version>0.9.0</version>
+    <version>0.11.0</version>
 </dependency>
 ```
 
@@ -327,7 +327,7 @@ import java.net.URI;
 
 var transport = new WebSocketAcpClientTransport(
     URI.create("ws://localhost:8080/acp"),
-    McpJsonMapper.getDefault()
+    AcpJsonMapper.createDefault()
 );
 AcpSyncClient client = AcpClient.sync(transport).build();
 ```
@@ -339,7 +339,7 @@ import com.agentclientprotocol.sdk.agent.transport.WebSocketAcpAgentTransport;
 var transport = new WebSocketAcpAgentTransport(
     8080,                           // port
     "/acp",                         // path
-    McpJsonMapper.getDefault()
+    AcpJsonMapper.createDefault()
 );
 AcpAsyncAgent agent = AcpAgent.async(transport)
     // ... handlers ...
@@ -443,13 +443,14 @@ This SDK is part of the [Agent Client Protocol](https://agentclientprotocol.com/
 
 ## Roadmap
 
-### v0.9.0 (Current — [Maven Central](https://central.sonatype.com/artifact/com.agentclientprotocol/acp-core))
+### v0.11.0 (Current — [Maven Central](https://central.sonatype.com/artifact/com.agentclientprotocol/acp-core))
 - Client and Agent SDKs with async/sync APIs
 - Stdio and WebSocket transports
 - Capability negotiation
 - Structured error handling
 - Full protocol compliance (all SessionUpdate types, MCP configs, `_meta` extensibility)
-- 258 tests
+- Own JSON abstraction layer (`AcpJsonMapper`) — no MCP SDK dependency
+- Pluggable JSON via `ServiceLoader` SPI
 
 ### v1.0.0 (Planned)
 - Production hardening

acp-core/pom.xml

@@ -23,16 +23,6 @@
             <artifactId>reactor-core</artifactId>
         </dependency>
 
-        <!-- MCP Java SDK JSON utilities (reused for ACP) -->
-        <dependency>
-            <groupId>io.modelcontextprotocol.sdk</groupId>
-            <artifactId>mcp-json</artifactId>
-        </dependency>
-        <dependency>
-            <groupId>io.modelcontextprotocol.sdk</groupId>
-            <artifactId>mcp-json-jackson2</artifactId>
-        </dependency>
-
         <!-- Jackson JSON processing -->
         <dependency>
             <groupId>com.fasterxml.jackson.core</groupId>

acp-core/src/main/java/com/agentclientprotocol/sdk/agent/DefaultAcpAsyncAgent.java

@@ -14,7 +14,7 @@
 import com.agentclientprotocol.sdk.spec.AcpAgentSession;
 import com.agentclientprotocol.sdk.spec.AcpAgentTransport;
 import com.agentclientprotocol.sdk.spec.AcpSchema;
-import io.modelcontextprotocol.json.TypeRef;
+import com.agentclientprotocol.sdk.json.TypeRef;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Mono;

acp-core/src/main/java/com/agentclientprotocol/sdk/agent/transport/StdioAcpAgentTransport.java

@@ -21,8 +21,8 @@
 import com.agentclientprotocol.sdk.spec.AcpSchema;
 import com.agentclientprotocol.sdk.spec.AcpSchema.JSONRPCMessage;
 import com.agentclientprotocol.sdk.util.Assert;
-import io.modelcontextprotocol.json.McpJsonMapper;
-import io.modelcontextprotocol.json.TypeRef;
+import com.agentclientprotocol.sdk.json.AcpJsonMapper;
+import com.agentclientprotocol.sdk.json.TypeRef;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Flux;
@@ -56,7 +56,7 @@ public class StdioAcpAgentTransport implements AcpAgentTransport {
 
 	private static final Logger logger = LoggerFactory.getLogger(StdioAcpAgentTransport.class);
 
-	private final McpJsonMapper jsonMapper;
+	private final AcpJsonMapper jsonMapper;
 
 	private final InputStream inputStream;
 
@@ -87,15 +87,15 @@ public class StdioAcpAgentTransport implements AcpAgentTransport {
 	 * System.in and System.out for communication.
 	 */
 	public StdioAcpAgentTransport() {
-		this(McpJsonMapper.getDefault());
+		this(AcpJsonMapper.createDefault());
 	}
 
 	/**
 	 * Creates a new StdioAcpAgentTransport with the specified JsonMapper using
 	 * System.in and System.out for communication.
 	 * @param jsonMapper The JsonMapper to use for JSON serialization/deserialization
 	 */
-	public StdioAcpAgentTransport(McpJsonMapper jsonMapper) {
+	public StdioAcpAgentTransport(AcpJsonMapper jsonMapper) {
 		this(jsonMapper, System.in, System.out);
 	}
 
@@ -106,7 +106,7 @@ public StdioAcpAgentTransport(McpJsonMapper jsonMapper) {
 	 * @param inputStream The input stream to read messages from (client → agent)
 	 * @param outputStream The output stream to write messages to (agent → client)
 	 */
-	public StdioAcpAgentTransport(McpJsonMapper jsonMapper, InputStream inputStream, OutputStream outputStream) {
+	public StdioAcpAgentTransport(AcpJsonMapper jsonMapper, InputStream inputStream, OutputStream outputStream) {
 		Assert.notNull(jsonMapper, "The JsonMapper can not be null");
 		Assert.notNull(inputStream, "The InputStream can not be null");
 		Assert.notNull(outputStream, "The OutputStream can not be null");

acp-core/src/main/java/com/agentclientprotocol/sdk/client/AcpAsyncClient.java

@@ -8,7 +8,7 @@
 
 import com.agentclientprotocol.sdk.capabilities.NegotiatedCapabilities;
 import com.agentclientprotocol.sdk.spec.AcpClientTransport;
-import io.modelcontextprotocol.json.TypeRef;
+import com.agentclientprotocol.sdk.json.TypeRef;
 import com.agentclientprotocol.sdk.spec.AcpSchema;
 import com.agentclientprotocol.sdk.spec.AcpSession;
 import com.agentclientprotocol.sdk.util.Assert;
@@ -53,7 +53,7 @@
  * AgentParameters params = AgentParameters.builder("gemini")
  *     .arg("--experimental-acp")
  *     .build();
- * StdioAcpClientTransport transport = new StdioAcpClientTransport(params, McpJsonMapper.getDefault());
+ * StdioAcpClientTransport transport = new StdioAcpClientTransport(params, AcpJsonMapper.createDefault());
  *
  * // Create client
  * AcpAsyncClient client = AcpClient.async(transport)

acp-core/src/main/java/com/agentclientprotocol/sdk/client/AcpClient.java

@@ -19,7 +19,7 @@
 import com.agentclientprotocol.sdk.spec.AcpSchema;
 import com.agentclientprotocol.sdk.spec.AcpSession;
 import com.agentclientprotocol.sdk.util.Assert;
-import io.modelcontextprotocol.json.TypeRef;
+import com.agentclientprotocol.sdk.json.TypeRef;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Mono;
@@ -58,7 +58,7 @@
  * AgentParameters params = AgentParameters.builder("gemini")
  *     .arg("--experimental-acp")
  *     .build();
- * StdioAcpClientTransport transport = new StdioAcpClientTransport(params, McpJsonMapper.getDefault());
+ * StdioAcpClientTransport transport = new StdioAcpClientTransport(params, AcpJsonMapper.createDefault());
  *
  * // Build client
  * AcpAsyncClient client = AcpClient.async(transport)
@@ -509,7 +509,7 @@ public AcpAsyncClient build() {
 			if (!sessionUpdateConsumers.isEmpty()) {
 				notificationHandlers.put(AcpSchema.METHOD_SESSION_UPDATE, params -> {
 					AcpSchema.SessionNotification notification = transport.unmarshalFrom(params,
-							new io.modelcontextprotocol.json.TypeRef<AcpSchema.SessionNotification>() {
+							new TypeRef<AcpSchema.SessionNotification>() {
 							});
 					logger.debug("Received session update for session: {}", notification.sessionId());
 
@@ -904,7 +904,7 @@ public AcpSyncClient build() {
 			if (!sessionUpdateConsumers.isEmpty()) {
 				notificationHandlers.put(AcpSchema.METHOD_SESSION_UPDATE, params -> {
 					AcpSchema.SessionNotification notification = transport.unmarshalFrom(params,
-							new io.modelcontextprotocol.json.TypeRef<AcpSchema.SessionNotification>() {
+							new TypeRef<AcpSchema.SessionNotification>() {
 							});
 					logger.debug("Received session update for session: {}", notification.sessionId());
 

acp-core/src/main/java/com/agentclientprotocol/sdk/client/transport/StdioAcpClientTransport.java

@@ -15,8 +15,8 @@
 import java.util.function.Consumer;
 import java.util.function.Function;
 
-import io.modelcontextprotocol.json.TypeRef;
-import io.modelcontextprotocol.json.McpJsonMapper;
+import com.agentclientprotocol.sdk.json.AcpJsonMapper;
+import com.agentclientprotocol.sdk.json.TypeRef;
 import com.agentclientprotocol.sdk.spec.AcpClientTransport;
 import com.agentclientprotocol.sdk.spec.AcpSchema;
 import com.agentclientprotocol.sdk.spec.AcpSchema.JSONRPCMessage;
@@ -58,7 +58,7 @@ public class StdioAcpClientTransport implements AcpClientTransport {
 	/** The agent process being communicated with */
 	private Process process;
 
-	private McpJsonMapper jsonMapper;
+	private AcpJsonMapper jsonMapper;
 
 	/** Scheduler for handling inbound messages from the agent process */
 	private Scheduler inboundScheduler;
@@ -84,15 +84,15 @@ public class StdioAcpClientTransport implements AcpClientTransport {
 	 * @param params The parameters for configuring the agent process
 	 */
 	public StdioAcpClientTransport(AgentParameters params) {
-		this(params, McpJsonMapper.getDefault());
+		this(params, AcpJsonMapper.createDefault());
 	}
 
 	/**
 	 * Creates a new StdioAcpClientTransport with the specified parameters and JsonMapper.
 	 * @param params The parameters for configuring the agent process
 	 * @param jsonMapper The JsonMapper to use for JSON serialization/deserialization
 	 */
-	public StdioAcpClientTransport(AgentParameters params, McpJsonMapper jsonMapper) {
+	public StdioAcpClientTransport(AgentParameters params, AcpJsonMapper jsonMapper) {
 		Assert.notNull(params, "The params can not be null");
 		Assert.notNull(jsonMapper, "The JsonMapper can not be null");
 

acp-core/src/main/java/com/agentclientprotocol/sdk/client/transport/WebSocketAcpClientTransport.java

@@ -19,8 +19,8 @@
 import com.agentclientprotocol.sdk.spec.AcpSchema;
 import com.agentclientprotocol.sdk.spec.AcpSchema.JSONRPCMessage;
 import com.agentclientprotocol.sdk.util.Assert;
-import io.modelcontextprotocol.json.McpJsonMapper;
-import io.modelcontextprotocol.json.TypeRef;
+import com.agentclientprotocol.sdk.json.AcpJsonMapper;
+import com.agentclientprotocol.sdk.json.TypeRef;
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import reactor.core.publisher.Mono;
@@ -56,7 +56,7 @@ public class WebSocketAcpClientTransport implements AcpClientTransport {
 
 	private final URI serverUri;
 
-	private final McpJsonMapper jsonMapper;
+	private final AcpJsonMapper jsonMapper;
 
 	private final HttpClient httpClient;
 
@@ -83,7 +83,7 @@ public class WebSocketAcpClientTransport implements AcpClientTransport {
 	 * @param serverUri The WebSocket URI to connect to (e.g., "ws://localhost:8080/acp")
 	 * @param jsonMapper The JsonMapper to use for JSON serialization/deserialization
 	 */
-	public WebSocketAcpClientTransport(URI serverUri, McpJsonMapper jsonMapper) {
+	public WebSocketAcpClientTransport(URI serverUri, AcpJsonMapper jsonMapper) {
 		this(serverUri, jsonMapper, HttpClient.newBuilder()
 			.executor(Executors.newCachedThreadPool(r -> {
 				Thread t = new Thread(r, "acp-ws-client");
@@ -99,7 +99,7 @@ public WebSocketAcpClientTransport(URI serverUri, McpJsonMapper jsonMapper) {
 	 * @param jsonMapper The JsonMapper to use for JSON serialization/deserialization
 	 * @param httpClient The HttpClient to use for WebSocket connections
 	 */
-	public WebSocketAcpClientTransport(URI serverUri, McpJsonMapper jsonMapper, HttpClient httpClient) {
+	public WebSocketAcpClientTransport(URI serverUri, AcpJsonMapper jsonMapper, HttpClient httpClient) {
 		Assert.notNull(serverUri, "The serverUri can not be null");
 		Assert.notNull(jsonMapper, "The JsonMapper can not be null");
 		Assert.notNull(httpClient, "The HttpClient can not be null");

acp-core/src/main/java/com/agentclientprotocol/sdk/json/AcpJsonMapper.java

@@ -0,0 +1,118 @@
+/*
+ * Copyright 2025-2025 the original author or authors.
+ */
+
+package com.agentclientprotocol.sdk.json;
+
+import java.io.IOException;
+import java.util.ServiceLoader;
+
+/**
+ * Abstraction for JSON serialization/deserialization to decouple the SDK from any
+ * specific JSON library.
+ *
+ * <p>
+ * A default implementation is discovered at runtime via {@link ServiceLoader} using the
+ * {@link AcpJsonMapperSupplier} SPI. The built-in Jackson-based implementation is
+ * registered automatically.
+ * </p>
+ *
+ * <p>
+ * Alternative implementations (e.g., for Micronaut serialization) can be provided by
+ * implementing {@link AcpJsonMapperSupplier} and registering it in
+ * {@code META-INF/services/com.agentclientprotocol.sdk.json.AcpJsonMapperSupplier}.
+ * </p>
+ *
+ * @author Mark Pollack
+ */
+public interface AcpJsonMapper {
+
+	/**
+	 * Creates a default AcpJsonMapper by discovering an {@link AcpJsonMapperSupplier}
+	 * via {@link ServiceLoader}. The first available supplier on the classpath is used.
+	 * @return a new AcpJsonMapper instance
+	 * @throws java.util.ServiceConfigurationError if no supplier is found
+	 */
+	static AcpJsonMapper createDefault() {
+		return ServiceLoader.load(AcpJsonMapperSupplier.class)
+			.findFirst()
+			.orElseThrow(() -> new java.util.ServiceConfigurationError(
+					"No AcpJsonMapperSupplier found on the classpath"))
+			.get();
+	}
+
+	/**
+	 * Deserialize JSON string into a target type.
+	 * @param content JSON as String
+	 * @param type target class
+	 * @return deserialized instance
+	 * @param <T> generic type
+	 * @throws IOException on parse errors
+	 */
+	<T> T readValue(String content, Class<T> type) throws IOException;
+
+	/**
+	 * Deserialize JSON bytes into a target type.
+	 * @param content JSON as bytes
+	 * @param type target class
+	 * @return deserialized instance
+	 * @param <T> generic type
+	 * @throws IOException on parse errors
+	 */
+	<T> T readValue(byte[] content, Class<T> type) throws IOException;
+
+	/**
+	 * Deserialize JSON string into a parameterized target type.
+	 * @param content JSON as String
+	 * @param type parameterized type reference
+	 * @return deserialized instance
+	 * @param <T> generic type
+	 * @throws IOException on parse errors
+	 */
+	<T> T readValue(String content, TypeRef<T> type) throws IOException;
+
+	/**
+	 * Deserialize JSON bytes into a parameterized target type.
+	 * @param content JSON as bytes
+	 * @param type parameterized type reference
+	 * @return deserialized instance
+	 * @param <T> generic type
+	 * @throws IOException on parse errors
+	 */
+	<T> T readValue(byte[] content, TypeRef<T> type) throws IOException;
+
+	/**
+	 * Convert a value to a given type, useful for mapping nested JSON structures.
+	 * @param fromValue source value
+	 * @param type target class
+	 * @return converted value
+	 * @param <T> generic type
+	 */
+	<T> T convertValue(Object fromValue, Class<T> type);
+
+	/**
+	 * Convert a value to a given parameterized type.
+	 * @param fromValue source value
+	 * @param type target type reference
+	 * @return converted value
+	 * @param <T> generic type
+	 */
+	<T> T convertValue(Object fromValue, TypeRef<T> type);
+
+	/**
+	 * Serialize an object to JSON string.
+	 * @param value object to serialize
+	 * @return JSON as String
+	 * @throws IOException on serialization errors
+	 */
+	String writeValueAsString(Object value) throws IOException;
+
+	/**
+	 * Serialize an object to JSON bytes.
+	 * @param value object to serialize
+	 * @return JSON as bytes
+	 * @throws IOException on serialization errors
+	 */
+	byte[] writeValueAsBytes(Object value) throws IOException;
+
+}