type) {
+ JavaType javaType = jsonMapper.getTypeFactory().constructType(type.getType());
+ return jsonMapper.convertValue(fromValue, javaType);
+ }
+
+ @Override
+ public String writeValueAsString(Object value) {
+ return jsonMapper.writeValueAsString(value);
+ }
+
+ @Override
+ public byte[] writeValueAsBytes(Object value) {
+ return jsonMapper.writeValueAsBytes(value);
+ }
+
+}
diff --git a/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/jackson3/JacksonMcpJsonMapperSupplier.java b/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/jackson3/JacksonMcpJsonMapperSupplier.java
new file mode 100644
index 000000000..c53061b2f
--- /dev/null
+++ b/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/jackson3/JacksonMcpJsonMapperSupplier.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2026 - 2026 the original author or authors.
+ */
+
+package io.modelcontextprotocol.json.jackson3;
+
+import tools.jackson.databind.json.JsonMapper;
+
+import io.modelcontextprotocol.json.McpJsonMapper;
+import io.modelcontextprotocol.json.McpJsonMapperSupplier;
+
+/**
+ * A supplier of {@link McpJsonMapper} instances that uses the Jackson library for JSON
+ * serialization and deserialization.
+ *
+ * This implementation provides a {@link McpJsonMapper} backed by a Jackson
+ * {@link JsonMapper}.
+ */
+public class JacksonMcpJsonMapperSupplier implements McpJsonMapperSupplier {
+
+ /**
+ * Returns a new instance of {@link McpJsonMapper} that uses the Jackson library for
+ * JSON serialization and deserialization.
+ *
+ * The returned {@link McpJsonMapper} is backed by a new instance of
+ * {@link tools.jackson.databind.json.JsonMapper}.
+ * @return a new {@link McpJsonMapper} instance
+ */
+ @Override
+ public McpJsonMapper get() {
+ return new JacksonMcpJsonMapper(JsonMapper.shared());
+ }
+
+}
diff --git a/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/schema/jackson3/DefaultJsonSchemaValidator.java b/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/schema/jackson3/DefaultJsonSchemaValidator.java
new file mode 100644
index 000000000..8c9b7ccdb
--- /dev/null
+++ b/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/schema/jackson3/DefaultJsonSchemaValidator.java
@@ -0,0 +1,162 @@
+/*
+ * Copyright 2026-2026 the original author or authors.
+ */
+package io.modelcontextprotocol.json.schema.jackson3;
+
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+import com.networknt.schema.Schema;
+import com.networknt.schema.SchemaRegistry;
+import com.networknt.schema.Error;
+import com.networknt.schema.dialect.Dialects;
+import io.modelcontextprotocol.json.schema.JsonSchemaValidator;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import tools.jackson.core.JacksonException;
+import tools.jackson.databind.JsonNode;
+import tools.jackson.databind.json.JsonMapper;
+
+/**
+ * Default implementation of the {@link JsonSchemaValidator} interface. This class
+ * provides methods to validate structured content against a JSON schema. It uses the
+ * NetworkNT JSON Schema Validator library for validation.
+ *
+ * @author Filip Hrisafov
+ */
+public class DefaultJsonSchemaValidator implements JsonSchemaValidator {
+
+ private static final Logger logger = LoggerFactory.getLogger(DefaultJsonSchemaValidator.class);
+
+ private final JsonMapper jsonMapper;
+
+ private final SchemaRegistry schemaFactory;
+
+ // TODO: Implement a strategy to purge the cache (TTL, size limit, etc.)
+ private final ConcurrentHashMap schemaCache;
+
+ public DefaultJsonSchemaValidator() {
+ this(JsonMapper.shared());
+ }
+
+ public DefaultJsonSchemaValidator(JsonMapper jsonMapper) {
+ this.jsonMapper = jsonMapper;
+ this.schemaFactory = SchemaRegistry.withDialect(Dialects.getDraft202012());
+ this.schemaCache = new ConcurrentHashMap<>();
+ }
+
+ @Override
+ public ValidationResponse validate(Map schema, Object structuredContent) {
+
+ if (schema == null) {
+ throw new IllegalArgumentException("Schema must not be null");
+ }
+ if (structuredContent == null) {
+ throw new IllegalArgumentException("Structured content must not be null");
+ }
+
+ try {
+
+ JsonNode jsonStructuredOutput = (structuredContent instanceof String)
+ ? this.jsonMapper.readTree((String) structuredContent)
+ : this.jsonMapper.valueToTree(structuredContent);
+
+ List validationResult = this.getOrCreateJsonSchema(schema).validate(jsonStructuredOutput);
+
+ // Check if validation passed
+ if (!validationResult.isEmpty()) {
+ return ValidationResponse
+ .asInvalid("Validation failed: structuredContent does not match tool outputSchema. "
+ + "Validation errors: " + validationResult);
+ }
+
+ return ValidationResponse.asValid(jsonStructuredOutput.toString());
+
+ }
+ catch (JacksonException e) {
+ logger.error("Failed to validate CallToolResult: Error parsing schema: {}", e);
+ return ValidationResponse.asInvalid("Error parsing tool JSON Schema: " + e.getMessage());
+ }
+ catch (Exception e) {
+ logger.error("Failed to validate CallToolResult: Unexpected error: {}", e);
+ return ValidationResponse.asInvalid("Unexpected validation error: " + e.getMessage());
+ }
+ }
+
+ /**
+ * Gets a cached Schema or creates and caches a new one.
+ * @param schema the schema map to convert
+ * @return the compiled Schema
+ * @throws JacksonException if schema processing fails
+ */
+ private Schema getOrCreateJsonSchema(Map schema) throws JacksonException {
+ // Generate cache key based on schema content
+ String cacheKey = this.generateCacheKey(schema);
+
+ // Try to get from cache first
+ Schema cachedSchema = this.schemaCache.get(cacheKey);
+ if (cachedSchema != null) {
+ return cachedSchema;
+ }
+
+ // Create new schema if not in cache
+ Schema newSchema = this.createJsonSchema(schema);
+
+ // Cache the schema
+ Schema existingSchema = this.schemaCache.putIfAbsent(cacheKey, newSchema);
+ return existingSchema != null ? existingSchema : newSchema;
+ }
+
+ /**
+ * Creates a new Schema from the given schema map.
+ * @param schema the schema map
+ * @return the compiled Schema
+ * @throws JacksonException if schema processing fails
+ */
+ private Schema createJsonSchema(Map schema) throws JacksonException {
+ // Convert schema map directly to JsonNode (more efficient than string
+ // serialization)
+ JsonNode schemaNode = this.jsonMapper.valueToTree(schema);
+
+ // Handle case where ObjectMapper might return null (e.g., in mocked scenarios)
+ if (schemaNode == null) {
+ throw new JacksonException("Failed to convert schema to JsonNode") {
+ };
+ }
+
+ return this.schemaFactory.getSchema(schemaNode);
+ }
+
+ /**
+ * Generates a cache key for the given schema map.
+ * @param schema the schema map
+ * @return a cache key string
+ */
+ protected String generateCacheKey(Map schema) {
+ if (schema.containsKey("$id")) {
+ // Use the (optional) "$id" field as the cache key if present
+ return "" + schema.get("$id");
+ }
+ // Fall back to schema's hash code as a simple cache key
+ // For more sophisticated caching, could use content-based hashing
+ return String.valueOf(schema.hashCode());
+ }
+
+ /**
+ * Clears the schema cache. Useful for testing or memory management.
+ */
+ public void clearCache() {
+ this.schemaCache.clear();
+ }
+
+ /**
+ * Returns the current size of the schema cache.
+ * @return the number of cached schemas
+ */
+ public int getCacheSize() {
+ return this.schemaCache.size();
+ }
+
+}
diff --git a/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/schema/jackson3/JacksonJsonSchemaValidatorSupplier.java b/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/schema/jackson3/JacksonJsonSchemaValidatorSupplier.java
new file mode 100644
index 000000000..87cead5db
--- /dev/null
+++ b/mcp-json-jackson3/src/main/java/io/modelcontextprotocol/json/schema/jackson3/JacksonJsonSchemaValidatorSupplier.java
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2026 - 2026 the original author or authors.
+ */
+
+package io.modelcontextprotocol.json.schema.jackson3;
+
+import io.modelcontextprotocol.json.schema.JsonSchemaValidator;
+import io.modelcontextprotocol.json.schema.JsonSchemaValidatorSupplier;
+
+/**
+ * A concrete implementation of {@link JsonSchemaValidatorSupplier} that provides a
+ * {@link JsonSchemaValidator} instance based on the Jackson library.
+ *
+ * @see JsonSchemaValidatorSupplier
+ * @see JsonSchemaValidator
+ */
+public class JacksonJsonSchemaValidatorSupplier implements JsonSchemaValidatorSupplier {
+
+ /**
+ * Returns a new instance of {@link JsonSchemaValidator} that uses the Jackson library
+ * for JSON schema validation.
+ * @return A {@link JsonSchemaValidator} instance.
+ */
+ @Override
+ public JsonSchemaValidator get() {
+ return new DefaultJsonSchemaValidator();
+ }
+
+}
diff --git a/mcp-json-jackson3/src/main/resources/META-INF/services/io.modelcontextprotocol.json.McpJsonMapperSupplier b/mcp-json-jackson3/src/main/resources/META-INF/services/io.modelcontextprotocol.json.McpJsonMapperSupplier
new file mode 100644
index 000000000..6abfb347f
--- /dev/null
+++ b/mcp-json-jackson3/src/main/resources/META-INF/services/io.modelcontextprotocol.json.McpJsonMapperSupplier
@@ -0,0 +1 @@
+io.modelcontextprotocol.json.jackson3.JacksonMcpJsonMapperSupplier
\ No newline at end of file
diff --git a/mcp-json-jackson3/src/main/resources/META-INF/services/io.modelcontextprotocol.json.schema.JsonSchemaValidatorSupplier b/mcp-json-jackson3/src/main/resources/META-INF/services/io.modelcontextprotocol.json.schema.JsonSchemaValidatorSupplier
new file mode 100644
index 000000000..2bab3ba8e
--- /dev/null
+++ b/mcp-json-jackson3/src/main/resources/META-INF/services/io.modelcontextprotocol.json.schema.JsonSchemaValidatorSupplier
@@ -0,0 +1 @@
+io.modelcontextprotocol.json.schema.jackson3.JacksonJsonSchemaValidatorSupplier
\ No newline at end of file
diff --git a/mcp-json-jackson3/src/test/java/io/modelcontextprotocol/json/DefaultJsonSchemaValidatorTests.java b/mcp-json-jackson3/src/test/java/io/modelcontextprotocol/json/DefaultJsonSchemaValidatorTests.java
new file mode 100644
index 000000000..37c52caf7
--- /dev/null
+++ b/mcp-json-jackson3/src/test/java/io/modelcontextprotocol/json/DefaultJsonSchemaValidatorTests.java
@@ -0,0 +1,807 @@
+/*
+ * Copyright 2026-2026 the original author or authors.
+ */
+
+package io.modelcontextprotocol.json;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertNotEquals;
+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 static org.mockito.ArgumentMatchers.any;
+import static org.mockito.Mockito.when;
+
+import java.util.List;
+import java.util.Map;
+import java.util.stream.Stream;
+
+import io.modelcontextprotocol.json.schema.jackson3.DefaultJsonSchemaValidator;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.Arguments;
+import org.junit.jupiter.params.provider.MethodSource;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+import tools.jackson.core.type.TypeReference;
+import tools.jackson.databind.json.JsonMapper;
+
+import io.modelcontextprotocol.json.schema.JsonSchemaValidator.ValidationResponse;
+
+/**
+ * Tests for {@link DefaultJsonSchemaValidator}.
+ *
+ * @author Filip Hrisafov
+ */
+class DefaultJsonSchemaValidatorTests {
+
+ private DefaultJsonSchemaValidator validator;
+
+ private JsonMapper jsonMapper;
+
+ @Mock
+ private JsonMapper mockJsonMapper;
+
+ @BeforeEach
+ void setUp() {
+ MockitoAnnotations.openMocks(this);
+ validator = new DefaultJsonSchemaValidator();
+ jsonMapper = JsonMapper.shared();
+ }
+
+ /**
+ * Utility method to convert JSON string to Map
+ */
+ private Map toMap(String json) {
+ try {
+ return jsonMapper.readValue(json, new TypeReference<>() {
+ });
+ }
+ catch (Exception e) {
+ throw new RuntimeException("Failed to parse JSON: " + json, e);
+ }
+ }
+
+ private List> toListMap(String json) {
+ try {
+ return jsonMapper.readValue(json, new TypeReference<>() {
+ });
+ }
+ catch (Exception e) {
+ throw new RuntimeException("Failed to parse JSON: " + json, e);
+ }
+ }
+
+ @Test
+ void testDefaultConstructor() {
+ DefaultJsonSchemaValidator defaultValidator = new DefaultJsonSchemaValidator();
+
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "test": {"type": "string"}
+ }
+ }
+ """;
+ String contentJson = """
+ {
+ "test": "value"
+ }
+ """;
+
+ ValidationResponse response = defaultValidator.validate(toMap(schemaJson), toMap(contentJson));
+ assertTrue(response.valid());
+ }
+
+ @Test
+ void testConstructorWithObjectMapper() {
+ JsonMapper customMapper = JsonMapper.builder().build();
+ DefaultJsonSchemaValidator customValidator = new DefaultJsonSchemaValidator(customMapper);
+
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "test": {"type": "string"}
+ }
+ }
+ """;
+ String contentJson = """
+ {
+ "test": "value"
+ }
+ """;
+
+ ValidationResponse response = customValidator.validate(toMap(schemaJson), toMap(contentJson));
+ assertTrue(response.valid());
+ }
+
+ @Test
+ void testValidateWithValidStringSchema() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"},
+ "age": {"type": "integer"}
+ },
+ "required": ["name", "age"]
+ }
+ """;
+
+ String contentJson = """
+ {
+ "name": "John Doe",
+ "age": 30
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ assertNotNull(response.jsonStructuredOutput());
+ }
+
+ @Test
+ void testValidateWithValidNumberSchema() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "price": {"type": "number", "minimum": 0},
+ "quantity": {"type": "integer", "minimum": 1}
+ },
+ "required": ["price", "quantity"]
+ }
+ """;
+
+ String contentJson = """
+ {
+ "price": 19.99,
+ "quantity": 5
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithValidArraySchema() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "items": {
+ "type": "array",
+ "items": {"type": "string"}
+ }
+ },
+ "required": ["items"]
+ }
+ """;
+
+ String contentJson = """
+ {
+ "items": ["apple", "banana", "cherry"]
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithValidArraySchemaTopLevelArray() {
+ String schemaJson = """
+ {
+ "$schema" : "https://json-schema.org/draft/2020-12/schema",
+ "type" : "array",
+ "items" : {
+ "type" : "object",
+ "properties" : {
+ "city" : {
+ "type" : "string"
+ },
+ "summary" : {
+ "type" : "string"
+ },
+ "temperatureC" : {
+ "type" : "number",
+ "format" : "float"
+ }
+ },
+ "required" : [ "city", "summary", "temperatureC" ]
+ },
+ "additionalProperties" : false
+ }
+ """;
+
+ String contentJson = """
+ [
+ {
+ "city": "London",
+ "summary": "Generally mild with frequent rainfall. Winters are cool and damp, summers are warm but rarely hot. Cloudy conditions are common throughout the year.",
+ "temperatureC": 11.3
+ },
+ {
+ "city": "New York",
+ "summary": "Four distinct seasons with hot and humid summers, cold winters with snow, and mild springs and autumns. Precipitation is fairly evenly distributed throughout the year.",
+ "temperatureC": 12.8
+ },
+ {
+ "city": "San Francisco",
+ "summary": "Mild year-round with a distinctive Mediterranean climate. Famous for summer fog, mild winters, and little temperature variation throughout the year. Very little rainfall in summer months.",
+ "temperatureC": 14.6
+ },
+ {
+ "city": "Tokyo",
+ "summary": "Humid subtropical climate with hot, wet summers and mild winters. Experiences a rainy season in early summer and occasional typhoons in late summer to early autumn.",
+ "temperatureC": 15.4
+ }
+ ]
+ """;
+
+ Map schema = toMap(schemaJson);
+
+ // Validate as JSON string
+ ValidationResponse response = validator.validate(schema, contentJson);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+
+ List> structuredContent = toListMap(contentJson);
+
+ // Validate as List>
+ response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithInvalidTypeSchema() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"},
+ "age": {"type": "integer"}
+ },
+ "required": ["name", "age"]
+ }
+ """;
+
+ String contentJson = """
+ {
+ "name": "John Doe",
+ "age": "thirty"
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertFalse(response.valid());
+ assertNotNull(response.errorMessage());
+ assertTrue(response.errorMessage().contains("Validation failed"));
+ assertTrue(response.errorMessage().contains("structuredContent does not match tool outputSchema"));
+ }
+
+ @Test
+ void testValidateWithMissingRequiredField() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"},
+ "age": {"type": "integer"}
+ },
+ "required": ["name", "age"]
+ }
+ """;
+
+ String contentJson = """
+ {
+ "name": "John Doe"
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertFalse(response.valid());
+ assertNotNull(response.errorMessage());
+ assertTrue(response.errorMessage().contains("Validation failed"));
+ }
+
+ @Test
+ void testValidateWithAdditionalPropertiesNotAllowed() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"}
+ },
+ "required": ["name"],
+ "additionalProperties": false
+ }
+ """;
+
+ String contentJson = """
+ {
+ "name": "John Doe",
+ "extraField": "should not be allowed"
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertFalse(response.valid());
+ assertNotNull(response.errorMessage());
+ assertTrue(response.errorMessage().contains("Validation failed"));
+ }
+
+ @Test
+ void testValidateWithAdditionalPropertiesExplicitlyAllowed() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"}
+ },
+ "required": ["name"],
+ "additionalProperties": true
+ }
+ """;
+
+ String contentJson = """
+ {
+ "name": "John Doe",
+ "extraField": "should be allowed"
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithDefaultAdditionalProperties() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"}
+ },
+ "required": ["name"],
+ "additionalProperties": true
+ }
+ """;
+
+ String contentJson = """
+ {
+ "name": "John Doe",
+ "extraField": "should be allowed"
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithAdditionalPropertiesExplicitlyDisallowed() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"}
+ },
+ "required": ["name"],
+ "additionalProperties": false
+ }
+ """;
+
+ String contentJson = """
+ {
+ "name": "John Doe",
+ "extraField": "should not be allowed"
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertFalse(response.valid());
+ assertNotNull(response.errorMessage());
+ assertTrue(response.errorMessage().contains("Validation failed"));
+ }
+
+ @Test
+ void testValidateWithEmptySchema() {
+ String schemaJson = """
+ {
+ "additionalProperties": true
+ }
+ """;
+
+ String contentJson = """
+ {
+ "anything": "goes"
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithEmptyContent() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {}
+ }
+ """;
+
+ String contentJson = """
+ {}
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithNestedObjectSchema() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "person": {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"},
+ "address": {
+ "type": "object",
+ "properties": {
+ "street": {"type": "string"},
+ "city": {"type": "string"}
+ },
+ "required": ["street", "city"]
+ }
+ },
+ "required": ["name", "address"]
+ }
+ },
+ "required": ["person"]
+ }
+ """;
+
+ String contentJson = """
+ {
+ "person": {
+ "name": "John Doe",
+ "address": {
+ "street": "123 Main St",
+ "city": "Anytown"
+ }
+ }
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ }
+
+ @Test
+ void testValidateWithInvalidNestedObjectSchema() {
+ String schemaJson = """
+ {
+ "type": "object",
+ "properties": {
+ "person": {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"},
+ "address": {
+ "type": "object",
+ "properties": {
+ "street": {"type": "string"},
+ "city": {"type": "string"}
+ },
+ "required": ["street", "city"]
+ }
+ },
+ "required": ["name", "address"]
+ }
+ },
+ "required": ["person"]
+ }
+ """;
+
+ String contentJson = """
+ {
+ "person": {
+ "name": "John Doe",
+ "address": {
+ "street": "123 Main St"
+ }
+ }
+ }
+ """;
+
+ Map schema = toMap(schemaJson);
+ Map structuredContent = toMap(contentJson);
+
+ ValidationResponse response = validator.validate(schema, structuredContent);
+
+ assertFalse(response.valid());
+ assertNotNull(response.errorMessage());
+ assertTrue(response.errorMessage().contains("Validation failed"));
+ }
+
+ @Test
+ void testValidateWithJsonProcessingException() {
+ DefaultJsonSchemaValidator validatorWithMockMapper = new DefaultJsonSchemaValidator(mockJsonMapper);
+
+ Map schema = Map.of("type", "object");
+ Map structuredContent = Map.of("key", "value");
+
+ // This will trigger our null check and throw JsonProcessingException
+ when(mockJsonMapper.valueToTree(any())).thenReturn(null);
+
+ ValidationResponse response = validatorWithMockMapper.validate(schema, structuredContent);
+
+ assertFalse(response.valid());
+ assertNotNull(response.errorMessage());
+ assertTrue(response.errorMessage().contains("Error parsing tool JSON Schema"));
+ assertTrue(response.errorMessage().contains("Failed to convert schema to JsonNode"));
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideValidSchemaAndContentPairs")
+ void testValidateWithVariousValidInputs(Map schema, Map content) {
+ ValidationResponse response = validator.validate(schema, content);
+
+ assertTrue(response.valid(), "Expected validation to pass for schema: " + schema + " and content: " + content);
+ assertNull(response.errorMessage());
+ }
+
+ @ParameterizedTest
+ @MethodSource("provideInvalidSchemaAndContentPairs")
+ void testValidateWithVariousInvalidInputs(Map schema, Map content) {
+ ValidationResponse response = validator.validate(schema, content);
+
+ assertFalse(response.valid(), "Expected validation to fail for schema: " + schema + " and content: " + content);
+ assertNotNull(response.errorMessage());
+ assertTrue(response.errorMessage().contains("Validation failed"));
+ }
+
+ private static Map staticToMap(String json) {
+ try {
+ return JsonMapper.shared().readValue(json, new TypeReference<>() {
+ });
+ }
+ catch (Exception e) {
+ throw new RuntimeException("Failed to parse JSON: " + json, e);
+ }
+ }
+
+ private static Stream provideValidSchemaAndContentPairs() {
+ return Stream.of(
+ // Boolean schema
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "flag": {"type": "boolean"}
+ }
+ }
+ """), staticToMap("""
+ {
+ "flag": true
+ }
+ """)),
+ // String with additional properties allowed
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "name": {"type": "string"}
+ },
+ "additionalProperties": true
+ }
+ """), staticToMap("""
+ {
+ "name": "test",
+ "extra": "allowed"
+ }
+ """)),
+ // Array with specific items
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "numbers": {
+ "type": "array",
+ "items": {"type": "number"}
+ }
+ }
+ }
+ """), staticToMap("""
+ {
+ "numbers": [1.0, 2.5, 3.14]
+ }
+ """)),
+ // Enum validation
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "status": {
+ "type": "string",
+ "enum": ["active", "inactive", "pending"]
+ }
+ }
+ }
+ """), staticToMap("""
+ {
+ "status": "active"
+ }
+ """)));
+ }
+
+ private static Stream provideInvalidSchemaAndContentPairs() {
+ return Stream.of(
+ // Wrong boolean type
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "flag": {"type": "boolean"}
+ }
+ }
+ """), staticToMap("""
+ {
+ "flag": "true"
+ }
+ """)),
+ // Array with wrong item types
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "numbers": {
+ "type": "array",
+ "items": {"type": "number"}
+ }
+ }
+ }
+ """), staticToMap("""
+ {
+ "numbers": ["one", "two", "three"]
+ }
+ """)),
+ // Invalid enum value
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "status": {
+ "type": "string",
+ "enum": ["active", "inactive", "pending"]
+ }
+ }
+ }
+ """), staticToMap("""
+ {
+ "status": "unknown"
+ }
+ """)),
+ // Minimum constraint violation
+ Arguments.of(staticToMap("""
+ {
+ "type": "object",
+ "properties": {
+ "age": {"type": "integer", "minimum": 0}
+ }
+ }
+ """), staticToMap("""
+ {
+ "age": -5
+ }
+ """)));
+ }
+
+ @Test
+ void testValidationResponseToValid() {
+ String jsonOutput = "{\"test\":\"value\"}";
+ ValidationResponse response = ValidationResponse.asValid(jsonOutput);
+ assertTrue(response.valid());
+ assertNull(response.errorMessage());
+ assertEquals(jsonOutput, response.jsonStructuredOutput());
+ }
+
+ @Test
+ void testValidationResponseToInvalid() {
+ String errorMessage = "Test error message";
+ ValidationResponse response = ValidationResponse.asInvalid(errorMessage);
+ assertFalse(response.valid());
+ assertEquals(errorMessage, response.errorMessage());
+ assertNull(response.jsonStructuredOutput());
+ }
+
+ @Test
+ void testValidationResponseRecord() {
+ ValidationResponse response1 = new ValidationResponse(true, null, "{\"valid\":true}");
+ ValidationResponse response2 = new ValidationResponse(false, "Error", null);
+
+ assertTrue(response1.valid());
+ assertNull(response1.errorMessage());
+ assertEquals("{\"valid\":true}", response1.jsonStructuredOutput());
+
+ assertFalse(response2.valid());
+ assertEquals("Error", response2.errorMessage());
+ assertNull(response2.jsonStructuredOutput());
+
+ // Test equality
+ ValidationResponse response3 = new ValidationResponse(true, null, "{\"valid\":true}");
+ assertEquals(response1, response3);
+ assertNotEquals(response1, response2);
+ }
+
+}
diff --git a/mcp-spring/mcp-spring-webflux/pom.xml b/mcp-spring/mcp-spring-webflux/pom.xml
index f1737a477..34bbf02b9 100644
--- a/mcp-spring/mcp-spring-webflux/pom.xml
+++ b/mcp-spring/mcp-spring-webflux/pom.xml
@@ -24,7 +24,7 @@
io.modelcontextprotocol.sdk
- mcp-json-jackson2
+ mcp-json-jackson3
0.18.0-SNAPSHOT
diff --git a/mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/client/transport/WebFluxSseClientTransportTests.java b/mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/client/transport/WebFluxSseClientTransportTests.java
index 1150e47f5..ba747b8de 100644
--- a/mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/client/transport/WebFluxSseClientTransportTests.java
+++ b/mcp-spring/mcp-spring-webflux/src/test/java/io/modelcontextprotocol/client/transport/WebFluxSseClientTransportTests.java
@@ -10,9 +10,8 @@
import java.util.concurrent.atomic.AtomicInteger;
import java.util.function.Function;
-import com.fasterxml.jackson.databind.ObjectMapper;
import io.modelcontextprotocol.json.McpJsonMapper;
-import io.modelcontextprotocol.json.jackson.JacksonMcpJsonMapper;
+import io.modelcontextprotocol.json.jackson3.JacksonMcpJsonMapper;
import io.modelcontextprotocol.spec.McpSchema;
import io.modelcontextprotocol.spec.McpSchema.JSONRPCRequest;
import org.junit.jupiter.api.AfterAll;
@@ -27,6 +26,7 @@
import reactor.core.publisher.Mono;
import reactor.core.publisher.Sinks;
import reactor.test.StepVerifier;
+import tools.jackson.databind.json.JsonMapper;
import org.springframework.http.codec.ServerSentEvent;
import org.springframework.web.reactive.function.client.WebClient;
@@ -147,7 +147,7 @@ void testBuilderPattern() {
assertThatCode(() -> transport1.closeGracefully().block()).doesNotThrowAnyException();
// Test builder with custom ObjectMapper
- ObjectMapper customMapper = new ObjectMapper();
+ JsonMapper customMapper = JsonMapper.builder().build();
WebFluxSseClientTransport transport2 = WebFluxSseClientTransport.builder(webClientBuilder)
.jsonMapper(new JacksonMcpJsonMapper(customMapper))
.build();
diff --git a/mcp-spring/mcp-spring-webmvc/pom.xml b/mcp-spring/mcp-spring-webmvc/pom.xml
index df18b1b8b..a9701b8ec 100644
--- a/mcp-spring/mcp-spring-webmvc/pom.xml
+++ b/mcp-spring/mcp-spring-webmvc/pom.xml
@@ -24,7 +24,7 @@
io.modelcontextprotocol.sdk
- mcp-json-jackson2
+ mcp-json-jackson3
0.18.0-SNAPSHOT
diff --git a/mcp-test/pom.xml b/mcp-test/pom.xml
index 7fc22e5d2..ab9dd54e3 100644
--- a/mcp-test/pom.xml
+++ b/mcp-test/pom.xml
@@ -34,9 +34,9 @@