1fc698bb8e
## Motivation and Context MCP 2025-11-25 (SEP-1613) establishes JSON Schema 2020-12 as the default dialect for MCP schema definitions. https://github.com/modelcontextprotocol/modelcontextprotocol/issues/1613 The Ruby SDK was emitting tool input and output schemas with no `$schema` field, leaving the dialect implicit and inconsistent with the TypeScript SDK (`packages/core/src/util/standardSchema.ts`, which emits with `target: 'draft-2020-12'`) and the Python SDK (which preserves `$schema` in its types and conformance fixtures). `Tool::Schema#to_h` now includes `"$schema": "https://json-schema.org/draft/2020-12/schema"` unless the user supplied a different `$schema` value, so clients see the canonical dialect URI on the wire. Runtime metaschema and argument validation remain on draft-04 because the `json-schema` gem does not yet support 2020-12. Switching the runtime validator is left as a separate change because it requires either replacing the gem or waiting for upstream 2020-12 support. ## How Has This Been Tested? Updated `Tool::Schema#to_h` expectations across `input_schema_test`, `output_schema_test`, `tool_test`, and the `tools/list` server tests to reflect the new `$schema` field. Added focused regression tests: - `to_h` preserves a user-supplied `$schema` URI rather than overwriting it (covered for both symbol-keyed input and the string-keyed Hash form that goes through the initializer's `symbolize_names` normalization) - `validate_arguments` / `validate_result` continue to work when the user supplies a 2020-12 `$schema` URI on the schema (the validator strips the unknown top-level dialect URI before invoking the draft-04 validator, instead of raising `JSON::Schema::SchemaError`) - `tools/list` JSON-RPC response includes the 2020-12 `$schema` on both `inputSchema` and `outputSchema` (transport-boundary assertion) `bundle exec rake test` and `bundle exec rake rubocop` both pass. ## Breaking Changes Additive change. Tolerant consumers of the `tools/list` payload are unaffected. Consumers that strictly assert hash equality on the emitted `inputSchema` / `outputSchema` need to account for the new `$schema` key, but no schema semantics change. Schemas using 2020-12-only keywords (e.g. `prefixItems`, nested `$schema` on subschemas) are still rejected by the draft-04 metaschema validator, as before. Lifting that restriction depends on adopting a 2020-12-capable validator and is out of scope for this change.
205 lines
8 KiB
Ruby
205 lines
8 KiB
Ruby
# frozen_string_literal: true
|
|
|
|
require "test_helper"
|
|
|
|
module MCP
|
|
class Tool
|
|
class InputSchemaTest < ActiveSupport::TestCase
|
|
test "required arguments are converted to strings" do
|
|
input_schema = InputSchema.new(properties: { message: { type: "string" } }, required: [:message])
|
|
assert_equal ["message"], input_schema.schema[:required]
|
|
end
|
|
|
|
test "to_h returns a hash representation of the input schema" do
|
|
input_schema = InputSchema.new(properties: { message: { type: "string" } }, required: ["message"])
|
|
assert_equal(
|
|
{
|
|
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
|
type: "object",
|
|
properties: { message: { type: "string" } },
|
|
required: ["message"],
|
|
},
|
|
input_schema.to_h,
|
|
)
|
|
end
|
|
|
|
test "to_h returns a hash representation of the input schema with additionalProperties set to false" do
|
|
input_schema = InputSchema.new(properties: { message: { type: "string" } }, required: ["message"], additionalProperties: false)
|
|
assert_equal(
|
|
{
|
|
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
|
type: "object",
|
|
properties: { message: { type: "string" } },
|
|
required: ["message"],
|
|
additionalProperties: false,
|
|
},
|
|
input_schema.to_h,
|
|
)
|
|
end
|
|
|
|
test "to_h preserves user-supplied $schema dialect" do
|
|
input_schema = InputSchema.new(
|
|
"$schema": "https://json-schema.org/draft/2019-09/schema",
|
|
properties: { message: { type: "string" } },
|
|
)
|
|
assert_equal "https://json-schema.org/draft/2019-09/schema", input_schema.to_h[:"$schema"]
|
|
end
|
|
|
|
test "validate_arguments works when user supplies a 2020-12 $schema" do
|
|
input_schema = InputSchema.new(
|
|
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
|
properties: { foo: { type: "string" } },
|
|
required: ["foo"],
|
|
)
|
|
assert_nil(input_schema.validate_arguments(foo: "bar"))
|
|
assert_raises(InputSchema::ValidationError) do
|
|
input_schema.validate_arguments({ foo: 123 })
|
|
end
|
|
end
|
|
|
|
test "to_h preserves user-supplied $schema given via string key" do
|
|
# The initializer normalizes input through `JSON.parse(...,
|
|
# symbolize_names: true)`, so a string-keyed `"$schema"` should
|
|
# arrive at `schema_for_validation` the same as a symbol-keyed one.
|
|
input_schema = InputSchema.new(
|
|
{
|
|
"$schema" => "https://json-schema.org/draft/2020-12/schema",
|
|
"properties" => { "foo" => { "type" => "string" } },
|
|
"required" => ["foo"],
|
|
},
|
|
)
|
|
assert_equal "https://json-schema.org/draft/2020-12/schema", input_schema.to_h[:"$schema"]
|
|
assert_nil(input_schema.validate_arguments(foo: "bar"))
|
|
end
|
|
|
|
test "missing_required_arguments returns an array of missing required arguments" do
|
|
input_schema = InputSchema.new(properties: { message: { type: "string" } }, required: ["message"])
|
|
assert_equal ["message"], input_schema.missing_required_arguments({})
|
|
end
|
|
|
|
test "missing_required_arguments returns an empty array if no required arguments are missing" do
|
|
input_schema = InputSchema.new(properties: { message: { type: "string" } }, required: ["message"])
|
|
assert_equal([], input_schema.missing_required_arguments({ message: "Hello, world!" }))
|
|
end
|
|
|
|
test "valid schema initialization" do
|
|
schema = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"])
|
|
assert_equal(
|
|
{
|
|
"$schema": "https://json-schema.org/draft/2020-12/schema",
|
|
type: "object",
|
|
properties: { foo: { type: "string" } },
|
|
required: ["foo"],
|
|
},
|
|
schema.to_h,
|
|
)
|
|
end
|
|
|
|
test "invalid schema raises argument error" do
|
|
assert_raises(ArgumentError) do
|
|
InputSchema.new(properties: { foo: { type: "invalid_type" } }, required: ["foo"])
|
|
end
|
|
end
|
|
|
|
test "schema without required arguments is valid" do
|
|
assert_nothing_raised do
|
|
InputSchema.new(properties: { foo: { type: "string" } })
|
|
end
|
|
end
|
|
|
|
test "validate arguments with valid data" do
|
|
schema = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"])
|
|
assert_nil(schema.validate_arguments({ foo: "bar" }))
|
|
end
|
|
|
|
test "validate arguments with invalid data" do
|
|
schema = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"])
|
|
assert_raises(InputSchema::ValidationError) do
|
|
schema.validate_arguments({ foo: 123 })
|
|
end
|
|
end
|
|
|
|
test "validate arguments with valid data when additionalProperties set to nil (default)" do
|
|
schema = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"])
|
|
assert_nil(schema.validate_arguments({ foo: "bar", extra: 123 }))
|
|
end
|
|
|
|
test "validate arguments with valid data when additionalProperties set to true (default)" do
|
|
schema = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"], additionalProperties: true)
|
|
assert_nil(schema.validate_arguments({ foo: "bar", extra: 123 }))
|
|
end
|
|
|
|
test "validate arguments with invalid data when additionalProperties set to false" do
|
|
schema = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"], additionalProperties: false)
|
|
assert_raises(InputSchema::ValidationError) do
|
|
schema.validate_arguments({ foo: "bar", extra: 123 })
|
|
end
|
|
end
|
|
|
|
test "unexpected errors bubble up from validate_arguments" do
|
|
schema = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"])
|
|
|
|
JSON::Validator.stub(:fully_validate, ->(*) { raise "unexpected error" }) do
|
|
assert_raises(RuntimeError) do
|
|
schema.validate_arguments({ foo: "bar" })
|
|
end
|
|
end
|
|
end
|
|
|
|
test "accepts schemas with $ref references" do
|
|
schema = InputSchema.new(
|
|
properties: {
|
|
foo: { type: "string" },
|
|
},
|
|
definitions: {
|
|
bar: { type: "string" },
|
|
},
|
|
required: ["foo"],
|
|
)
|
|
assert_includes schema.to_h.keys, :definitions
|
|
end
|
|
|
|
test "accepts schemas with $ref string key and includes $ref in to_h" do
|
|
schema = InputSchema.new({
|
|
"properties" => {
|
|
"foo" => { "$ref" => "#/definitions/bar" },
|
|
},
|
|
"definitions" => {
|
|
"bar" => { "type" => "string" },
|
|
},
|
|
})
|
|
assert_equal "#/definitions/bar", schema.to_h[:properties][:foo][:$ref]
|
|
end
|
|
|
|
test "accepts schemas with $ref symbol key and includes $ref in to_h" do
|
|
schema = InputSchema.new({
|
|
properties: {
|
|
foo: { :$ref => "#/definitions/bar" },
|
|
},
|
|
definitions: {
|
|
bar: { type: "string" },
|
|
},
|
|
})
|
|
assert_equal "#/definitions/bar", schema.to_h[:properties][:foo][:$ref]
|
|
end
|
|
|
|
test "== compares two input schemas with the same properties, required fields" do
|
|
schema1 = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"])
|
|
schema2 = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"])
|
|
assert_equal schema1, schema2
|
|
|
|
schema3 = InputSchema.new(properties: { bar: { type: "string" } }, required: ["bar"])
|
|
refute_equal schema1, schema3
|
|
|
|
schema4 = InputSchema.new(properties: { foo: { type: "string" } }, required: ["bar"])
|
|
refute_equal schema1, schema4
|
|
|
|
schema5 = InputSchema.new(properties: { bar: { type: "string" } }, required: ["foo"])
|
|
refute_equal schema1, schema5
|
|
|
|
schema6 = InputSchema.new(properties: { foo: { type: "string" } }, required: ["foo"], additionalProperties: false)
|
|
refute_equal schema1, schema6
|
|
end
|
|
end
|
|
end
|
|
end
|