Support Client ID Metadata Documents in OAuth client

## Motivation and Context

The MCP 2025-11-25 authorization specification and `draft-ietf-oauth-client-id-metadata-document-00` define
Client ID Metadata Documents (CIMD): a client publishes its OAuth metadata at an HTTPS URL and uses that URL
as the OAuth `client_id` instead of going through Dynamic Client Registration. The Python and TypeScript SDKs
already implement this; the Ruby SDK now reaches parity.

The change adds:

- `MCP::Client::OAuth::Provider` accepts an optional `client_id_metadata_document_url:` keyword.
- A new `Discovery.client_id_metadata_document_url?` validator enforces structural requirements.
  Spec-required: `https` scheme, a non-root path, and no fragment, userinfo, or `.`/`..` segments
  (including the percent-encoded form `%2E`). Stricter than the draft as an SDK policy: query strings
  are also rejected, because different encodings of the same query would yield distinct `client_id` strings for
  the same logical document. The loopback `http` carve-out used for discovery URLs does not extend to CIMD URLs,
  since the value is sent verbatim to the authorization server as the OAuth `client_id` and travels off-loopback.
  Validation failures raise `Provider::InvalidClientIDMetadataDocumentURLError`.
- `Flow#ensure_client_registered` routes through CIMD only when the authorization server advertises
  `client_id_metadata_document_supported` as JSON `boolean true`; truthy non-boolean values
  (string `"true"`, `"false"`, etc.) fall back to DCR, matching the gating in the Python and TypeScript SDKs.
- The CIMD `client_id` is NOT persisted to storage. AS support is re-read on every flow so a server
  that later drops CIMD support stops receiving the stale URL. Pre-registered `client_information`
  continues to win over CIMD when both are available.
- `Flow#refresh!` reconstructs the CIMD `client_id` from live AS metadata when refreshing tokens obtained via CIMD.
  When support has been withdrawn and no other identity is stored, it raises a clear `AuthorizationError` rather than
  sending a `client_id` the authorization server no longer recognises.
- The Provider docstring and README OAuth section explain that DCR `client_metadata` and the JSON document served at
  the CIMD URL are separate artifacts: DCR metadata MUST NOT include `client_id`, while the CIMD document MUST include
  `client_id` set to the URL, `client_name`, and `redirect_uris` covering `redirect_uri`.
- `auth/basic-cimd` is removed from `conformance/expected_failures.yml`.

## How Has This Been Tested?

`Discovery` tests cover: https with path accepted; non-https rejected (http, ftp, file); root and empty path rejected;
fragment, query, and userinfo rejected; dot segments rejected including the percent-encoded form `%2E`; nil, empty,
and malformed inputs rejected.

`Provider` tests cover: the default `nil`; rejection of http URLs (loopback included); non-https schemes;
root and empty path; fragment; query; userinfo; and dot segments.

`Flow#run!` tests cover: skip DCR when the authorization server advertises CIMD and the provider has a URL;
fall back to DCR when the authorization server does not advertise support; fall back to DCR when the value is
the string `"false"` or `"true"`; pre-registered `client_information` wins over CIMD; the CIMD `client_id` is not
persisted to storage; a second flow against an authorization server that has dropped CIMD support recovers via DCR.

`Flow#refresh!` tests cover: refresh reconstructs the CIMD `client_id` without a stored `client_information`;
refresh raises when the authorization server no longer advertises CIMD support; stored `client_information`
takes precedence over the CIMD URL during refresh.

Conformance: `auth/basic-cimd` now passes 12/12 with no warnings. `bundle exec rake test`, `bundle exec rake rubocop`,
and `bundle exec rake conformance` are all green.

## Breaking Changes

None. The `client_id_metadata_document_url:` keyword is purely opt-in and defaults to `nil`.
When the keyword is omitted, the DCR flow is unchanged. Existing OAuth users see no behaviour change.
The CIMD path is only entered when both the user explicitly configures a URL and the authorization server
advertises support via `client_id_metadata_document_supported: true`.
This commit is contained in:
Koichi ITO 2026-05-25 02:42:13 +09:00
commit 355c904899

View file

@ -83,6 +83,104 @@ module MCP
provider = Provider.new(**args)
assert_equal("http://localhost:0/callback", provider.redirect_uri)
end
def test_initialize_defaults_client_id_metadata_document_url_to_nil
provider = Provider.new(**args_for("http://localhost:0/callback"))
assert_nil(provider.client_id_metadata_document_url)
end
def test_initialize_accepts_https_client_id_metadata_document_url
args = args_for("http://localhost:0/callback").merge(
client_id_metadata_document_url: "https://app.example.com/client-metadata.json",
)
provider = Provider.new(**args)
assert_equal(
"https://app.example.com/client-metadata.json",
provider.client_id_metadata_document_url,
)
end
def test_initialize_rejects_http_client_id_metadata_document_url
# The loopback `http` carve-out used for discovery does not extend to the CIMD URL:
# the URL is sent to the AS as the OAuth `client_id` and travels off-loopback,
# so MCP requires `https`.
["http://localhost:8080/client-metadata.json", "http://app.example.com/cm"].each do |uri|
args = args_for("http://localhost:0/callback").merge(client_id_metadata_document_url: uri)
assert_raises(Provider::InvalidClientIDMetadataDocumentURLError, "should reject #{uri}") do
Provider.new(**args)
end
end
end
def test_initialize_rejects_non_https_scheme_client_id_metadata_document_url
["ftp://app.example.com/cm", "file:///cm", "foo://bar/cm"].each do |uri|
args = args_for("http://localhost:0/callback").merge(client_id_metadata_document_url: uri)
assert_raises(Provider::InvalidClientIDMetadataDocumentURLError, "should reject #{uri}") do
Provider.new(**args)
end
end
end
def test_initialize_rejects_client_id_metadata_document_url_without_path
# The CIMD document is a discrete resource, not the origin.
# A bare origin or root-path URL would let two different deployments at
# the same origin shadow each other under one `client_id`.
["https://app.example.com", "https://app.example.com/"].each do |uri|
args = args_for("http://localhost:0/callback").merge(client_id_metadata_document_url: uri)
assert_raises(Provider::InvalidClientIDMetadataDocumentURLError, "should reject #{uri}") do
Provider.new(**args)
end
end
end
def test_initialize_rejects_client_id_metadata_document_url_with_fragment
# A fragment is never sent to the server; embedding one in the `client_id` value
# would make the OAuth `client_id` and the URL the AS dereferences point at different artifacts.
args = args_for("http://localhost:0/callback").merge(
client_id_metadata_document_url: "https://app.example.com/cm#frag",
)
assert_raises(Provider::InvalidClientIDMetadataDocumentURLError) do
Provider.new(**args)
end
end
def test_initialize_rejects_client_id_metadata_document_url_with_query
args = args_for("http://localhost:0/callback").merge(
client_id_metadata_document_url: "https://app.example.com/cm?x=1",
)
assert_raises(Provider::InvalidClientIDMetadataDocumentURLError) do
Provider.new(**args)
end
end
def test_initialize_rejects_client_id_metadata_document_url_with_userinfo
# Embedding credentials in the `client_id` leaks them to every AS
# log line and to the conformance audit trail.
args = args_for("http://localhost:0/callback").merge(
client_id_metadata_document_url: "https://user:pass@app.example.com/cm",
)
assert_raises(Provider::InvalidClientIDMetadataDocumentURLError) do
Provider.new(**args)
end
end
def test_initialize_rejects_client_id_metadata_document_url_with_dot_segments
# `https://x/a/./b` and `https://x/a/b` are RFC 3986 equivalent,
# so accepting both would let one client publish under two `client_id` values.
# Reject `.`/`..` (including percent-encoded `.`).
[
"https://app.example.com/./cm",
"https://app.example.com/a/../cm",
"https://app.example.com/%2E/cm",
].each do |uri|
args = args_for("http://localhost:0/callback").merge(client_id_metadata_document_url: uri)
assert_raises(Provider::InvalidClientIDMetadataDocumentURLError, "should reject #{uri}") do
Provider.new(**args)
end
end
end
end
end
end