216 changed files with 4034 additions and 47932 deletions
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@ -9,7 +9,7 @@ jobs:
    strategy:
      matrix:
        entry:
-          - { ruby: '2.7.0', allowed-failure: false } # Minimum supported Ruby version.
+          - { ruby: '2.7', allowed-failure: false }
          - { ruby: '3.0', allowed-failure: false }
          - { ruby: '3.1', allowed-failure: false }
          - { ruby: '3.2', allowed-failure: false }
@ -19,7 +19,7 @@ jobs:
          - { ruby: 'head', allowed-failure: true }
    name: Test Ruby ${{ matrix.entry.ruby }}
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: ${{ matrix.entry.ruby }}
@ -33,7 +33,7 @@ jobs:
      contents: read
    name: RuboCop
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: 4.0 # Specify the latest supported Ruby version.
@ -46,7 +46,7 @@ jobs:
      contents: read
    name: YARD Documentation
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
      - uses: ruby/setup-ruby@v1
        with:
          ruby-version: 4.0 # Specify the latest supported Ruby version.
--- a/.github/workflows/conformance.yml
+++ b/.github/workflows/conformance.yml
@ -7,7 +7,7 @@ on:
  workflow_dispatch:

 concurrency:
-  group: conformance-${{ github.ref }}-${{ github.event_name == 'push' && github.sha || '' }}
+  group: conformance-${{ github.ref }}
  cancel-in-progress: true

 permissions:
@ -18,12 +18,12 @@ jobs:
    runs-on: ubuntu-latest
    continue-on-error: true
    steps:
-      - uses: actions/checkout@v7
+      - 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@v7
+      - uses: actions/setup-node@v6
        with:
          node-version: '24' # Specify the latest Node.js version.
-      - run: bundle exec rake conformance:test
+      - run: bundle exec rake conformance
--- a/.github/workflows/release.yml
+++ b/.github/workflows/release.yml
@ -16,7 +16,7 @@ jobs:
      id-token: write # IMPORTANT: this permission is mandatory for trusted publishing
      contents: write # IMPORTANT: this permission is required for `rake release` to push the release tag
    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
      - name: Set up Ruby
        uses: ruby/setup-ruby@v1
        with:
@ -34,7 +34,7 @@ jobs:
      contents: write

    steps:
-      - uses: actions/checkout@v7
+      - uses: actions/checkout@v6
        with:
          fetch-depth: 0 # Fetch all history for all branches and tags

--- a/.gitignore
+++ b/.gitignore
@ -9,7 +9,3 @@
 /spec/reports/
 /tmp/
 Gemfile.lock
-docs/_site/
-docs/.jekyll-cache/
-docs/.jekyll-metadata
-docs/_data/versions.yml
--- a/.rubocop.yml
+++ b/.rubocop.yml
@ -7,7 +7,6 @@ plugins:

 AllCops:
  TargetRubyVersion: 2.7
-  SuggestExtensions: false

 Gemspec/DevelopmentDependencies:
  Enabled: true
@ -17,7 +16,3 @@ Lint/IncompatibleIoSelectWithFiberScheduler:

 Minitest/LiteralAsActualArgument:
  Enabled: true
-
-Naming/MethodName:
-  AllowedPatterns:
-    - '\Atest_'
--- a/AGENTS.md
+++ b/AGENTS.md
@ -15,9 +15,7 @@ This is the official Ruby SDK for the Model Context Protocol (MCP), implementing
 - `bundle install` - Install dependencies
 - `rake test` - Run all tests
 - `rake rubocop` - Run linter
- `rake` - Run linting, tests, and the conformance suite (default task)
- `bundle exec rake conformance:test` - Run the MCP conformance suite (see conformance/README.md)
- `bundle exec rake docs:preview` - Serve the documentation site locally at http://localhost:4000 (PORT to override)
+- `rake` - Run tests and linting (default task)
 - `ruby -I lib -I test test/path/to/specific_test.rb` - Run single test file
 - `gem build mcp.gemspec` - Build the gem

@ -34,15 +32,6 @@ This is the official Ruby SDK for the Model Context Protocol (MCP), implementing
 - Use frozen string literals
 - Follow Ruby community conventions
 - Keep dependencies minimal
- Use lowercase HTTP response header names (e.g. `mcp-session-id`); the Rack 3 SPEC requires this, and the MCP spec's `Mcp-Session-Id` casing is prose convention only
-
-## Documentation
-
- User-facing documentation lives in `docs/`, one page per topic, published at https://ruby.sdk.modelcontextprotocol.io (deploys only when a release is published)
- Pages live in the `docs/_server/`, `docs/_client/`, and `docs/_extensions/` collections
- Keep README.md slim: quick start and pointers only; document features on the relevant docs page
- Internal links are absolute and extensionless (e.g. `/server/tools/`); front matter is followed by a blank line before the h1
- Callout tiers: `.note` (supplementary), `.important` (spec constraints), `.warning` (deprecated features)

 ## Commit message conventions

@ -127,6 +116,6 @@ This is the official Ruby SDK for the Model Context Protocol (MCP), implementing

 ### Integration patterns

- **Rails/Rack apps**: Mount `StreamableHTTPTransport` as a Rack app (e.g., `mount transport => "/mcp"`)
+- **Rails controllers**: Use `server.handle_json(request.body.read)` for HTTP endpoints
 - **Command-line tools**: Use `StdioTransport.new(server).open` for CLI applications
- **HTTP services**: Use `StreamableHTTPTransport` for web-based servers
+- **HTTP services**: Use `StreamableHttpTransport` for web-based servers
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -7,377 +7,6 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0

 ## [Unreleased]

-## [1.5.1] - 2026-09-09
-
-This release keeps the HTTP client working with json 3.0. That release accepts the options of `JSON.parse`
-as keywords only, and Faraday's JSON response middleware, through 2.14.3, passes them as a positional Hash,
-which Ruby 3 no longer converts, so every JSON body the client received failed as an internal error.
-The client now parses response bodies itself, the way it already handled streamed ones, and no longer
-registers the middleware. A malformed JSON body delivered whole by an adapter without streaming support
-now raises `RequestHandlerError` with `error_type: :parse_error`, as the streamed path already did.
-
-### Fixed
-
- Parse HTTP client response bodies without Faraday's JSON middleware, which json 3.0 breaks (#546)
-
-## [1.5.0] - 2026-09-05
-
-This release makes the client answer a server's `ping` with the empty result the specification requires.
-Earlier clients replied with Method not found over Streamable HTTP and stayed silent over stdio,
-so a server that checks liveness dropped their long-lived sessions. On the OAuth side,
-the embedding application can refuse an authorization request through `authorization_request_validator`,
-and stored tokens are refreshed only against the authorization server that issued them:
-when the server named for a session differs, the client reauthorizes instead of refreshing,
-and the validator sees the newly named server. Tokens stored by earlier releases carry no issuer and keep refreshing.
-
-### Added
-
- Add `authorization_request_validator` to let the embedding application refuse an authorization request (#539)
-
-### Fixed
-
- Answer server-to-client pings in the client (#541)
-
-## [1.4.0] - 2026-08-28
-
-This release repairs the `subscriptions/listen` stream. A host that buffers its responses,
-the documented Rails controller pattern among them, can decline the method with
-`serve_subscriptions_listen: false` instead of answering a modern client with a streaming body
-it cannot render, and the stream's ordering guarantees are enforced: no notification reaches
-a client before the acknowledgement, and none follows the graceful closing result.
-
-### Added
-
- Add `serve_subscriptions_listen:` for hosts that cannot hold an SSE stream open (#533)
-
-### Fixed
-
- Deliver `subscriptions/listen` notifications only after the acknowledgement (#532)
- Serialize `subscriptions/listen` writes so the graceful result is the final message (#535)
-
-## [1.3.0] - 2026-08-22
-
-User-facing documentation now lives on the documentation site at https://ruby.sdk.modelcontextprotocol.io,
-and README.md keeps the quick start. Two entries under "Changed" reject traffic that earlier releases accepted
-and ship in a minor release under the exceptions described in [VERSIONING.md](VERSIONING.md).
-
-### Added
-
- Add a `resources_list_handler` for context-dependent resource lists (#509)
- Pass a handler-returned `_meta` through the subscribe result (#510)
-
-### Changed
-
- Bound OAuth response bodies in the client (#520)
- Reject duplicate in-flight JSON-RPC request ids (#521)
- Move the documentation from README.md to the documentation site (#523)
-
-## [1.2.0] - 2026-08-15
-
-This release completes the SEP-2575 stateless lifecycle of the 2026-07-28 specification, together with
-the SEP-2322, SEP-2549, and SEP-2243 features that revision builds on. Several entries under "Changed"
-are incompatible with 1.1.0 and ship in a minor release under the spec-conformance and security exceptions
-described in [VERSIONING.md](VERSIONING.md).
-
-### Added
-
- Handle the SEP-2575 modern request envelope in the server core (#475)
- Serve both lifecycle eras over stdio with an era lock per SEP-2575 (#478)
- Serve the sessionless modern path over Streamable HTTP per SEP-2575 (#479)
- Finalize `server/discover` and add client modern lifecycle support per SEP-2575 (#480)
- Let handlers return multi round-trip `input_required` results per SEP-2322 (#481)
- Add `MCP::Elicitation::EnumSchema` builders per SEP-1330 (#482)
- Stamp the required `resultType` on modern results per SEP-2322 (#487)
- Enforce the modern lifecycle admission rules per SEP-2575 (#489)
- Stream modern request notifications and honor the envelope `logLevel` per SEP-2575 (#490)
- Expose the user-defined `server_context` in instrumentation data (#493)
- Serve the `subscriptions/listen` notification stream per SEP-2575 (#495)
- Add opt-in `requestState` sealing via `MCP::Server::RequestStateSecurity` (#496)
- Mirror `x-mcp-header` tool parameters into `Mcp-Param-*` headers per SEP-2243 (#498)
- Stamp the required cache hints on modern cacheable results per SEP-2549 (#499)
- Drive multi round-trip `input_required` results on the client per SEP-2322 (#500)
- Fulfill `input_required` results on the legacy wire per SEP-2322 (#501)
-
-### Changed
-
- Align modern envelope validation with the finalized specification (#491)
- Require the `Mcp-Method` header on the modern path (#492)
- Bound server-to-client requests with a timeout (#502)
- Refuse server-to-client requests in the modern lifecycle per SEP-2575 (#503)
- Bound the total wait across SSE reconnection attempts (#504)
- Bound automatic pagination in the MCP client (#505)
- Reject modern-removed methods before the connection era locks (#511)
- Stop negotiating modern protocol versions through the `initialize` handshake (#516)
-
-### Deprecated
-
- Warn on modern client connects that declare the Roots or Sampling capabilities deprecated per SEP-2577 (#406, #516)
-
-### Fixed
-
- Stop leaking exception messages to clients via JSON-RPC error data (#486)
- Return Invalid Params for unknown prompts and missing prompt arguments (#517)
- Restrict OAuth discovery to same-origin metadata URLs and refuse private-network destinations
-
-## [1.1.0] - 2026-08-01
-
-### Added
-
- Support 2026-07-28 as the Latest Protocol Version (#476)
- Expose server tool annotations on MCP::Client::Tool (#445)
-
-### Fixed
-
- Preserve explicit tool response content (#469)
-
-## [1.0.0] - 2026-07-24
-
-First stable release. The public API is now stable: breaking changes ship only in major releases,
-apart from the narrow exceptions documented in [VERSIONING.md](VERSIONING.md).
-
-### Added
-
- Add `ROADMAP.md` outlining the path toward SEP-1730 (#465)
- Add `VERSIONING.md` documenting the versioning and breaking-change policy (#466)
-
-## [0.25.0] - 2026-07-18
-
-### Added
-
- Support SEP-990 Cross-App Access via ID-JAG and the `jwt-bearer` grant (#454)
- Support client-side sampling via `MCP::Client#on_sampling` (#458)
-
-### Fixed
-
- Reject notifications carrying an unknown or expired session (#455)
- Handle an `initialize` request sent without an ID (#456)
- Bound client-side message buffering in the HTTP transport (#459)
- Lowercase response header names in `StreamableHTTPTransport` (#460)
-
-## [0.24.0] - 2026-07-12
-
-### Added
-
- Support SSE reconnection per SEP-1699 in the HTTP client transport (#426)
- Validate the RFC 9207 `iss` authorization response parameter per SEP-2468 (#431)
- Support `private_key_jwt` client authentication for the `client_credentials` grant (#432)
- Recognize multi round-trip `input_required` results per SEP-2322 (#433)
- Add opt-in `ttlMs` / `cacheScope` cache hints to List and Read results per SEP-2549 (#436)
- Add `server/discover` and stateless lifecycle error codes per SEP-2575 (#438)
- Associate server-to-client requests with the originating client request per SEP-2260 (#440)
- Add server-side MCP Apps helpers per SEP-1865 (#441)
- Support client-side elicitation with SEP-1034 schema defaults (#443)
- Support class-based Resource and ResourceTemplate definitions (#447)
-
-### Changed
-
- Bind stored client credentials to the authorization server issuer per SEP-2352 (#439)
-
-### Fixed
-
- Handle non-object JSON-RPC messages without raising (#448)
- Perform SSE stream writes outside the session mutex (#449)
- Validate required params for `initialize` and `resources/subscribe` (#451)
-
-## [0.23.0] - 2026-07-07
-
-### Added
-
- Add a session-ownership hook to `StreamableHTTPTransport`
-
-### Changed
-
- Require calling `MCP::Client#connect` before sending requests on stdio transport (#427)
-
-### Deprecated
-
- Annotate Roots, Sampling, and Logging APIs as deprecated per SEP-2577 (#429)
-
-### Fixed
-
- Fix an incorrect `result: null` response to an id-bearing notification message (#435)
- Validate `Host` and `Origin` headers to prevent DNS rebinding per MCP 2025-11-25
- Bound stateful session retention to prevent an initialize-flood DoS
- Bound stdio frame reads with `max_line_bytes`
- Bound request body and frame reads to prevent memory-exhaustion DoS
-
-## [0.22.0] - 2026-06-27
-
-### Added
-
- Add `audience` role validation for `MCP::Annotations` per MCP specification (#422)
- Send SEP-2243 `Mcp-Method` and `Mcp-Name` headers per MCP specification (#423)
- Support client-side `notifications/cancelled` per MCP specification (#425)
-
-### Changed
-
- Conform Tool Schemas to JSON Schema 2020-12 per SEP-2106 (#417)
-
-### Fixed
-
- Fix a `SyntaxError` on Ruby 2.7.0 caused by arguments forwarding syntax (#419)
-
-## [0.21.0] - 2026-06-20
-
-### Added
-
- Support capability extensions per SEP-2133 (#405)
- Add range validation for `MCP::Annotations#priority` per MCP specification (#410)
- Isolate stateless requests in ephemeral sessions per SEP-2567 (#415)
-
-### Changed
-
- Set OIDC `application_type` on Dynamic Client Registration per SEP-837 (#408)
- Fall back to legacy 2025-03-26 OAuth discovery for servers without PRM (#414)
-
-## [0.20.0] - 2026-06-14
-
-### Added
-
- Support W3C Trace Context Propagation via `_meta` per SEP-414 (#397)
- Support OAuth `client_credentials` grant in OAuth client (#399)
- Add `annotations` field to `MCP::Resource` and `MCP::ResourceTemplate` per MCP specification (#403)
-
-### Changed
-
- Re-run OAuth flow on 403 `insufficient_scope` (step-up) (#368)
- Speed up `Tool::Schema` validation by 5x to 100x (#369)
- Use JSON-RPC error envelope for `StreamableHTTPTransport` errors (#371)
- Pin RFC 8414 default well-known suffix per SEP-2351 (#395)
- Default missing `MCP-Protocol-Version` to `2025-03-26` in `StreamableHTTPTransport` (#392)
-
-### Fixed
-
- Preserve the request ID in invalid request error responses (#400)
- Standardize Resource Not Found errors on -32602 with URI data per SEP-2164 (#402)
-
-## [0.19.0] - 2026-06-13
-
-### Added
-
- Support Client ID Metadata Documents in OAuth client (#361)
- Request `offline_access` scope when supported (#365)
- Add `size` field to `MCP::Resource` per MCP specification (#393)
-
-## [0.18.0] - 2026-05-30
-
-### Added
-
- Support server-to-client `ping` per MCP specification (#358)
-
-### Changed
-
- Warn on implicit stdio initialization (#338)
- Cache `Tool::Schema` validation to avoid re-validating identical schemas (#363)
-
-### Fixed
-
- Fix case-sensitive `Accept` header comparison (#359)
-
-## [0.17.0] - 2026-05-19
-
-### Added
-
- Add OAuth 2.1 client support for MCP authorization flow (#353)
-
-### Fixed
-
- Validate `MCP-Protocol-Version` header in `StreamableHTTPTransport` (#347)
- Reject duplicate `initialize` requests (#350)
- Reject non-Hash JSON-RPC bodies in `StreamableHTTPTransport` (#354)
-
-## [0.16.0] - 2026-05-14
-
-### Added
-
- Add opt-in tool output validation (#344)
-
-### Changed
-
- Advertise JSON Schema 2020-12 dialect on emitted tool schemas (#342)
-
-### Fixed
-
- Preserve client tool output schemas (#343)
- Fix missing `output_schema` argument in `define_tool` API (#301)
-
-## [0.15.0] - 2026-05-05
-
-### Added
-
- Support `notifications/cancelled` per MCP specification (#332)
- Add client-level `connect` for initialize handshake (#327)
- Add client-level `connect` handshake to stdio transport (#336)
-
-### Changed
-
- Return tool argument validation failures as tool execution errors (#333)
-
-### Removed
-
- Remove obsolete `MCP::Transports` module (#331)
-
-## [0.14.0] - 2026-04-24
-
-### Added
-
- Support pagination per MCP specification (#320)
- Support resource subscriptions per MCP specification (#313)
- Add `roots/list` and `notifications/roots/list_changed` support (#315)
- Support JSON response mode for `StreamableHTTPTransport` (#328)
- Add HTTP client close for explicit session termination (#326)
- Track `Mcp-Session-Id` and protocol version in HTTP client (#325)
- Support `ping` client API per MCP specification (#324)
-
-### Fixed
-
- Handle 202 Accepted response in HTTP client (#323)
-
-### Changed
-
- Parse SSE responses in HTTP client via `event_stream_parser` (#322)
-
-## [0.13.0] - 2026-04-16
-
-### Added
-
- Make `StreamableHTTPTransport` a Rack application (#263)
- Support `elicitation/create` per MCP specification (#312)
- Add `around_request` hook for request instrumentation (#309)
- Add `_meta` field to resource, content, and result classes (#310)
-
-### Removed
-
- Remove `Server#create_sampling_message` direct call (#311)
-
-## [0.12.0] - 2026-04-11
-
-### Added
-
- Support customizing the Faraday client in `MCP::Client::HTTP` (#306)
-
-### Changed
-
- Auto-set `server.transport` in `Transport#initialize` (#305)
-
-### Fixed
-
- Validate Content-Type on POST requests (#304)
-
-## [0.11.0] - 2026-04-06
-
-### Added
-
- Support `sampling/createMessage` per MCP specification (#282)
- Support `completion/complete` per MCP specification (#289)
-
-### Fixed
-
- Support POST response SSE streams for server-to-client messages (#294)
- Return protocol errors for invalid arguments and server errors (#285)
- Fix client methods silently swallowing JSON-RPC error responses (#281)
- Close streams outside mutex in session cleanup (#291)
-
 ## [0.10.0] - 2026-03-30

 ### Added
--- a/CLAUDE.md
+++ b/CLAUDE.md
@ -1 +0,0 @@
-@AGENTS.md
--- a/5
+++ b/5
@ -6,7 +6,7 @@ source "https://rubygems.org"
 gemspec

 # Specify development dependencies below
-gem "rubocop-minitest", ">= 0.39.0", require: false
+gem "rubocop-minitest", require: false
 gem "rubocop-rake", require: false
 gem "rubocop-shopify", ">= 2.18", require: false if RUBY_VERSION >= "3.1"

@ -17,15 +17,12 @@ gem "rackup", ">= 2.1.0"
 gem "activesupport"
 # Fix io-console install error when Ruby 3.0.
 gem "debug" if RUBY_VERSION >= "3.1"
-# Avoid i18n 1.15.0, which breaks on Ruby 3.1 (ruby-i18n/i18n#735).
-gem "i18n", "!= 1.15.0"
 gem "rake", "~> 13.0"
 gem "sorbet-static-and-runtime" if RUBY_VERSION >= "3.0"
 gem "yard", "~> 0.9"
 gem "yard-sorbet", "~> 0.9" if RUBY_VERSION >= "3.1"

 group :test do
-  gem "event_stream_parser", ">= 1.0"
  gem "faraday", ">= 2.0"
  gem "minitest", "~> 5.1", require: false
  gem "mocha"
--- a/README.md
+++ b/README.md
--- a/ROADMAP.md
+++ b/ROADMAP.md
@ -1,51 +0,0 @@
-# Roadmap
-
-This roadmap outlines the MCP Ruby SDK's path toward SEP-1730 Tier 1.
-It is a living document and will evolve as the SDK matures.
-
-## Current Status
-
-The SDK implements the 2025-06-18, 2025-11-25, and 2026-07-28 spec revisions, and passes all scored server
-and client conformance scenarios for each revision's requirement set.
-Optional protocol extensions (such as DPoP, workload identity federation, and the tasks extension)
-are not yet implemented; SEP-1730 does not require extensions for any tier.
-
-## API Stability
-
-The 1.0.0 release marked the public API as stable: breaking changes ship only in major releases,
-apart from the narrow exceptions documented in [VERSIONING.md](VERSIONING.md),
-which also defines the Semantic Versioning scheme and breaking-change policy.
-
-## Deprecated Features
-
-The 2026-07-28 spec revision deprecates Roots, Sampling, and Logging (SEP-2577).
-These features remain supported throughout 1.x: on the legacy lifecycle they work unchanged
-(the deprecations do not apply there), and the 2026-07-28 lifecycle carries them through its own mechanisms:
-roots-shaped and sampling-shaped input requests embedded in `InputRequiredResult` responses
-(the SEP-2322 multi round-trip requests pattern) and per-request log delivery through the envelope's `logLevel`.
-The replacements SEP-2577 names live outside the protocol: tool parameters or configuration for roots,
-direct LLM provider APIs for sampling, and stderr or OpenTelemetry for logging.
-The client emits a deprecation warning when a modern connect declares the deprecated Roots or Sampling capabilities.
-Under Semantic Versioning their removal requires a major release, but no removal is scheduled yet: whether 2.0.0 removes
-them depends on how future MCP spec revisions treat these features and on adoption of their replacements.
-
-## Conformance
-
-The SDK maintains a 100% conformance pass rate as new scenarios are added to the conformance suite.
-Legacy SSE transport (2024-11-05) is intentionally out of scope; the SDK provides modern Streamable HTTP only.
-
-## Documentation
-
-Reference documentation covers all non-experimental features with examples.
-
-## Tracking New Spec Revisions
-
-The SDK aims to support each new MCP specification revision, with the implementation timeline agreed per
-release based on feature complexity.
-The 2026-07-28 revision shipped during 1.x: the server serves both lifecycle eras side by side,
-so the SEP-2575 stateless lifecycle (including `server/discover` and `subscriptions/listen`),
-SEP-2322 multi round-trip requests, SEP-2549 cache hints, and SEP-2243 custom headers are available alongside
-the legacy handshake. The few incompatible adjustments the revision required shipped in
-a minor release under the spec-conformance and security exceptions described in [VERSIONING.md](VERSIONING.md).
-Removing legacy-era support is reserved for a future major release.
-The tasks extension (SEP-2663) remains planned ([#391](https://github.com/modelcontextprotocol/ruby-sdk/issues/391)).
--- a/91
+++ b/91
@ -14,85 +14,38 @@ require "rubocop/rake_task"

 RuboCop::RakeTask.new

-task default: [:rubocop, :test, "conformance:test"]
+task default: [:rubocop, :test, :conformance]

-namespace :conformance do
-  desc "Run MCP conformance tests (PORT, SCENARIO, SPEC_VERSION, VERBOSE)"
-  task :test do |t|
-    next unless npx_available?(t.name)
+desc "Run MCP conformance tests (PORT, SCENARIO, SPEC_VERSION, VERBOSE)"
+task :conformance do |t|
+  next unless npx_available?(t.name)

-    require_relative "conformance/server_runner"
-    require_relative "conformance/client_runner"
+  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"]
+  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::ServerRunner.new(**options).run
-    Conformance::ClientRunner.new(**options.reject { |key, _value| key == :port }).run
-  end
-
-  desc "List available conformance scenarios"
-  task :list do |t|
-    next unless npx_available?(t.name)
-
-    system("npx", "--yes", "@modelcontextprotocol/conformance", "list", "--server")
-    system("npx", "--yes", "@modelcontextprotocol/conformance", "list", "--client")
-  end
-
-  desc "Start the conformance server (PORT)"
-  task :server do
-    require_relative "conformance/server"
-
-    options = {}
-    options[:port] = Integer(ENV["PORT"]) if ENV["PORT"]
-
-    Conformance::Server.new(**options).start
-  end
+  Conformance::Runner.new(**options).run
 end

-# The other two former names now fail with a "Did you mean?" suggestion, but a bare `conformance`
-# would match the `conformance/` directory: Rake synthesizes a file task for it and exits 0 without
-# running anything. This keeps the name pointing at the suite instead of at that silent no-op.
-desc "Alias for conformance:test"
-task conformance: "conformance:test"
+desc "List available conformance scenarios"
+task :conformance_list do |t|
+  next unless npx_available?(t.name)

-namespace :docs do
-  desc "Serve the documentation site locally at http://localhost:4000 (PORT)"
-  task :preview do
-    docs_dir = File.expand_path("docs", __dir__)
-    generate_docs_versions_data(docs_dir)
-
-    env = {
-      "BUNDLE_GEMFILE" => File.join(docs_dir, "Gemfile"),
-      "RUBYOPT" => "-r#{File.join(docs_dir, "_preview", "taint_shim.rb")}",
-    }
-    port = ENV.fetch("PORT", "4000")
-
-    Bundler.with_unbundled_env do
-      system(env, "bundle", "install", "--quiet", chdir: docs_dir, exception: true)
-      system(env, "bundle", "exec", "jekyll", "serve", "--port", port, chdir: docs_dir, exception: true)
-    rescue Interrupt
-      # Ctrl-C is the way to stop the preview, not an error.
-    end
-  end
+  system("npx", "--yes", "@modelcontextprotocol/conformance", "list", "--server")
 end

-# Mirrors bin/generate-gh-pages.sh: the released site receives `_data/versions.yml` from
-# the version tags at deploy time, and the preview generates the same data so the nav footer
-# shows the released-gem version line.
-def generate_docs_versions_data(docs_dir)
-  versions = %x(git tag --list).split("\n").filter_map { |tag|
-    tag[/\A[^0-9]*(\d+\.\d+\.\d+(?:-[a-zA-Z0-9.-]+)?)\z/, 1]
-  }.sort_by { |version|
-    Gem::Version.new(version)
-  }.reverse
-  return if versions.empty?
+desc "Start the conformance server (PORT)"
+task :conformance_server do
+  require_relative "conformance/server"

-  mkdir_p(File.join(docs_dir, "_data"))
-  File.write(File.join(docs_dir, "_data", "versions.yml"), versions.map { |version| "- #{version}\n" }.join)
+  options = {}
+  options[:port] = Integer(ENV["PORT"]) if ENV["PORT"]
+
+  Conformance::Server.new(**options).start
 end

 def npx_available?(task_name)
--- a/VERSIONING.md
+++ b/VERSIONING.md
@ -1,56 +0,0 @@
-# Versioning Policy
-
-The MCP Ruby SDK follows [Semantic Versioning 2.0.0](https://semver.org/spec/v2.0.0.html).
-This document describes what each version component means for users of the `mcp` gem,
-what counts as a breaking change, and how breaking changes are communicated.
-
-## Version Scheme
-
-Given a version number `MAJOR.MINOR.PATCH`:
-
- **MAJOR** is incremented for incompatible changes to the public API.
- **MINOR** is incremented for backwards-compatible new functionality.
- **PATCH** is incremented for backwards-compatible bug fixes.
-
-### Current 0.x Phase
-
-While the SDK is at version 0.x, the public API is not yet considered stable.
-Following SemVer conventions for initial development, minor releases (0.x -> 0.y) may contain breaking changes.
-All breaking changes are recorded in [CHANGELOG.md](CHANGELOG.md).
-
-### After 1.0.0
-
-Once 1.0.0 is released, breaking changes will only ship in major releases, with the exceptions described below.
-
-## What Counts as a Breaking Change
-
-A breaking change is any change that requires users to modify their code when upgrading, including:
-
- Removing or renaming a public class, module, method, or constant
- Changing a public method's signature in a way that rejects previously valid arguments
- Changing documented behavior that users can reasonably depend on
-
-New functionality that is purely additive (new classes, new methods, new optional keyword arguments)
-is not a breaking change.
-
-## Exceptions: Spec Compliance, Security, and Clear Defects
-
-Minor releases avoid incompatible changes as much as possible. However, the SDK's primary contract is
-conformance to the [MCP specification](https://modelcontextprotocol.io/specification/).
-Behavior that deviates from the specification is treated as a bug, even when users may have come to rely on it.
-Therefore, incompatible changes may be shipped in a minor release when they are required to:
-
- Fix incorrect conformance to the MCP specification
- Address a security vulnerability
- Fix a clear defect, such as behavior that contradicts the documentation, a crash,
-  or data corruption, where compatibility would mean preserving the defect
-
-When such a change ships, the release notes and CHANGELOG entry explicitly call out the incompatibility
-and describe how to migrate.
-
-## How Breaking Changes Are Communicated
-
- [CHANGELOG.md](CHANGELOG.md) records every release in [Keep a Changelog](https://keepachangelog.com/en/1.1.0/) format;
-  breaking changes appear under the "Changed" or "Removed" headings
- [GitHub Releases](https://github.com/modelcontextprotocol/ruby-sdk/releases) mirror the changelog for each release
- Where practical, deprecation warnings are added at least one minor release before removal
--- a/conformance/README.md
+++ b/conformance/README.md
@ -12,45 +12,45 @@ Validates the Ruby SDK's conformance to the MCP specification using [`@modelcont
 ### Run all scenarios

 ```bash
-bundle exec rake conformance:test
+bundle exec rake conformance
 ```

-Runs both server and client conformance tests in sequence. Server conformance starts the
-conformance server and tests it. Client conformance spawns test servers for each scenario
-and invokes `conformance/client.rb` against them. Scenarios listed in `expected_failures.yml`
-are allowed to fail without affecting the exit code.
+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 (server conformance only) | `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)   |
+| 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 server scenario
-bundle exec rake conformance:test SCENARIO=ping
+# Run a single scenario
+bundle exec rake conformance SCENARIO=ping

 # Use a different port with verbose output
-bundle exec rake conformance:test PORT=3000 VERBOSE=1
+bundle exec rake conformance PORT=3000 VERBOSE=1

 # Start the server on a specific port
-bundle exec rake conformance:server PORT=3000
+bundle exec rake conformance_server PORT=3000
 ```

 ### Start the server and test separately

 ```bash
 # Terminal 1: start the server
-bundle exec rake conformance:server
+bundle exec rake conformance_server

 # Terminal 2: run all scenarios
-npx @modelcontextprotocol/conformance@alpha server --url http://localhost:9292/mcp
+npx @modelcontextprotocol/conformance server --url http://localhost:9292/mcp

 # Terminal 2: run a single scenario
-npx @modelcontextprotocol/conformance@alpha server --url http://localhost:9292/mcp --scenario ping
+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
@ -59,7 +59,7 @@ on a single scenario. Stop the server with Ctrl+C when done.
 ### List available scenarios

 ```bash
-bundle exec rake conformance:list
+bundle exec rake conformance_list
 ```

 Prints all scenario names that can be passed to `SCENARIO`.
@ -76,7 +76,7 @@ repository with the conformance server running:

 ```bash
 # Terminal 1 (this repository): start the conformance server
-bundle exec rake 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
@ -91,10 +91,8 @@ submissions.
 ```
 conformance/
  server.rb              # Conformance server (Rack + Puma, default port 9292)
-  server_runner.rb       # Starts the server, runs npx conformance server, exits with result code
-  client.rb              # Conformance client (invoked by npx conformance client)
-  client_runner.rb       # Runs npx conformance client, exits with result code
-  expected_failures.yml  # Baseline of known-failing scenarios (server and client)
+  runner.rb              # Starts the server, runs npx conformance, exits with result code
+  expected_failures.yml  # Baseline of known-failing scenarios
  README.md              # This file
 ```

@ -102,4 +100,4 @@ conformance/

 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:test`.
+These are shown in the output of `bundle exec rake conformance`.
--- a/conformance/client.rb
+++ b/conformance/client.rb
@ -1,306 +0,0 @@
-# frozen_string_literal: true
-
-# Conformance test client for the MCP Ruby SDK.
-# Invoked by the conformance runner:
-#   MCP_CONFORMANCE_SCENARIO=<scenario> bundle exec ruby conformance/client.rb <server-url>
-#
-# The server URL is passed as the last positional argument.
-# The scenario name is read from the MCP_CONFORMANCE_SCENARIO environment variable,
-# which is set automatically by the conformance test runner.
-
-require "faraday"
-require "json"
-require_relative "../lib/mcp"
-
-scenario = ENV["MCP_CONFORMANCE_SCENARIO"]
-server_url = ARGV.last
-
-unless scenario && server_url
-  abort("Usage: MCP_CONFORMANCE_SCENARIO=<scenario> ruby conformance/client.rb <server-url>")
-end
-
-# URL the conformance harness expects to see as the OAuth `client_id` for the `auth/basic-cimd` scenario
-# when the AS advertises `client_id_metadata_document_supported`. The harness does not fetch the document,
-# only matches the value, so the URL does not need to resolve.
-CONFORMANCE_CIMD_URL = "https://conformance-test.local/client-metadata.json"
-
-# The conformance harness optionally injects scenario-specific data via
-# the `MCP_CONFORMANCE_CONTEXT` environment variable as a JSON document. The shape is
-# defined by the harness, not the MCP spec, and has varied between versions:
-#
-# - Newer (`@modelcontextprotocol/conformance` >= 0.x): scenario fields are
-#   spread at the top level alongside `name`, e.g.
-#   `{"name":"auth/pre-registration","client_id":"...","client_secret":"..."}`.
-# - Older: a nested `context` object: `{"name":"...","context":{...}}`.
-#
-# Both shapes are accepted so the client conforms to whichever harness version
-# the developer has on hand.
-def conformance_context
-  raw = ENV["MCP_CONFORMANCE_CONTEXT"]
-  return {} if raw.nil? || raw.empty?
-
-  parsed = JSON.parse(raw)
-  return {} unless parsed.is_a?(Hash)
-
-  if parsed["context"].is_a?(Hash)
-    parsed["context"]
-  else
-    parsed.reject { |key, _| key == "name" }
-  end
-rescue JSON::ParserError
-  {}
-end
-
-# Saves the pre-registered `client_id` / `client_secret` the harness injects
-# via context (used by pre-registration and client_credentials scenarios).
-def storage_for(context)
-  storage = MCP::Client::OAuth::InMemoryStorage.new
-  if context["client_id"]
-    storage.save_client_information(
-      "client_id" => context["client_id"],
-      "client_secret" => context["client_secret"],
-      "token_endpoint_auth_method" => context["token_endpoint_auth_method"] || "client_secret_basic",
-    )
-  end
-  storage
-end
-
-# Builds a `client_credentials`-only provider (machine-to-machine, no redirect).
-# The pre-registered credentials are injected by the harness via context:
-# a shared secret for the basic scenario, or a PEM private key plus signing algorithm
-# (default ES256, matching the TypeScript and Python conformance clients)
-# for the `private_key_jwt` scenario.
-def build_client_credentials_provider(context)
-  if context["private_key_pem"]
-    MCP::Client::OAuth::ClientCredentialsProvider.new(
-      client_id: context["client_id"],
-      token_endpoint_auth_method: "private_key_jwt",
-      private_key: context["private_key_pem"],
-      signing_algorithm: context["signing_algorithm"] || "ES256",
-    )
-  else
-    MCP::Client::OAuth::ClientCredentialsProvider.new(
-      client_id: context["client_id"],
-      client_secret: context["client_secret"],
-      token_endpoint_auth_method: context["token_endpoint_auth_method"] || "client_secret_basic",
-    )
-  end
-end
-
-# Builds a SEP-990 Cross-App Access provider: the harness injects an IdP ID token plus the IdP token endpoint
-# via context; the assertion provider exchanges them for an ID-JAG (RFC 8693), which the flow then presents to
-# the MCP authorization server with the jwt-bearer grant.
-def build_cross_app_access_provider(context)
-  assertion_provider = ->(audience:, resource:) do
-    MCP::Client::OAuth::IDJAGTokenExchange.request(
-      token_endpoint: context["idp_token_endpoint"],
-      id_token: context["idp_id_token"],
-      client_id: context["idp_client_id"],
-      audience: audience,
-      resource: resource,
-    )
-  end
-
-  MCP::Client::OAuth::CrossAppAccessProvider.new(
-    client_id: context["client_id"],
-    client_secret: context["client_secret"],
-    assertion_provider: assertion_provider,
-  )
-end
-
-# Builds an OAuth provider that drives the authorization code + PKCE + DCR flow
-# non-interactively against the conformance test's auth server. The conformance
-# `/authorize` endpoint redirects synchronously to `redirect_uri` with
-# `code=test-auth-code`, so we follow it manually instead of opening a browser.
-def build_oauth_provider(context, scenario:)
-  callback_holder = {}
-  redirect_uri = "http://localhost:0/callback"
-
-  redirect_handler = ->(authorization_url) do
-    response = Faraday.new.get(authorization_url) do |req|
-      req.options.params_encoder = nil
-    end
-    location = response.headers["location"] || response.headers["Location"]
-    abort("Authorization request did not redirect: #{response.status}.") unless location
-
-    callback_holder[:url] = URI.parse(location)
-  end
-
-  callback_handler = -> do
-    query = URI.decode_www_form(callback_holder.fetch(:url).query).to_h
-    # The 3-element form opts into SEP-2468 / RFC 9207 `iss` validation;
-    # `query["iss"]` is nil when the authorization response carried no `iss`.
-    [query["code"], query["state"], query["iss"]]
-  end
-
-  MCP::Client::OAuth::Provider.new(
-    client_metadata: {
-      client_name: "ruby-sdk-conformance-client",
-      redirect_uris: [redirect_uri],
-      grant_types: ["authorization_code", "refresh_token"],
-      response_types: ["code"],
-      token_endpoint_auth_method: "none",
-    },
-    redirect_uri: redirect_uri,
-    redirect_handler: redirect_handler,
-    callback_handler: callback_handler,
-    storage: storage_for(context),
-    client_id_metadata_document_url: (scenario == "auth/basic-cimd" ? CONFORMANCE_CIMD_URL : nil),
-  )
-end
-
-def build_provider_for(scenario, context)
-  if context["idp_id_token"]
-    build_cross_app_access_provider(context)
-  elsif scenario.start_with?("auth/client-credentials")
-    build_client_credentials_provider(context)
-  else
-    build_oauth_provider(context, scenario: scenario)
-  end
-end
-
-oauth = scenario.start_with?("auth/") ? build_provider_for(scenario, conformance_context) : nil
-transport = MCP::Client::HTTP.new(url: server_url, oauth: oauth)
-client = MCP::Client.new(transport: transport)
-
-# SEP-2322: the MRTR scenario exercises the automatic driver; this elicitation handler accepts
-# every embedded confirmation request, and the driver echoes `requestState` byte-exactly.
-# The same registration answers a real `elicitation/create` request, so nothing here is MRTR-specific.
-if scenario == "sep-2322-client-request-state"
-  client.on_elicitation { |_params| { action: "accept", content: { confirmed: true } } }
-end
-capabilities = scenario == "elicitation-sep1034-client-defaults" ? { elicitation: {} } : {}
-# The conformance harness asserts on the observed protocol exchange, not on the client's exit status,
-# and echoes the client's output only when the exit status is non-zero. Several negative auth scenarios
-# (e.g. `auth/resource-mismatch`, `auth/scope-retry-limit`) are expected to drive the client into
-# a terminal failure: the SDK correctly refuses a mismatched resource or stops after the scope step-up
-# retry limit. Report such an expected failure as a one-line reason and exit cleanly so the run stays
-# free of noise, while letting any unexpected error (a real SDK bug) still raise with a full backtrace
-# and a failing exit status.
-begin
-  # The harness names the wire version per scenario run: the 2026 draft selects the stateless modern lifecycle,
-  # and every dated version through 2025-11-25 keeps the legacy `initialize` handshake
-  # (pinned rather than `:auto`, whose `server/discover` probe the legacy scenario servers do not expect).
-  mode = ENV["MCP_CONFORMANCE_PROTOCOL_VERSION"] == "2026-07-28" ? :modern : :legacy
-  connect = lambda do
-    client.connect(
-      client_info: { name: "ruby-sdk-conformance-client", version: MCP::VERSION },
-      capabilities: capabilities,
-      mode: mode,
-    )
-  end
-
-  begin
-    connect.call
-  rescue MCP::Client::RequestHandlerError
-    # SEP-2575 version negotiation: a server may reject the first request with `-32022` naming
-    # its supported versions. Retry once so the harness observes a follow-up request carrying
-    # a mutually supported version (this client already speaks the latest draft).
-    raise unless mode == :modern
-
-    connect.call
-  end
-
-  case scenario
-  when "initialize"
-    client.tools
-  when "json-schema-2020-12-preservation"
-    # SEP-1613/SEP-2106: echo the focal tool's observed inputSchema verbatim so the harness
-    # can diff what the client preserved. Preservation holds because `Client::Tool#input_schema`
-    # is the parsed response untouched.
-    tools = client.tools
-    focal = tools.find { |t| t.name == "json_schema_2020_12_tool" }
-    abort("Tool json_schema_2020_12_tool not found") unless focal
-    client.call_tool(name: "json_schema_echo", arguments: { "schema" => focal.input_schema })
-  when "request-metadata"
-    # SEP-2575: the checks read the envelope and headers of the requests the modern connect
-    # and this listing already produce.
-    client.tools
-  when "sep-2322-client-request-state"
-    # SEP-2322: the driver resumes `test_mrtr_echo_state` automatically (fresh JSON-RPC id,
-    # byte-exact `requestState` echo); `test_mrtr_unrelated` must carry neither retry field;
-    # `test_mrtr_no_state` retries without inventing a state; `test_mrtr_no_result_type`
-    # has no `resultType` and therefore must be treated as complete, with no retry.
-    client.tools
-    client.call_tool(name: "test_mrtr_echo_state", arguments: {})
-    client.call_tool(name: "test_mrtr_unrelated", arguments: {})
-    client.call_tool(name: "test_mrtr_no_state", arguments: {})
-    client.call_tool(name: "test_mrtr_no_result_type", arguments: {})
-  when "http-custom-headers"
-    # SEP-2243: the harness names the exact tool calls (with encoding edge-case values) via context;
-    # listing first teaches the transport the `x-mcp-header` declarations it mirrors.
-    client.tools
-    (conformance_context["toolCalls"] || []).each do |tool_call|
-      client.call_tool(name: tool_call["name"], arguments: tool_call["arguments"])
-    end
-  when "http-invalid-tool-headers"
-    # SEP-2243: the listing carries one valid tool among invalid `x-mcp-header` definitions;
-    # calling only the valid one shows the invalid definitions did not block it.
-    client.tools
-    client.call_tool(name: "valid_tool", arguments: { "message" => "hello" })
-  when "http-standard-headers"
-    # SEP-2243: the harness inspects the `Mcp-Method` header on every POST and the `Mcp-Name` header on
-    # the name-carrying requests, so drive one of each standard request kind.
-    tools = client.tools
-    tool = tools.find { |t| t.name == "test_headers" } || tools.first
-    abort("No tool exposed by conformance server for #{scenario}") unless tool
-    client.call_tool(tool: tool, arguments: {})
-
-    resource = client.resources.first
-    abort("No resource exposed by conformance server for #{scenario}") unless resource
-    client.read_resource(uri: resource["uri"])
-
-    prompt = client.prompts.first
-    abort("No prompt exposed by conformance server for #{scenario}") unless prompt
-    client.get_prompt(name: prompt["name"])
-  when "json-schema-ref-no-deref"
-    # SEP-2106: listing tools whose schemas carry `$ref` must not trigger network dereferencing.
-    client.tools
-  when "tools_call"
-    tools = client.tools
-    add_numbers = tools.find { |t| t.name == "add_numbers" }
-    abort("Tool add_numbers not found") unless add_numbers
-    client.call_tool(tool: add_numbers, arguments: { a: 1, b: 2 })
-  when "sse-retry"
-    # SEP-1699: the server closes the tools/call SSE stream right after a priming event.
-    # The transport waits the server's `retry:` interval, reconnects with a GET carrying `Last-Event-ID`,
-    # and receives the tool result on the resumed stream; the harness verifies the reconnect,
-    # its timing, and the header.
-    tools = client.tools
-    test_reconnection = tools.find { |t| t.name == "test_reconnection" }
-    abort("Tool test_reconnection not found") unless test_reconnection
-    client.call_tool(tool: test_reconnection, arguments: {})
-  when "elicitation-sep1034-client-defaults"
-    # SEP-1034: the server sends `elicitation/create` on the tools/call SSE stream with every property declaring
-    # a `default` and none required. The handler accepts and fills the omitted fields from those defaults.
-    client.on_elicitation do |params|
-      { action: "accept", content: MCP::Client::Elicitation.apply_defaults(params["requestedSchema"] || {}) }
-    end
-
-    tools = client.tools
-    defaults_tool = tools.find { |t| t.name == "test_client_elicitation_defaults" }
-
-    abort("Tool test_client_elicitation_defaults not found") unless defaults_tool
-
-    client.call_tool(tool: defaults_tool, arguments: {})
-  when %r|\Aauth/|
-    # Auth-only scenarios: the protocol-level checks (PRM/AS metadata, DCR, PKCE, token usage)
-    # are observed by the conformance server during `connect` and the subsequent request below.
-    # Listing tools forces a second authenticated MCP request so the bearer token usage check fires.
-    tools = client.tools
-
-    # `auth/scope-step-up` only fires its escalation 403 on `tools/call`, not `tools/list`,
-    # so the client must actually invoke a tool to drive the second authorization request
-    # the scenario asserts on.
-    if scenario == "auth/scope-step-up"
-      tool = tools.find { |t| t.name == "test-tool" } || tools.first
-      abort("No tool exposed by conformance server for #{scenario}") unless tool
-      client.call_tool(tool: tool, arguments: {})
-    end
-  else
-    abort("Unknown or unsupported scenario: #{scenario}")
-  end
-rescue MCP::Client::OAuth::Flow::AuthorizationError, MCP::Client::RequestHandlerError, Faraday::Error => e
-  warn("#{scenario}: client ended in the expected terminal failure (#{e.class}: #{e.message})")
-  exit
-end
--- a/conformance/client_runner.rb
+++ b/conformance/client_runner.rb
@ -1,48 +0,0 @@
-# frozen_string_literal: true
-
-# Runs `npx @modelcontextprotocol/conformance@alpha client` against the conformance client script.
-require "English"
-
-module Conformance
-  class ClientRunner
-    def initialize(scenario: nil, spec_version: nil, verbose: false)
-      @scenario = scenario
-      @spec_version = spec_version
-      @verbose = verbose
-    end
-
-    def run
-      command = build_command
-      puts "Command: #{command.join(" ")}\n\n"
-
-      system(*command)
-      conformance_exit_code = $CHILD_STATUS.exitstatus
-      exit(conformance_exit_code || 1) unless conformance_exit_code == 0
-    end
-
-    private
-
-    def build_command
-      expected_failures_yml = File.expand_path("expected_failures.yml", __dir__)
-      client_script = File.expand_path("client.rb", __dir__)
-
-      npx_command = [
-        "npx",
-        "--yes",
-        "@modelcontextprotocol/conformance@alpha",
-        "client",
-        "--command",
-        "bundle exec ruby #{client_script}",
-      ]
-      npx_command += if @scenario
-        ["--scenario", @scenario]
-      else
-        ["--suite", "all"]
-      end
-      npx_command += ["--spec-version", @spec_version] if @spec_version
-      npx_command += ["--verbose"] if @verbose
-      npx_command += ["--expected-failures", expected_failures_yml]
-      npx_command
-    end
-  end
-end
--- a/conformance/expected_failures.yml
+++ b/conformance/expected_failures.yml
@ -1,6 +1,7 @@
-server: []
-client:
-  # Unimplemented authorization extensions.
-  - auth/dpop
-  - auth/dpop-nonce
-  - auth/wif-jwt-bearer
+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
--- a/conformance/runner.rb
+++ b/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
--- a/conformance/server.rb
+++ b/conformance/server.rb
@ -2,8 +2,6 @@

 require "rackup"
 require "json"
-require "securerandom"
-require "set"
 require "uri"
 require_relative "../lib/mcp"

@ -14,43 +12,6 @@ module Conformance
  # Minimal WAV file (matches TypeScript SDK and Python SDK)
  BASE64_MINIMAL_WAV = "UklGRiYAAABXQVZFZm10IBAAAAABAAEAQB8AAAB9AAACABAAZGF0YQIAAAA="

-  # SEP-2322 MRTR fixture helpers. A retried request re-runs its handler from the start,
-  # so every round reads the client's earlier answers back through these.
-  module Mrtr
-    module_function
-
-    # The transport parses JSON with symbolized keys, but retries may also arrive through
-    # `Server#handle` with string keys; tolerate both like the SDK's own readers.
-    def read(hash, key)
-      return unless hash.is_a?(Hash)
-
-      value = hash[key.to_sym]
-      value.nil? ? hash[key.to_s] : value
-    end
-
-    # The `content` of an accepted `elicitation/create` response, or `nil` for a declined,
-    # malformed, or missing one (a `nil` return re-requests the input).
-    def accepted_content(response)
-      content = read(response, :content)
-      content if read(response, :action) == "accept" && content.is_a?(Hash)
-    end
-
-    # The `text` of a `sampling/createMessage` response, or `nil` when malformed.
-    def sampled_text(response)
-      text = read(read(response, :content), :text)
-      text if text.is_a?(String)
-    end
-
-    def parse_state(request_state)
-      return unless request_state.is_a?(String)
-
-      parsed = JSON.parse(request_state)
-      parsed.is_a?(Hash) ? parsed : nil
-    rescue JSON::ParserError
-      nil
-    end
-  end
-
  module Tools
    class TestSimpleText < MCP::Tool
      tool_name "test_simple_text"
@ -195,6 +156,7 @@ module Conformance
      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"
@ -204,19 +166,16 @@ module Conformance
      )

      class << self
-        def call(prompt:, server_context:)
-          result = server_context.create_sampling_message(
-            messages: [{ role: "user", content: { type: "text", text: prompt } }],
-            max_tokens: 100,
+        def call(prompt:)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Sampling not supported in this SDK version").to_h],
+            error: true,
          )
-          model = result[:model] || "unknown"
-          text = result.dig(:content, :text) || ""
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("LLM response: #{text} (model: #{model})").to_h])
        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"
@ -226,90 +185,41 @@ module Conformance
      )

      class << self
-        def call(server_context:, message:)
-          result = server_context.create_form_elicitation(
-            message: message,
-            requested_schema: {
-              type: "object",
-              properties: {
-                username: { type: "string", description: "User's response" },
-                email: { type: "string", description: "User's email address" },
-              },
-              required: ["username", "email"],
-            },
+        def call(message:)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Elicitation not supported in this SDK version").to_h],
+            error: true,
          )
-          MCP::Tool::Response.new([MCP::Content::Text.new("User response: #{result}").to_h])
        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(server_context:, **_args)
-          result = server_context.create_form_elicitation(
-            message: "Please provide your information (with defaults)",
-            requested_schema: {
-              type: "object",
-              properties: {
-                name: { type: "string", default: "John Doe" },
-                age: { type: "integer", default: 30 },
-                score: { type: "number", default: 95.5 },
-                status: MCP::Elicitation::EnumSchema.untitled_single_select(
-                  values: ["active", "inactive", "pending"], default: "active",
-                ).to_h,
-                verified: { type: "boolean", default: true },
-              },
-            },
+        def call(**_args)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Elicitation not supported in this SDK version").to_h],
+            error: true,
          )
-          MCP::Tool::Response.new([MCP::Content::Text.new("Elicitation result: #{result}").to_h])
        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(server_context:, **_args)
-          # Built with the SEP-1330 builders so the conformance run exercises the same schemas
-          # the SDK produces for users.
-          result = server_context.create_form_elicitation(
-            message: "Please select options",
-            requested_schema: {
-              type: "object",
-              properties: {
-                untitledSingle: MCP::Elicitation::EnumSchema.untitled_single_select(
-                  values: ["option1", "option2", "option3"],
-                ).to_h,
-                titledSingle: MCP::Elicitation::EnumSchema.titled_single_select(
-                  options: [
-                    { value: "value1", title: "First Option" },
-                    { value: "value2", title: "Second Option" },
-                    { value: "value3", title: "Third Option" },
-                  ],
-                ).to_h,
-                legacyEnum: MCP::Elicitation::EnumSchema.legacy_titled(
-                  values: ["opt1", "opt2", "opt3"],
-                  value_titles: ["Option One", "Option Two", "Option Three"],
-                ).to_h,
-                untitledMulti: MCP::Elicitation::EnumSchema.untitled_multi_select(
-                  values: ["option1", "option2", "option3"],
-                ).to_h,
-                titledMulti: MCP::Elicitation::EnumSchema.titled_multi_select(
-                  options: [
-                    { value: "value1", title: "First Choice" },
-                    { value: "value2", title: "Second Choice" },
-                    { value: "value3", title: "Third Choice" },
-                  ],
-                ).to_h,
-              },
-            },
+        def call(**_args)
+          MCP::Tool::Response.new(
+            [MCP::Content::Text.new("Elicitation not supported in this SDK version").to_h],
+            error: true,
          )
-          MCP::Tool::Response.new([MCP::Content::Text.new("Elicitation result: #{result}").to_h])
        end
      end
    end
@ -324,377 +234,6 @@ module Conformance
        end
      end
    end
-
-    class TestMissingCapability < MCP::Tool
-      tool_name "test_missing_capability"
-      description "A tool that requires the sampling client capability (SEP-2575)"
-
-      class << self
-        def call(server_context:, **_args)
-          server_context.require_client_capability!(:sampling)
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("Sampling capability is declared").to_h])
-        end
-      end
-    end
-
-    class TestStreamingElicitation < MCP::Tool
-      tool_name "test_streaming_elicitation"
-      description "A tool whose response stream carries only notifications, never independent requests (SEP-2575)"
-
-      class << self
-        def call(server_context:, **_args)
-          # No independent server-to-client request is ever written to the response stream;
-          # the progress notification only goes out when the request carried a progressToken.
-          server_context.report_progress(50, total: 100)
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("Streaming complete").to_h])
-        end
-      end
-    end
-
-    class TestInputRequiredResultElicitation < MCP::Tool
-      tool_name "test_input_required_result_elicitation"
-      description "A tool that asks for the user's name through an input_required result (SEP-2322)"
-
-      class << self
-        def call(server_context:, **_args)
-          content = Mrtr.accepted_content(server_context.input_response("user_name"))
-          name = content && Mrtr.read(content, :name)
-
-          unless name.is_a?(String)
-            return MCP::Server::InputRequiredResult.new(
-              input_requests: {
-                user_name: {
-                  method: "elicitation/create",
-                  params: {
-                    message: "What is your name?",
-                    requestedSchema: {
-                      type: "object",
-                      properties: { name: { type: "string" } },
-                      required: ["name"],
-                    },
-                  },
-                },
-              },
-            )
-          end
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("Hello, #{name}!").to_h])
-        end
-      end
-    end
-
-    class TestInputRequiredResultSampling < MCP::Tool
-      tool_name "test_input_required_result_sampling"
-      description "A tool that asks for an LLM completion through an input_required result (SEP-2322)"
-
-      class << self
-        def call(server_context:, **_args)
-          text = Mrtr.sampled_text(server_context.input_response("sample_request"))
-
-          unless text
-            return MCP::Server::InputRequiredResult.new(
-              input_requests: {
-                sample_request: {
-                  method: "sampling/createMessage",
-                  params: {
-                    messages: [{ role: "user", content: { type: "text", text: "What is the capital of France?" } }],
-                    maxTokens: 100,
-                  },
-                },
-              },
-            )
-          end
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("Sampled: #{text}").to_h])
-        end
-      end
-    end
-
-    class TestInputRequiredResultListRoots < MCP::Tool
-      tool_name "test_input_required_result_list_roots"
-      description "A tool that asks for the client's roots through an input_required result (SEP-2322)"
-
-      class << self
-        def call(server_context:, **_args)
-          roots = Mrtr.read(server_context.input_response("roots_request"), :roots)
-
-          unless roots.is_a?(Array)
-            return MCP::Server::InputRequiredResult.new(
-              input_requests: { roots_request: { method: "roots/list" } },
-            )
-          end
-
-          uris = roots.filter_map { |root| Mrtr.read(root, :uri) }
-          MCP::Tool::Response.new([MCP::Content::Text.new("Roots: #{uris.join(", ")}").to_h])
-        end
-      end
-    end
-
-    class TestInputRequiredResultRequestState < MCP::Tool
-      tool_name "test_input_required_result_request_state"
-      description "A tool whose input_required result carries an opaque requestState (SEP-2322)"
-
-      class << self
-        def call(server_context:, **_args)
-          state = Mrtr.parse_state(server_context.request_state)
-          confirmed = Mrtr.accepted_content(server_context.input_response("confirm"))
-
-          if state && state["kind"] == "request-state" && confirmed
-            return MCP::Tool::Response.new([MCP::Content::Text.new("state-ok: requestState validated").to_h])
-          end
-
-          MCP::Server::InputRequiredResult.new(
-            input_requests: {
-              confirm: {
-                method: "elicitation/create",
-                params: {
-                  message: "Confirm to continue",
-                  requestedSchema: {
-                    type: "object",
-                    properties: { ok: { type: "boolean" } },
-                  },
-                },
-              },
-            },
-            request_state: JSON.generate({ kind: "request-state", nonce: SecureRandom.hex(8) }),
-          )
-        end
-      end
-    end
-
-    class TestInputRequiredResultMultipleInputs < MCP::Tool
-      tool_name "test_input_required_result_multiple_inputs"
-      description "A tool that embeds elicitation, sampling, and roots/list inputs in one input_required result (SEP-2322)"
-
-      class << self
-        def call(server_context:, **_args)
-          content = Mrtr.accepted_content(server_context.input_response("user_name"))
-          name = content && Mrtr.read(content, :name)
-          greeting = Mrtr.sampled_text(server_context.input_response("greeting"))
-          roots = Mrtr.read(server_context.input_response("client_roots"), :roots)
-
-          if name.is_a?(String) && greeting && roots.is_a?(Array)
-            return MCP::Tool::Response.new(
-              [MCP::Content::Text.new("#{greeting} #{name} (#{roots.length} roots)").to_h],
-            )
-          end
-
-          MCP::Server::InputRequiredResult.new(
-            input_requests: {
-              user_name: {
-                method: "elicitation/create",
-                params: {
-                  message: "What is your name?",
-                  requestedSchema: {
-                    type: "object",
-                    properties: { name: { type: "string" } },
-                    required: ["name"],
-                  },
-                },
-              },
-              greeting: {
-                method: "sampling/createMessage",
-                params: {
-                  messages: [{ role: "user", content: { type: "text", text: "Write a one-word greeting" } }],
-                  maxTokens: 50,
-                },
-              },
-              client_roots: { method: "roots/list" },
-            },
-            request_state: JSON.generate({ kind: "multiple-inputs" }),
-          )
-        end
-      end
-    end
-
-    class TestInputRequiredResultMultiRound < MCP::Tool
-      tool_name "test_input_required_result_multi_round"
-      description "A tool that needs two elicitation rounds before completing (SEP-2322)"
-
-      class << self
-        def call(server_context:, **_args)
-          state = Mrtr.parse_state(server_context.request_state)
-
-          case state && state["round"]
-          when 1
-            content = Mrtr.accepted_content(server_context.input_response("user_name"))
-            name = content && Mrtr.read(content, :name)
-            return second_round(name) if name.is_a?(String)
-          when 2
-            content = Mrtr.accepted_content(server_context.input_response("favorite_color"))
-            color = content && Mrtr.read(content, :color)
-            if color.is_a?(String)
-              return MCP::Tool::Response.new([MCP::Content::Text.new("#{state["name"]} likes #{color}").to_h])
-            end
-          end
-
-          first_round
-        end
-
-        private
-
-        def first_round
-          MCP::Server::InputRequiredResult.new(
-            input_requests: {
-              user_name: {
-                method: "elicitation/create",
-                params: {
-                  message: "What is your name?",
-                  requestedSchema: {
-                    type: "object",
-                    properties: { name: { type: "string" } },
-                    required: ["name"],
-                  },
-                },
-              },
-            },
-            request_state: JSON.generate({ round: 1 }),
-          )
-        end
-
-        def second_round(name)
-          MCP::Server::InputRequiredResult.new(
-            input_requests: {
-              favorite_color: {
-                method: "elicitation/create",
-                params: {
-                  message: "What is your favorite color?",
-                  requestedSchema: {
-                    type: "object",
-                    properties: { color: { type: "string" } },
-                    required: ["color"],
-                  },
-                },
-              },
-            },
-            request_state: JSON.generate({ round: 2, name: name }),
-          )
-        end
-      end
-    end
-
-    class TestInputRequiredResultTamperedState < MCP::Tool
-      tool_name "test_input_required_result_tampered_state"
-      description "A tool whose sealed requestState rejects tampered echoes (SEP-2322)"
-
-      class << self
-        # A tampered `requestState` never reaches this handler: the server-level unsealing rejects it with -32602
-        # before dispatch, so the tool body is a plain MRTR flow.
-        def call(server_context:, **_args)
-          state = Mrtr.parse_state(server_context.request_state)
-          confirmed = Mrtr.accepted_content(server_context.input_response("confirm"))
-
-          if state && state["kind"] == "tamper-check" && confirmed
-            return MCP::Tool::Response.new([MCP::Content::Text.new("requestState integrity verified").to_h])
-          end
-
-          MCP::Server::InputRequiredResult.new(
-            input_requests: {
-              confirm: {
-                method: "elicitation/create",
-                params: {
-                  message: "Confirm to continue",
-                  requestedSchema: {
-                    type: "object",
-                    properties: { ok: { type: "boolean" } },
-                  },
-                },
-              },
-            },
-            request_state: JSON.generate({ kind: "tamper-check", nonce: SecureRandom.hex(8) }),
-          )
-        end
-      end
-    end
-
-    class TestInputRequiredResultCapabilities < MCP::Tool
-      tool_name "test_input_required_result_capabilities"
-      description "A tool that only embeds input requests the client's declared capabilities can fulfill (SEP-2322)"
-
-      class << self
-        def call(server_context:, **_args)
-          capabilities = server_context.client_capabilities || {}
-          elicited = Mrtr.accepted_content(server_context.input_response("elicit_input"))
-          sampled = Mrtr.sampled_text(server_context.input_response("sample_input"))
-
-          requests = {}
-          if Mrtr.read(capabilities, :elicitation) && !elicited
-            requests[:elicit_input] = {
-              method: "elicitation/create",
-              params: {
-                message: "Provide a value",
-                requestedSchema: {
-                  type: "object",
-                  properties: { value: { type: "string" } },
-                },
-              },
-            }
-          end
-          if Mrtr.read(capabilities, :sampling) && !sampled
-            requests[:sample_input] = {
-              method: "sampling/createMessage",
-              params: {
-                messages: [{ role: "user", content: { type: "text", text: "Say hello" } }],
-                maxTokens: 50,
-              },
-            }
-          end
-
-          if requests.empty?
-            MCP::Tool::Response.new(
-              [MCP::Content::Text.new("Inputs: elicit=#{!elicited.nil?}, sample=#{!sampled.nil?}").to_h],
-            )
-          else
-            MCP::Server::InputRequiredResult.new(input_requests: requests)
-          end
-        end
-      end
-    end
-
-    class TestLoggingTool < MCP::Tool
-      tool_name "test_logging_tool"
-      description "A tool that logs only for requests opting in via the _meta logLevel (SEP-2575)"
-
-      class << self
-        def call(server_context:, **_args)
-          # On modern requests the notification is dropped unless `io.modelcontextprotocol/logLevel` authorized it,
-          # so the call itself is unconditional.
-          server_context.notify_log_message(data: "Log level honored", level: "info", logger: "conformance")
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("Logging evaluated").to_h])
-        end
-      end
-    end
-
-    class TestTriggerToolChange < MCP::Tool
-      tool_name "test_trigger_tool_change"
-      description "A diagnostic tool that broadcasts notifications/tools/list_changed to listen streams (SEP-2575)"
-
-      class << self
-        # The broadcast alone exercises the `subscriptions/listen` delivery, so no actual
-        # tool-list mutation is needed, matching the suite's TypeScript reference fixture.
-        def call(server_context:, **_args)
-          server_context.notify_tools_list_changed
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("Mutation triggered").to_h])
-        end
-      end
-    end
-
-    class TestTriggerPromptChange < MCP::Tool
-      tool_name "test_trigger_prompt_change"
-      description "A diagnostic tool that broadcasts notifications/prompts/list_changed to listen streams (SEP-2575)"
-
-      class << self
-        def call(server_context:, **_args)
-          server_context.notify_prompts_list_changed
-
-          MCP::Tool::Response.new([MCP::Content::Text.new("Mutation triggered").to_h])
-        end
-      end
-    end
  end

  module Prompts
@ -793,45 +332,6 @@ module Conformance
        end
      end
    end
-
-    class TestInputRequiredResultPrompt < MCP::Prompt
-      prompt_name "test_input_required_result_prompt"
-      description "A prompt that asks for user context through an input_required result (SEP-2322)"
-
-      class << self
-        def template(_args, server_context: nil)
-          content = server_context && Mrtr.accepted_content(server_context.input_response("user_context"))
-          context = content && Mrtr.read(content, :context)
-
-          unless context.is_a?(String)
-            return MCP::Server::InputRequiredResult.new(
-              input_requests: {
-                user_context: {
-                  method: "elicitation/create",
-                  params: {
-                    message: "Provide context for the prompt",
-                    requestedSchema: {
-                      type: "object",
-                      properties: { context: { type: "string" } },
-                      required: ["context"],
-                    },
-                  },
-                },
-              },
-            )
-          end
-
-          MCP::Prompt::Result.new(
-            messages: [
-              MCP::Prompt::Message.new(
-                role: "user",
-                content: MCP::Content::Text.new("Context: #{context}"),
-              ),
-            ],
-          )
-        end
-      end
-    end
  end

  class Server
@ -891,7 +391,7 @@ module Conformance

    def start
      server = build_server
-      transport = MCP::Server::Transports::StreamableHTTPTransport.new(server)
+      transport = build_transport(server)
      configure_handlers(server)
      rack_app = build_rack_app(transport)

@ -924,33 +424,15 @@ module Conformance
          Tools::TestElicitationSep1034Defaults,
          Tools::TestElicitationSep1330Enums,
          Tools::TestReconnection,
-          Tools::TestMissingCapability,
-          Tools::TestInputRequiredResultElicitation,
-          Tools::TestInputRequiredResultSampling,
-          Tools::TestInputRequiredResultListRoots,
-          Tools::TestInputRequiredResultRequestState,
-          Tools::TestInputRequiredResultMultipleInputs,
-          Tools::TestInputRequiredResultMultiRound,
-          Tools::TestInputRequiredResultTamperedState,
-          Tools::TestInputRequiredResultCapabilities,
-          Tools::TestStreamingElicitation,
-          Tools::TestLoggingTool,
-          Tools::TestTriggerToolChange,
-          Tools::TestTriggerPromptChange,
        ],
        prompts: [
          Prompts::TestSimplePrompt,
          Prompts::TestPromptWithArguments,
          Prompts::TestPromptWithEmbeddedResource,
          Prompts::TestPromptWithImage,
-          Prompts::TestInputRequiredResultPrompt,
        ],
        resources: resources,
        resource_templates: resource_templates,
-        # A per-boot random key is enough for conformance: every MRTR round trip completes
-        # within one server process, and sealing keeps the fixture's `requestState` values
-        # tamper-evident without any tool-level verification code.
-        request_state_security: MCP::Server::RequestStateSecurity.new(key: SecureRandom.bytes(32)),
        capabilities: {
          tools: { listChanged: true },
          prompts: { listChanged: true },
@ -995,13 +477,17 @@ module Conformance
      ]
    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)
-      configure_subscription_handlers(server)
-      configure_completion_handler(server)
    end

    def configure_resources_read_handler(server)
@ -1037,54 +523,11 @@ module Conformance
            ).to_h,
          ]
        else
-          # Per SEP-2164, an unknown URI answers with -32602 carrying the URI in `error.data`;
-          # an empty `contents` array is forbidden.
-          raise MCP::Server::ResourceNotFoundError.new(uri, params)
+          []
        end
      end
    end

-    def configure_completion_handler(server)
-      server.completion_handler do |params|
-        ref = params[:ref]
-        argument = params[:argument]
-        value = argument[:value].to_s
-
-        case ref[:type]
-        when "ref/prompt"
-          case ref[:name]
-          when "test_prompt_with_arguments"
-            candidates = case argument[:name]
-            when "arg1"
-              ["value1", "value2", "value3"]
-            when "arg2"
-              ["optionA", "optionB", "optionC"]
-            else
-              []
-            end
-            values = candidates.select { |v| v.start_with?(value) }
-            { completion: { values: values, hasMore: false } }
-          else
-            { completion: { values: [], hasMore: false } }
-          end
-        else
-          { completion: { values: [], hasMore: false } }
-        end
-      end
-    end
-
-    def configure_subscription_handlers(server)
-      subscribed_uris = Set.new
-
-      server.resources_subscribe_handler do |params|
-        subscribed_uris.add(params[:uri].to_s)
-      end
-
-      server.resources_unsubscribe_handler do |params|
-        subscribed_uris.delete(params[:uri].to_s)
-      end
-    end
-
    def build_rack_app(transport)
      mcp_app = proc do |env|
        request = Rack::Request.new(env)
--- a/docs/CNAME
+++ b/docs/CNAME
@ -1 +0,0 @@
-ruby.sdk.modelcontextprotocol.io
--- a/Show more
+++ b/Show more