mcp 0.7.1 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1358d86b880959c1608cba8b747c9a13de95b9811f339c2d5811a3a18c7df410
-  data.tar.gz: ba8d2d0d5071468b56570830f579cdf5ab1d3f2b683c31722d7ed49b90fcc71b
+  metadata.gz: 149cbf6f8809235111648ffae6163abb1994cb5c2a4bd2240eb696f17197e421
+  data.tar.gz: 7c526f405b013d868032122484079ce715ef8db9629d78dc5c8635fccaf2fc6f
 SHA512:
-  metadata.gz: 44b4b01136379f1136084654534536fd269963ba2a010dda528a3b890a5f5416e54f0500e42154725aa9d5e594bedd7fd1944a20da89d2ff81bc9eb7b86e25fe
-  data.tar.gz: 8ac611adc761a1ddcbf5a0e5b51dcc8c0ec8f9a5f7f072bf9fa226b0db0eb439ebfca73c7e923f3820088375c40e5d30b319fcd1b7b4ffbcd304e0c23d36ac9c
+  metadata.gz: b7dcdebe8faa024fe784a894ae6383d2bcd812f41a3a492c75429034ed8f062a8da49963a94a159ce2af25928cccfbb92cb629be98ead1d751d54389e3dfc9a3
+  data.tar.gz: 9c6f1fb122e3d636da0a7585fe38bd3ea567ba98c2899d91ef87136b69e8d0c93007c3f031915b44c835d16bbcd1465875decc459e5a34aada517541b91d369f

data/.github/workflows/conformance.yml

@@ -0,0 +1,29 @@
+name: Conformance Tests
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+  workflow_dispatch:
+
+concurrency:
+  group: conformance-${{ github.ref }}
+  cancel-in-progress: true
+
+permissions:
+  contents: read
+
+jobs:
+  server-conformance:
+    runs-on: ubuntu-latest
+    continue-on-error: true
+    steps:
+      - uses: actions/checkout@v6
+      - uses: ruby/setup-ruby@v1
+        with:
+          ruby-version: '4.0' # Specify the latest supported Ruby version.
+          bundler-cache: true
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '24' # Specify the latest Node.js version.
+      - run: bundle exec rake conformance

data/.gitignore

@@ -1,4 +1,5 @@
 .ruby-version
+/*.gem
 /.bundle/
 /.yardoc
 /_yardoc/

data/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.8.0] - 2026-03-03
+
+### Added
+
+- `Content::EmbeddedResource` class for embedded resource content type (#244)
+- `Content::Audio` class for audio content type (#243)
+- `$ref` support in `Tool::Schema` for protocol version 2025-11-25 (#242)
+- MCP conformance test suite (#248)
+
+### Fixed
+
+- Handle `Errno::ECONNRESET` in SSE stream operations (#249)
+- Fix default handler return values to comply with MCP spec (#247)
+- Fix `Prompt#validate_arguments!` crash when arguments are `nil` (#246)
+- Return 202 Accepted for SSE responses per MCP spec (#245)
+- Fix `Content::Image#to_h` to return `mimeType` (camelCase) per MCP spec (#241)
+
 ## [0.7.1] - 2026-02-21
 
 ### Fixed

data/README.md

@@ -1028,6 +1028,12 @@ The client provides a wrapper class for tools returned by the server:
 
 This class provides easy access to tool properties like name, description, input schema, and output schema.
 
+## Conformance Testing
+
+The `conformance/` directory contains a test server and runner that validate the SDK against the MCP specification using [`@modelcontextprotocol/conformance`](https://github.com/modelcontextprotocol/conformance).
+
+See [conformance/README.md](conformance/README.md) for usage instructions.
+
 ## Documentation
 
 - [SDK API documentation](https://rubydoc.info/gems/mcp)

data/Rakefile

@@ -14,4 +14,43 @@ require "rubocop/rake_task"
 
 RuboCop::RakeTask.new
 
-task default: [:test, :rubocop]
+task default: [:rubocop, :test, :conformance]
+
+desc "Run MCP conformance tests (PORT, SCENARIO, SPEC_VERSION, VERBOSE)"
+task :conformance do |t|
+  next unless npx_available?(t.name)
+
+  require_relative "conformance/runner"
+
+  options = {}
+  options[:port] = Integer(ENV["PORT"]) if ENV["PORT"]
+  options[:scenario] = ENV["SCENARIO"] if ENV["SCENARIO"]
+  options[:spec_version] = ENV["SPEC_VERSION"] if ENV["SPEC_VERSION"]
+  options[:verbose] = true if ENV["VERBOSE"]
+
+  Conformance::Runner.new(**options).run
+end
+
+desc "List available conformance scenarios"
+task :conformance_list do |t|
+  next unless npx_available?(t.name)
+
+  system("npx", "--yes", "@modelcontextprotocol/conformance", "list", "--server")
+end
+
+desc "Start the conformance server (PORT)"
+task :conformance_server do
+  require_relative "conformance/server"
+
+  options = {}
+  options[:port] = Integer(ENV["PORT"]) if ENV["PORT"]
+
+  Conformance::Server.new(**options).start
+end
+
+def npx_available?(task_name)
+  return true if system("which", "npx", out: File::NULL, err: File::NULL)
+
+  warn("Skipping #{task_name}: npx is not installed. Install Node.js to run this task: https://nodejs.org/")
+  false
+end

data/conformance/README.md

@@ -0,0 +1,103 @@
+# MCP Conformance Tests
+
+Validates the Ruby SDK's conformance to the MCP specification using [`@modelcontextprotocol/conformance`](https://github.com/modelcontextprotocol/conformance).
+
+## Prerequisites
+
+- Node.js (for `npx`)
+- `bundle install` completed
+
+## Running the Tests
+
+### Run all scenarios
+
+```bash
+bundle exec rake conformance
+```
+
+Starts the conformance server, runs all active scenarios against it, prints a pass/fail
+summary for each scenario, and exits with a non-zero status code if any unexpected failures
+are detected. Scenarios listed in `expected_failures.yml` are allowed to fail without
+affecting the exit code.
+
+### Environment variables
+
+| Variable       | Description                          | Default |
+|----------------|--------------------------------------|---------|
+| `PORT`         | Server port                          | `9292`  |
+| `SCENARIO`     | Run a single scenario by name        | (all)   |
+| `SPEC_VERSION` | Filter scenarios by spec version     | (all)   |
+| `VERBOSE`      | Show raw JSON output when set        | (off)   |
+
+```bash
+# Run a single scenario
+bundle exec rake conformance SCENARIO=ping
+
+# Use a different port with verbose output
+bundle exec rake conformance PORT=3000 VERBOSE=1
+
+# Start the server on a specific port
+bundle exec rake conformance_server PORT=3000
+```
+
+### Start the server and test separately
+
+```bash
+# Terminal 1: start the server
+bundle exec rake conformance_server
+
+# Terminal 2: run all scenarios
+npx @modelcontextprotocol/conformance server --url http://localhost:9292/mcp
+
+# Terminal 2: run a single scenario
+npx @modelcontextprotocol/conformance server --url http://localhost:9292/mcp --scenario ping
+```
+
+Keeps the server alive between test runs, which avoids the startup overhead when iterating
+on a single scenario. Stop the server with Ctrl+C when done.
+
+### List available scenarios
+
+```bash
+bundle exec rake conformance_list
+```
+
+Prints all scenario names that can be passed to `SCENARIO`.
+
+## SDK Tier Report
+
+The [MCP SDK Tier system](https://modelcontextprotocol.io/community/sdk-tiers) requires SDK
+maintainers to self-assess and report results to the SDK Working Group via
+[modelcontextprotocol/modelcontextprotocol issues](https://github.com/modelcontextprotocol/modelcontextprotocol/issues).
+
+To generate a full tier assessment report, use the `/mcp-sdk-tier-audit` slash command from
+the [modelcontextprotocol/conformance](https://github.com/modelcontextprotocol/conformance)
+repository with the conformance server running:
+
+```bash
+# Terminal 1 (this repository): start the conformance server
+bundle exec rake conformance_server
+
+# Terminal 2 (conformance repository): run the tier audit skill as a slash command in Claude Code
+/mcp-sdk-tier-audit /path/to/modelcontextprotocol/ruby-sdk http://localhost:9292/mcp
+```
+
+The skill evaluates conformance pass rate, issue label taxonomy, triage metrics, documentation
+coverage, and policy compliance, then produces a markdown report suitable for tier advancement
+submissions.
+
+## File Structure
+
+```
+conformance/
+  server.rb              # Conformance server (Rack + Puma, default port 9292)
+  runner.rb              # Starts the server, runs npx conformance, exits with result code
+  expected_failures.yml  # Baseline of known-failing scenarios
+  README.md              # This file
+```
+
+## Known Limitations
+
+Known-failing scenarios are registered in `conformance/expected_failures.yml`. They are allowed to
+fail without affecting the exit code and are tracked to catch regressions.
+These are shown in the output of `bundle exec rake conformance`.

data/conformance/expected_failures.yml

@@ -0,0 +1,9 @@
+server:
+  # TODO: Server-to-client requests (sampling/createMessage, elicitation/create) are not implemented.
+  # `Transport#send_request` does not exist in the current SDK.
+  - tools-call-sampling
+  - tools-call-elicitation
+  - elicitation-sep1034-defaults
+  - elicitation-sep1330-enums
+  # TODO: The SDK does not extract `_meta.progressToken` from tool call requests or deliver `notifications/progress` to tools.
+  - tools-call-with-progress

data/conformance/runner.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+# Starts the conformance server and runs `npx @modelcontextprotocol/conformance` against it.
+require "English"
+require "net/http"
+require_relative "server"
+
+module Conformance
+  class Runner
+    # Timeout for waiting for the Puma server to start.
+    SERVER_START_TIMEOUT = 20
+    SERVER_POLL_INTERVAL = 0.5
+    SERVER_HEALTH_CHECK_RETRIES = (SERVER_START_TIMEOUT / SERVER_POLL_INTERVAL).to_i
+
+    def initialize(port: Server::DEFAULT_PORT, scenario: nil, spec_version: nil, verbose: false)
+      @port = port
+      @scenario = scenario
+      @spec_version = spec_version
+      @verbose = verbose
+    end
+
+    def run
+      command = build_command
+      server_pid = start_server
+
+      run_conformance(command, server_pid: server_pid)
+    end
+
+    private
+
+    def build_command
+      expected_failures_yml = File.expand_path("expected_failures.yml", __dir__)
+
+      npx_command = ["npx", "--yes", "@modelcontextprotocol/conformance", "server", "--url", "http://localhost:#{@port}/mcp"]
+      npx_command += ["--scenario", @scenario] if @scenario
+      npx_command += ["--spec-version", @spec_version] if @spec_version
+      npx_command += ["--verbose"] if @verbose
+      npx_command += ["--expected-failures", expected_failures_yml]
+      npx_command
+    end
+
+    def start_server
+      puts "Starting conformance server on port #{@port}..."
+
+      server_pid = fork do
+        Conformance::Server.new(port: @port).start
+      end
+
+      health_url = URI("http://localhost:#{@port}/health")
+      ready = false
+      SERVER_HEALTH_CHECK_RETRIES.times do
+        begin
+          response = Net::HTTP.get_response(health_url)
+          if response.code == "200"
+            ready = true
+            break
+          end
+        rescue Errno::ECONNREFUSED, Errno::ECONNRESET, Net::ReadTimeout
+          # not ready yet
+        end
+        sleep(SERVER_POLL_INTERVAL)
+      end
+
+      unless ready
+        warn("ERROR: Conformance server did not start within #{SERVER_START_TIMEOUT} seconds")
+        terminate_server(server_pid)
+        exit(1)
+      end
+
+      puts "Server ready. Running conformance tests..."
+
+      server_pid
+    end
+
+    def run_conformance(command, server_pid:)
+      puts "Command: #{command.join(" ")}\n\n"
+
+      conformance_exit_code = nil
+      begin
+        system(*command)
+        conformance_exit_code = $CHILD_STATUS.exitstatus
+      ensure
+        terminate_server(server_pid)
+      end
+
+      exit(conformance_exit_code || 1)
+    end
+
+    def terminate_server(pid)
+      Process.kill("TERM", pid)
+    rescue Errno::ESRCH
+      # process already exited
+    ensure
+      begin
+        Process.wait(pid)
+      rescue Errno::ECHILD
+        # already reaped
+      end
+    end
+  end
+end

data/conformance/server.rb

@@ -0,0 +1,547 @@
+# frozen_string_literal: true
+
+require "rackup"
+require "json"
+require "uri"
+require_relative "../lib/mcp"
+
+module Conformance
+  # 1x1 red PNG pixel (matches TypeScript SDK and Python SDK)
+  BASE64_1X1_PNG = "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8z8DwHwAFBQIAX8jx0gAAAABJRU5ErkJggg=="
+
+  # Minimal WAV file (matches TypeScript SDK and Python SDK)
+  BASE64_MINIMAL_WAV = "UklGRiYAAABXQVZFZm10IBAAAAABAAEAQB8AAAB9AAACABAAZGF0YQIAAAA="
+
+  module Tools
+    class TestSimpleText < MCP::Tool
+      tool_name "test_simple_text"
+      description "A tool that returns simple text content"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new([MCP::Content::Text.new("This is a simple text response for testing.").to_h])
+        end
+      end
+    end
+
+    class TestImageContent < MCP::Tool
+      tool_name "test_image_content"
+      description "A tool that returns image content"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new([MCP::Content::Image.new(BASE64_1X1_PNG, "image/png").to_h])
+        end
+      end
+    end
+
+    class TestAudioContent < MCP::Tool
+      tool_name "test_audio_content"
+      description "A tool that returns audio content"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new([MCP::Content::Audio.new(BASE64_MINIMAL_WAV, "audio/wav").to_h])
+        end
+      end
+    end
+
+    class TestEmbeddedResource < MCP::Tool
+      tool_name "test_embedded_resource"
+      description "A tool that returns embedded resource content"
+
+      class << self
+        def call(**_args)
+          text_contents = MCP::Resource::TextContents.new(
+            uri: "test://embedded-resource",
+            mime_type: "text/plain",
+            text: "This is an embedded resource content.",
+          )
+          MCP::Tool::Response.new([MCP::Content::EmbeddedResource.new(text_contents).to_h])
+        end
+      end
+    end
+
+    class TestMultipleContentTypes < MCP::Tool
+      tool_name "test_multiple_content_types"
+      description "A tool that returns multiple content types"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new([
+            MCP::Content::Text.new("Multiple content types test:").to_h,
+            MCP::Content::Image.new(BASE64_1X1_PNG, "image/png").to_h,
+            MCP::Content::EmbeddedResource.new(
+              MCP::Resource::TextContents.new(
+                uri: "test://mixed-content-resource",
+                mime_type: "application/json",
+                text: '{"test":"data","value":123}',
+              ),
+            ).to_h,
+          ])
+        end
+      end
+    end
+
+    class TestErrorHandling < MCP::Tool
+      tool_name "test_error_handling"
+      description "A tool that intentionally returns an error for testing"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("This tool intentionally returns an error for testing").to_h],
+            error: true,
+          )
+        end
+      end
+    end
+
+    class JsonSchema202012Tool < MCP::Tool
+      tool_name "json_schema_2020_12_tool"
+      description "Tool with JSON Schema 2020-12 features"
+      input_schema(
+        "$schema": "https://json-schema.org/draft/2020-12/schema",
+        "$defs": {
+          address: {
+            type: "object",
+            properties: {
+              street: { type: "string" },
+              city: { type: "string" },
+            },
+          },
+        },
+        properties: {
+          name: { type: "string" },
+          address: { "$ref": "#/$defs/address" },
+        },
+        additionalProperties: false,
+      )
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new([MCP::Content::Text.new("Processed with JSON Schema 2020-12").to_h])
+        end
+      end
+    end
+
+    class TestToolWithLogging < MCP::Tool
+      tool_name "test_tool_with_logging"
+      description "A tool that sends log messages during execution"
+
+      class << self
+        def call(server_context:, **_args)
+          server_context.notify_log_message(data: "Tool execution started", level: "info", logger: "test_logger")
+          sleep(0.05) # Required by the conformance test to verify clients handle interleaved notifications (same as TypeScript SDK).
+          server_context.notify_log_message(data: "Tool processing data", level: "info", logger: "test_logger")
+          sleep(0.05) # Same as above.
+          server_context.notify_log_message(data: "Tool execution completed", level: "info", logger: "test_logger")
+          MCP::Tool::Response.new([MCP::Content::Text.new("Logging complete (3 messages sent)").to_h])
+        end
+      end
+    end
+
+    # test_tool_with_progress: the actual progress dispatch is in `tools_call_handler`
+    class TestToolWithProgress < MCP::Tool
+      tool_name "test_tool_with_progress"
+      description "A tool that reports progress notifications"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new([MCP::Content::Text.new("Progress complete").to_h])
+        end
+      end
+    end
+
+    # TODO: Implement when `Transport` supports server-to-client requests.
+    class TestSampling < MCP::Tool
+      tool_name "test_sampling"
+      description "A tool that requests LLM sampling from the client"
+      input_schema(
+        properties: { prompt: { type: "string" } },
+        required: ["prompt"],
+      )
+
+      class << self
+        def call(prompt:)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Sampling not supported in this SDK version").to_h],
+            error: true,
+          )
+        end
+      end
+    end
+
+    # TODO: Implement when `Transport` supports server-to-client requests.
+    class TestElicitation < MCP::Tool
+      tool_name "test_elicitation"
+      description "A tool that requests user input from the client"
+      input_schema(
+        properties: { message: { type: "string" } },
+        required: ["message"],
+      )
+
+      class << self
+        def call(message:)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Elicitation not supported in this SDK version").to_h],
+            error: true,
+          )
+        end
+      end
+    end
+
+    # TODO: Implement when `Transport` supports server-to-client requests.
+    class TestElicitationSep1034Defaults < MCP::Tool
+      tool_name "test_elicitation_sep1034_defaults"
+      description "A tool that tests elicitation with default values"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Elicitation not supported in this SDK version").to_h],
+            error: true,
+          )
+        end
+      end
+    end
+
+    # TODO: Implement when `Transport` supports server-to-client requests.
+    class TestElicitationSep1330Enums < MCP::Tool
+      tool_name "test_elicitation_sep1330_enums"
+      description "A tool that tests elicitation with enum schemas"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Elicitation not supported in this SDK version").to_h],
+            error: true,
+          )
+        end
+      end
+    end
+
+    class TestReconnection < MCP::Tool
+      tool_name "test_reconnection"
+      description "A tool that triggers SSE stream closure to test client reconnection behavior"
+
+      class << self
+        def call(**_args)
+          MCP::Tool::Response.new([MCP::Content::Text.new("Reconnection test completed").to_h])
+        end
+      end
+    end
+  end
+
+  module Prompts
+    class TestSimplePrompt < MCP::Prompt
+      prompt_name "test_simple_prompt"
+      description "A simple prompt for testing with no arguments"
+
+      class << self
+        def template(_args, server_context: nil)
+          MCP::Prompt::Result.new(
+            messages: [
+              MCP::Prompt::Message.new(
+                role: "user",
+                content: MCP::Content::Text.new("This is a simple prompt for testing."),
+              ),
+            ],
+          )
+        end
+      end
+    end
+
+    class TestPromptWithArguments < MCP::Prompt
+      prompt_name "test_prompt_with_arguments"
+      description "A prompt with required arguments for testing"
+      arguments [
+        MCP::Prompt::Argument.new(name: "arg1", description: "First test argument", required: true),
+        MCP::Prompt::Argument.new(name: "arg2", description: "Second test argument", required: true),
+      ]
+
+      class << self
+        def template(args, server_context: nil)
+          arg1 = args.dig(:arg1) || args.dig("arg1") || ""
+          arg2 = args.dig(:arg2) || args.dig("arg2") || ""
+          MCP::Prompt::Result.new(
+            messages: [
+              MCP::Prompt::Message.new(
+                role: "user",
+                content: MCP::Content::Text.new("Prompt with arguments: arg1='#{arg1}', arg2='#{arg2}'"),
+              ),
+            ],
+          )
+        end
+      end
+    end
+
+    class TestPromptWithEmbeddedResource < MCP::Prompt
+      prompt_name "test_prompt_with_embedded_resource"
+      description "A prompt with an embedded resource for testing"
+      arguments [
+        MCP::Prompt::Argument.new(name: "resourceUri", description: "URI of the resource to embed", required: true),
+      ]
+
+      class << self
+        def template(args, server_context: nil)
+          resource_uri = args.dig(:resourceUri) || args.dig("resourceUri") || "test://example-resource"
+          MCP::Prompt::Result.new(
+            messages: [
+              MCP::Prompt::Message.new(
+                role: "user",
+                content: MCP::Content::EmbeddedResource.new(
+                  MCP::Resource::TextContents.new(
+                    uri: resource_uri,
+                    mime_type: "text/plain",
+                    text: "Embedded resource content for testing.",
+                  ),
+                ),
+              ),
+              MCP::Prompt::Message.new(
+                role: "user",
+                content: MCP::Content::Text.new("Please process the embedded resource above."),
+              ),
+            ],
+          )
+        end
+      end
+    end
+
+    class TestPromptWithImage < MCP::Prompt
+      prompt_name "test_prompt_with_image"
+      description "A prompt with image content for testing"
+
+      class << self
+        def template(_args, server_context: nil)
+          MCP::Prompt::Result.new(
+            messages: [
+              MCP::Prompt::Message.new(
+                role: "user",
+                content: MCP::Content::Image.new(BASE64_1X1_PNG, "image/png"),
+              ),
+              MCP::Prompt::Message.new(
+                role: "user",
+                content: MCP::Content::Text.new("Please analyze the image above."),
+              ),
+            ],
+          )
+        end
+      end
+    end
+  end
+
+  class Server
+    DEFAULT_PORT = 9292
+
+    class DnsRebindingProtection
+      LOCALHOST_PATTERNS = /\A(localhost|127\.0\.0\.1|\[::1\]|::1)(:\d+)?\z/i.freeze
+
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        host = env["HTTP_HOST"] || env["SERVER_NAME"] || ""
+
+        unless localhost?(host)
+          return [
+            403,
+            { "Content-Type" => "application/json" },
+            [{ error: "Forbidden: DNS rebinding protection - invalid Host header '#{host}'" }.to_json],
+          ]
+        end
+
+        origin = env["HTTP_ORIGIN"]
+        if origin && !origin.empty?
+          begin
+            origin_host = URI.parse(origin).host.to_s
+            unless localhost?(origin_host)
+              return [
+                403,
+                { "Content-Type" => "application/json" },
+                [{ error: "Forbidden: DNS rebinding protection - invalid Origin '#{origin}'" }.to_json],
+              ]
+            end
+          rescue URI::InvalidURIError
+            return [
+              403,
+              { "Content-Type" => "application/json" },
+              [{ error: "Forbidden: invalid Origin header" }.to_json],
+            ]
+          end
+        end
+
+        @app.call(env)
+      end
+
+      private
+
+      def localhost?(host)
+        host.empty? || host.match?(LOCALHOST_PATTERNS)
+      end
+    end
+
+    def initialize(port: DEFAULT_PORT)
+      @port = port
+    end
+
+    def start
+      server = build_server
+      transport = build_transport(server)
+      configure_handlers(server)
+      rack_app = build_rack_app(transport)
+
+      puts <<~MESSAGE
+        MCP Conformance Server starting on http://localhost:#{@port}/mcp
+        Use Ctrl-C to stop
+      MESSAGE
+
+      Rackup::Handler.get("puma").run(rack_app, Port: @port, Host: "localhost", Silent: true)
+    end
+
+    private
+
+    def build_server
+      MCP::Server.new(
+        name: "ruby-sdk-conformance-server",
+        version: MCP::VERSION,
+        tools: [
+          Tools::TestSimpleText,
+          Tools::TestImageContent,
+          Tools::TestAudioContent,
+          Tools::TestEmbeddedResource,
+          Tools::TestMultipleContentTypes,
+          Tools::TestErrorHandling,
+          Tools::JsonSchema202012Tool,
+          Tools::TestToolWithLogging,
+          Tools::TestToolWithProgress,
+          Tools::TestSampling,
+          Tools::TestElicitation,
+          Tools::TestElicitationSep1034Defaults,
+          Tools::TestElicitationSep1330Enums,
+          Tools::TestReconnection,
+        ],
+        prompts: [
+          Prompts::TestSimplePrompt,
+          Prompts::TestPromptWithArguments,
+          Prompts::TestPromptWithEmbeddedResource,
+          Prompts::TestPromptWithImage,
+        ],
+        resources: resources,
+        resource_templates: resource_templates,
+        capabilities: {
+          tools: { listChanged: true },
+          prompts: { listChanged: true },
+          resources: { listChanged: true, subscribe: true },
+          logging: {},
+          completions: {},
+        },
+      )
+    end
+
+    def resources
+      [
+        MCP::Resource.new(
+          uri: "test://static-text",
+          name: "static-text",
+          description: "A static text resource for testing",
+          mime_type: "text/plain",
+        ),
+        MCP::Resource.new(
+          uri: "test://static-binary",
+          name: "static-binary",
+          description: "A static binary (PNG) resource for testing",
+          mime_type: "image/png",
+        ),
+        MCP::Resource.new(
+          uri: "test://watched-resource",
+          name: "watched-resource",
+          description: "A resource for subscription testing",
+          mime_type: "text/plain",
+        ),
+      ]
+    end
+
+    def resource_templates
+      [
+        MCP::ResourceTemplate.new(
+          uri_template: "test://template/{id}/data",
+          name: "template-resource",
+          description: "A parameterized resource template for testing",
+          mime_type: "application/json",
+        ),
+      ]
+    end
+
+    def build_transport(server)
+      transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
+      server.transport = transport
+      transport
+    end
+
+    def configure_handlers(server)
+      server.logging_message_notification = MCP::LoggingMessageNotification.new(level: "debug")
+      server.server_context = server
+
+      configure_resources_read_handler(server)
+    end
+
+    def configure_resources_read_handler(server)
+      server.resources_read_handler do |params|
+        uri = params[:uri].to_s
+
+        case uri
+        when "test://static-text"
+          [
+            MCP::Resource::TextContents.new(
+              text: "This is the content of the static text resource.",
+              uri: uri,
+              mime_type: "text/plain",
+            ).to_h,
+          ]
+        when "test://static-binary"
+          [
+            MCP::Resource::BlobContents.new(
+              data: BASE64_1X1_PNG,
+              uri: uri,
+              mime_type: "image/png",
+            ).to_h,
+          ]
+        when %r{\Atest://template/(.+)/data\z}
+          id = Regexp.last_match(1)
+          content = { id: id, templateTest: true, data: "Data for ID: #{id}" }.to_json
+
+          [
+            MCP::Resource::TextContents.new(
+              text: content,
+              uri: uri,
+              mime_type: "application/json",
+            ).to_h,
+          ]
+        else
+          []
+        end
+      end
+    end
+
+    def build_rack_app(transport)
+      mcp_app = proc do |env|
+        request = Rack::Request.new(env)
+
+        if request.path_info == "/health"
+          [200, { "Content-Type" => "application/json" }, ['{"status":"ok"}']]
+        elsif request.path_info == "/mcp" || request.path_info == "/"
+          transport.handle_request(request)
+        else
+          [404, { "Content-Type" => "application/json" }, ['{"error":"Not found"}']]
+        end
+      end
+
+      Rack::Builder.new do
+        use(DnsRebindingProtection)
+        run(mcp_app)
+      end
+    end
+  end
+end

data/lib/mcp/content.rb

@@ -25,7 +25,34 @@ module MCP
       end
 
       def to_h
-        { data: data, mime_type: mime_type, annotations: annotations, type: "image" }.compact
+        { data: data, mimeType: mime_type, annotations: annotations, type: "image" }.compact
+      end
+    end
+
+    class Audio
+      attr_reader :data, :mime_type, :annotations
+
+      def initialize(data, mime_type, annotations: nil)
+        @data = data
+        @mime_type = mime_type
+        @annotations = annotations
+      end
+
+      def to_h
+        { data: data, mimeType: mime_type, annotations: annotations, type: "audio" }.compact
+      end
+    end
+
+    class EmbeddedResource
+      attr_reader :resource, :annotations
+
+      def initialize(resource, annotations: nil)
+        @resource = resource
+        @annotations = annotations
+      end
+
+      def to_h
+        { resource: resource.to_h, annotations: annotations, type: "resource" }.compact
       end
     end
   end

data/lib/mcp/prompt.rb

@@ -21,7 +21,7 @@ module MCP
           title: title_value,
           description: description_value,
           icons: icons_value&.then { |icons| icons.empty? ? nil : icons.map(&:to_h) },
-          arguments: arguments_value&.map(&:to_h),
+          arguments: arguments_value.empty? ? nil : arguments_value.map(&:to_h),
           _meta: meta_value,
         }.compact
       end
@@ -32,7 +32,7 @@ module MCP
         subclass.instance_variable_set(:@title_value, nil)
         subclass.instance_variable_set(:@description_value, nil)
         subclass.instance_variable_set(:@icons_value, nil)
-        subclass.instance_variable_set(:@arguments_value, nil)
+        subclass.instance_variable_set(:@arguments_value, [])
         subclass.instance_variable_set(:@meta_value, nil)
       end
 
@@ -76,7 +76,7 @@ module MCP
         if value == NOT_SET
           @arguments_value
         else
-          @arguments_value = value
+          @arguments_value = Array(value)
         end
       end
 
@@ -103,6 +103,7 @@ module MCP
       end
 
       def validate_arguments!(args)
+        args ||= {}
         missing = required_args - args.keys
         return if missing.empty?
 

data/lib/mcp/server/transports/streamable_http_transport.rb

@@ -19,6 +19,7 @@ module MCP
 
         REQUIRED_POST_ACCEPT_TYPES = ["application/json", "text/event-stream"].freeze
         REQUIRED_GET_ACCEPT_TYPES = ["text/event-stream"].freeze
+        STREAM_WRITE_ERRORS = [IOError, Errno::EPIPE, Errno::ECONNRESET].freeze
 
         def handle_request(request)
           case request.env["REQUEST_METHOD"]
@@ -58,7 +59,7 @@ module MCP
               begin
                 send_to_stream(session[:stream], notification)
                 true
-              rescue IOError, Errno::EPIPE => e
+              rescue *STREAM_WRITE_ERRORS => e
                 MCP.configuration.exception_reporter.call(
                   e,
                   { session_id: session_id, error: "Failed to send notification" },
@@ -77,7 +78,7 @@ module MCP
                 begin
                   send_to_stream(session[:stream], notification)
                   sent_count += 1
-                rescue IOError, Errno::EPIPE => e
+                rescue *STREAM_WRITE_ERRORS => e
                   MCP.configuration.exception_reporter.call(
                     e,
                     { session_id: sid, error: "Failed to send notification" },
@@ -288,8 +289,8 @@ module MCP
         def send_response_to_stream(stream, response, session_id)
           message = JSON.parse(response)
           send_to_stream(stream, message)
-          [200, { "Content-Type" => "application/json" }, [{ accepted: true }.to_json]]
-        rescue IOError, Errno::EPIPE => e
+          handle_accepted
+        rescue *STREAM_WRITE_ERRORS => e
           MCP.configuration.exception_reporter.call(
             e,
             { session_id: session_id, error: "Stream closed during response" },
@@ -366,7 +367,7 @@ module MCP
               send_ping_to_stream(@sessions[session_id][:stream])
             end
           end
-        rescue IOError, Errno::EPIPE => e
+        rescue *STREAM_WRITE_ERRORS => e
           MCP.configuration.exception_reporter.call(
             e,
             { session_id: session_id, error: "Stream closed" },

data/lib/mcp/server.rb

@@ -99,9 +99,9 @@ module MCP
         Methods::LOGGING_SET_LEVEL => method(:configure_logging_level),
 
         # No op handlers for currently unsupported methods
-        Methods::RESOURCES_SUBSCRIBE => ->(_) {},
-        Methods::RESOURCES_UNSUBSCRIBE => ->(_) {},
-        Methods::COMPLETION_COMPLETE => ->(_) {},
+        Methods::RESOURCES_SUBSCRIBE => ->(_) { {} },
+        Methods::RESOURCES_UNSUBSCRIBE => ->(_) { {} },
+        Methods::COMPLETION_COMPLETE => ->(_) { { completion: { values: [], hasMore: false } } },
         Methods::ELICITATION_CREATE => ->(_) {},
       }
       @transport = transport
@@ -219,6 +219,14 @@ module MCP
           message = "Error occurred in server_info. `description` is not supported in protocol version 2025-06-18 or earlier"
           raise ArgumentError, message
         end
+
+        tools_with_ref = @tools.each_with_object([]) do |(tool_name, tool), names|
+          names << tool_name if schema_contains_ref?(tool.input_schema_value.to_h)
+        end
+        unless tools_with_ref.empty?
+          message = "Error occurred in #{tools_with_ref.join(", ")}. `$ref` in input schemas is supported by protocol version 2025-11-25 or higher"
+          raise ArgumentError, message
+        end
       end
 
       if @configuration.protocol_version <= "2025-03-26"
@@ -259,6 +267,17 @@ module MCP
       raise ToolNotUnique, duplicated_tool_names unless duplicated_tool_names.empty?
     end
 
+    def schema_contains_ref?(schema)
+      case schema
+      when Hash
+        schema.any? { |key, value| key.to_s == "$ref" || schema_contains_ref?(value) }
+      when Array
+        schema.any? { |element| schema_contains_ref?(element) }
+      else
+        false
+      end
+    end
+
     def handle_request(request, method)
       handler = @handlers[method]
       unless handler

data/lib/mcp/tool/schema.rb

@@ -31,10 +31,6 @@ module MCP
         case schema
         when Hash
           schema.each_with_object({}) do |(key, value), result|
-            if key.casecmp?("$ref")
-              raise ArgumentError, "Invalid JSON Schema: $ref is not allowed in tool schemas"
-            end
-
             result[yield(key)] = deep_transform_keys(value, &block)
           end
         when Array

data/lib/mcp/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MCP
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mcp
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Model Context Protocol
@@ -33,6 +33,7 @@ files:
 - ".gitattributes"
 - ".github/dependabot.yml"
 - ".github/workflows/ci.yml"
+- ".github/workflows/conformance.yml"
 - ".github/workflows/release.yml"
 - ".gitignore"
 - ".rubocop.yml"
@@ -49,6 +50,10 @@ files:
 - bin/generate-gh-pages.sh
 - bin/rake
 - bin/setup
+- conformance/README.md
+- conformance/expected_failures.yml
+- conformance/runner.rb
+- conformance/server.rb
 - dev.yml
 - docs/_config.yml
 - docs/index.md
@@ -99,7 +104,7 @@ licenses:
 - Apache-2.0
 metadata:
   allowed_push_host: https://rubygems.org
-  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v0.7.1
+  changelog_uri: https://github.com/modelcontextprotocol/ruby-sdk/releases/tag/v0.8.0
   homepage_uri: https://github.com/modelcontextprotocol/ruby-sdk
   source_code_uri: https://github.com/modelcontextprotocol/ruby-sdk
   bug_tracker_uri: https://github.com/modelcontextprotocol/ruby-sdk/issues