ruby-mcp-client 2.1.0 → 3.0.0

data/lib/mcp_client/oauth_client.rb

@@ -22,6 +22,8 @@ module MCPClient
     # @option options [Object, nil] :storage Storage backend for OAuth tokens and client info
     # @option options [String, nil] :client_id_metadata_url HTTPS URL of this client's
     #   Client ID Metadata Document (SEP-991)
+    # @option options [String, nil] :application_type 'native' or 'web' for Dynamic Client
+    #   Registration (MCP 2026-07-28; derived from the redirect URI when omitted)
     # @return [ServerHTTP] OAuth-enabled HTTP server
     def self.create_http_server(server_url:, **options)
       opts = default_server_options.merge(options)
@@ -32,7 +34,8 @@ module MCPClient
         scope: opts[:scope],
         logger: opts[:logger],
         storage: opts[:storage],
-        client_id_metadata_url: opts[:client_id_metadata_url]
+        client_id_metadata_url: opts[:client_id_metadata_url],
+        application_type: opts[:application_type]
       )
 
       ServerHTTP.new(
@@ -61,7 +64,8 @@ module MCPClient
         scope: opts[:scope],
         logger: opts[:logger],
         storage: opts[:storage],
-        client_id_metadata_url: opts[:client_id_metadata_url]
+        client_id_metadata_url: opts[:client_id_metadata_url],
+        application_type: opts[:application_type]
       )
 
       ServerStreamableHTTP.new(
@@ -93,13 +97,17 @@ module MCPClient
     # @param server [ServerHTTP, ServerStreamableHTTP] The OAuth-enabled server
     # @param code [String] Authorization code from callback
     # @param state [String] State parameter from callback
+    # @param iss [String, nil] the `iss` parameter of the authorization response (RFC 9207,
+    #   MCP 2026-07-28), validated against the recorded issuer before the token exchange
     # @return [Auth::Token] Access token
     # @raise [ArgumentError] if server doesn't have OAuth provider
-    def self.complete_oauth_flow(server, code, state)
+    def self.complete_oauth_flow(server, code, state, iss: nil)
       oauth_provider = server.instance_variable_get(:@oauth_provider)
       raise ArgumentError, 'Server does not have OAuth provider configured' unless oauth_provider
 
-      oauth_provider.complete_authorization_flow(code, state)
+      return oauth_provider.complete_authorization_flow(code, state) if iss.nil?
+
+      oauth_provider.complete_authorization_flow(code, state, iss: iss)
     end
 
     # Check if server has a valid OAuth access token
@@ -125,7 +133,8 @@ module MCPClient
         name: nil,
         logger: nil,
         storage: nil,
-        client_id_metadata_url: nil
+        client_id_metadata_url: nil,
+        application_type: nil
       }
     end
   end

data/lib/mcp_client/prompt.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'deep_copy'
+
 module MCPClient
   # Representation of an MCP prompt
   class Prompt
+    include MCPClient::DeepCopy
+
     # @!attribute [r] name
     #   @return [String] the name of the prompt
     # @!attribute [r] title

data/lib/mcp_client/request_authorization.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # The Authorization one request went out with, kept per thread and per
+  # transport (MCP 2026-07-28 caching, cacheScope "private"): a result is
+  # bound to the credentials of its own request rather than to whatever the
+  # transport is configured with at the moment it is recorded.
+  #
+  # Every transport that can send an Authorization header keeps it the same
+  # way, in a slot named after the transport's `object_id` so that
+  # {MCPClient::ResultCaching#forget_transport_thread_state} finds it: a
+  # worker thread that builds and discards transports must not keep one
+  # entry per transport for its whole life.
+  module RequestAuthorization
+    # Thread-local marker meaning "this attempt has not applied its headers
+    # yet": a failure before that point leaves the credentials of the
+    # attempt unknown, so no private stale copy may be served for it.
+    UNRECORDED_AUTHORIZATION = :unrecorded
+
+    # Thread-local marker for "this attempt went out with no Authorization
+    # at all". The anonymous context is `nil` everywhere else, and an empty
+    # thread-local slot is `nil` too: a request that really was anonymous is
+    # noted with this marker so that a slot a cleanup dropped reads as
+    # unrecorded rather than as an anonymous request that never happened.
+    ANONYMOUS_AUTHORIZATION = :anonymous
+
+    private
+
+    # Remember the Authorization header a request goes out with, on the
+    # thread that sends it, so the result it brings back can be bound to
+    # that context.
+    # @param authorization [String, nil] the Authorization header of the request
+    # @return [void]
+    def note_request_authorization(authorization)
+      file_request_authorization(authorization_fingerprint(authorization) || ANONYMOUS_AUTHORIZATION)
+    end
+
+    # Forget the header recorded before middleware ran: until the request is
+    # sent (or its error reports the headers) the attempt's context is
+    # unknown, so no private stale copy can be served for it.
+    # @return [void]
+    def note_request_authorization_pending
+      file_request_authorization(UNRECORDED_AUTHORIZATION)
+    end
+
+    # Run one exchange with a record of its own.
+    #
+    # A record is filed against the innermost exchange open on this thread,
+    # and when that exchange ends the record it made stands again — over
+    # anything a request nested inside it left behind. A host `on_complete`
+    # may send a request of its own, under credentials of its own, before the
+    # exchange it is nested in has bound its result or failed; the failing
+    # request must still be judged by what it carried itself (MCP 2026-07-28
+    # caching, cacheScope "private").
+    #
+    # A resend the exchange makes for itself — the one after a session
+    # restart — is not nested: it opens no exchange of its own, so its
+    # credentials are this exchange's, exactly as they were before.
+    # @yield the exchange
+    # @return [Object] the block's value
+    def recording_one_exchange
+      stack = (Thread.current[exchange_records_key] ||= [])
+      own = []
+      stack.push(own)
+      begin
+        yield
+      ensure
+        stack.pop
+        Thread.current[exchange_records_key] = nil if stack.empty?
+        # Written straight to the slot, never filed: this record is this
+        # exchange's, and filing it would make it the enclosing exchange's
+        # too — which is the very confusion the frame exists to prevent.
+        Thread.current[request_authorization_key] = own.first unless own.empty?
+      end
+    end
+
+    # @param record [String, Symbol, nil] the record to file for the request being sent
+    # @return [void]
+    def file_request_authorization(record)
+      Thread.current[request_authorization_key] = record
+      own = Thread.current[exchange_records_key]&.last
+      own&.replace([record])
+      nil
+    end
+
+    # The record this thread holds for the request it is sending, exactly as
+    # it stands. Taken before a response is parsed and put back afterwards
+    # ({MCPClient::HttpTransportBase::CacheSupport#exchange_jsonrpc}): the
+    # parse dispatches the notifications the response carried, and a request
+    # host code nests inside it would otherwise leave its own record here.
+    # @return [String, Symbol, nil]
+    def recorded_request_authorization
+      Thread.current[request_authorization_key]
+    end
+
+    # @param record [String, Symbol, nil] a record {#recorded_request_authorization} handed out
+    # @return [void]
+    def restore_request_authorization(record)
+      file_request_authorization(record)
+    end
+
+    # @return [String, nil] the Authorization header of the request this thread last sent
+    def request_authorization_context
+      context = Thread.current[request_authorization_key]
+      context.is_a?(String) ? context : nil
+    end
+
+    # @return [Boolean] whether the current attempt on this thread applied
+    #   its headers. An empty slot — nothing sent yet on this thread, or a
+    #   cleanup that dropped what this transport left on it — is as
+    #   unrecorded as the pending marker.
+    def request_authorization_recorded?
+      context = Thread.current[request_authorization_key]
+      !context.nil? && context != UNRECORDED_AUTHORIZATION
+    end
+
+    # @return [Symbol] the thread-local key of this transport's request authorization
+    def request_authorization_key
+      :"mcp_client_request_authorization_#{object_id}"
+    end
+
+    # @return [Symbol] the thread-local key of the exchanges open on this
+    #   thread, innermost last
+    def exchange_records_key
+      :"mcp_client_exchange_records_#{object_id}"
+    end
+  end
+end

data/lib/mcp_client/request_meta_scope.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # The operations a transport may make a cache decision for, each wrapped in
+  # a scope that reserves the evaluation of the host's `request_meta` for the
+  # request the operation leads to (MCP 2026-07-28 server/utilities/caching:
+  # a decision is weighed on the parameters the request will carry, and a
+  # host callable that vends a one-time value is read once for the two).
+  #
+  # Prepended to the transports, so the reservation is a property of the
+  # operation rather than of any path through it:
+  #
+  # * it is adopted only by the operation it was opened for, which the
+  #   opener hands it to by name ({MCPClient::RequestMetadata#offer_request_meta_hold});
+  #   an operation that merely uses the same method reserves its own;
+  # * it is spent by the request the operation sends and by nothing else --
+  #   a reconnect's handshake, the `subscriptions/listen` a reconnect
+  #   re-opens, a `notifications/cancelled` for an abandoned request, and
+  #   every request host code issues from behind the boundary the transport
+  #   crosses to reach it -- a nested list, a raw `rpc_request` or
+  #   `fetch_prompts_list` of the very method the operation holds -- all read
+  #   the host afresh ({MCPClient::JsonRpcCommon#request_meta_claim});
+  # * it never outlives the operation, whichever way that ends -- a value
+  #   returned, a reconnect or an initialization that raised, an error a
+  #   caller swallowed -- because the scope drops it from an `ensure`.
+  module RequestMetaScope
+    # Each operation and the JSON-RPC method of the request it leads to.
+    SCOPED_OPERATIONS = {
+      list_tools: 'tools/list',
+      list_prompts: 'prompts/list',
+      list_resources: 'resources/list',
+      list_resource_templates: 'resources/templates/list',
+      read_resource: 'resources/read',
+      get_prompt: 'prompts/get',
+      call_tool: 'tools/call'
+    }.freeze
+
+    SCOPED_OPERATIONS.each do |operation, request_method|
+      next if operation == :call_tool
+
+      define_method(operation) do |*args, **kwargs, &block|
+        holding_request_meta(request_method) { super(*args, **kwargs, &block) }
+      end
+    end
+
+    # A call also gets a slot of its own for the tool definition its request
+    # goes out under, so a nested exchange records into its own
+    # ({MCPClient::CalledToolDefinition}).
+    define_method(:call_tool) do |*args, **kwargs, &block|
+      holding_request_meta(SCOPED_OPERATIONS[:call_tool]) do
+        recording_called_tool_definition { super(*args, **kwargs, &block) }
+      end
+    end
+
+    # Where a transport hands control to host code: a notification listener
+    # (and, through it, a subscription's listeners and the client's own
+    # dispatch) and a handler for a server-initiated request. Whatever that
+    # code asks of the transport is an operation of its own -- a raw
+    # `rpc_request`, a `send_rpc`, a public `fetch_prompts_list`, a nested
+    # list -- so it never reaches the reservation the operation it
+    # interrupted is holding, whatever method it names. A `tools/call` it
+    # issues records the definition it goes out under into a slot of its own
+    # for the same reason ({MCPClient::CalledToolDefinition}): the call whose
+    # response is still being parsed keeps its own.
+    HOST_CALLBACKS = %i[route_notification handle_server_request].freeze
+
+    HOST_CALLBACKS.each do |callback|
+      define_method(callback) do |*args, **kwargs, &block|
+        raise NoMethodError, "undefined method '#{callback}' for #{self.class}" unless defined?(super)
+
+        outside_request_meta_hold do
+          outside_called_tool_definition { super(*args, **kwargs, &block) }
+        end
+      end
+    end
+  end
+end

data/lib/mcp_client/request_metadata.rb

@@ -0,0 +1,287 @@
+# frozen_string_literal: true
+
+require 'digest'
+require 'json'
+
+module MCPClient
+  # The metadata a request carries and the fingerprint a cached result is
+  # bound to (MCP 2026-07-28 basic/index "_meta", server/utilities/caching):
+  # the reserved protocol keys, the effective parameters of the request this
+  # thread last built, and the evaluation of the host's `request_meta` that a
+  # cache decision holds for the request it leads to.
+  #
+  # Each slot is named after the transport's `object_id`, so a worker thread
+  # that builds and discards transports keeps nothing of theirs for its life.
+  module RequestMetadata
+    # `_meta` keys that identify one request rather than what it asks for
+    # (the progress token and the W3C trace identifiers): a cached result
+    # does not depend on them. `baggage` is deliberately not among them --
+    # it carries application-defined context (a tenant, a locale), which a
+    # server may well vary its result by, so a result cached under one
+    # baggage is never served under another.
+    CACHE_NEUTRAL_META_KEYS = %w[progressToken traceparent tracestate].freeze
+
+    # Remember the effective parameters a request goes out with, so a result
+    # cached from it is bound to them (MCP 2026-07-28 caching: a server may
+    # vary a result by host metadata such as a vendor tenant key).
+    # @param params [Hash, nil] the effective (wire) parameters
+    # @return [void]
+    def note_request_params(params)
+      Thread.current[request_params_key] = params_fingerprint_of(params)
+    end
+
+    # @return [String, nil] the fingerprint of the effective parameters of
+    #   the request this thread last built
+    def request_params_fingerprint
+      Thread.current[request_params_key]
+    end
+
+    # The fingerprint this thread holds, exactly as it stands — never the
+    # transport's reading of it. Taken when an exchange starts and put back
+    # when it ends ({MCPClient::HttpTransportBase::CacheSupport#exchange_jsonrpc}):
+    # a request nested inside it notes parameters of its own, and the host
+    # may go on rewriting the metadata it handed the transport while the
+    # response is on its way back. A fingerprint is taken when the request is
+    # built, so what it describes is the request as sent.
+    # @return [String, Symbol, nil]
+    def recorded_request_params
+      Thread.current[request_params_key]
+    end
+
+    # @param record [String, Symbol, nil] a record {#recorded_request_params} handed out
+    # @return [void]
+    def restore_request_params(record)
+      Thread.current[request_params_key] = record
+    end
+
+    # Marks an attempt that has not built its request yet: the parameters
+    # of the previous request on this thread say nothing about it.
+    UNRECORDED_PARAMS = :unrecorded
+
+    # Marks a request whose effective parameters the transport cannot read:
+    # host middleware may rewrite the body after the transport built it, so
+    # the parameters the server answers are not the ones a fingerprint of the
+    # request would describe. It is not a fingerprint and matches none, so no
+    # result is served across it whatever its `cacheScope` — "public" permits
+    # sharing across callers, not across result-affecting parameters.
+    OPAQUE_PARAMS = :opaque
+
+    # @return [void]
+    def note_request_params_pending
+      Thread.current[request_params_key] = UNRECORDED_PARAMS
+    end
+
+    # The evaluation of the host's `request_meta` that one operation reserves
+    # for the request it leads to: the JSON-RPC method of that request, the
+    # evaluation once it has been made, and whether the request it was held
+    # for has already spent it.
+    #
+    # A reservation is claimed by that one request and by nothing else.
+    # Everything else a transport sends while it is open -- a reconnect's
+    # handshake, the `subscriptions/listen` a reconnect re-opens, the
+    # `notifications/cancelled` for an abandoned request, a raw `rpc_request`
+    # or nested list a notification listener issues -- reads the host afresh
+    # and leaves the reservation for the request that holds it.
+    HeldRequestMeta = Struct.new(:request_method, :evaluated, :value, :spent)
+
+    # Reserve the evaluation of the host's `request_meta` for the request
+    # `method` this operation leads to, for the operation's dynamic extent
+    # and no longer: however it ends -- a value returned, a reconnect that
+    # raised, a caller that swallowed the error -- the reservation goes with
+    # it, so no later request on this thread can carry it.
+    # @param method [String] the JSON-RPC method of the request the operation sends
+    # @yield the operation
+    # @return [Object] the block's value
+    def holding_request_meta(method)
+      open_request_meta_hold(method)
+      begin
+        yield
+      ensure
+        close_request_meta_hold
+      end
+    end
+
+    # Open a hold scope without a block, for a caller whose operation spans
+    # several transports (a client listing across its servers). Every opener
+    # closes it from an `ensure`.
+    #
+    # The operation adopts a reservation only when that very reservation was
+    # handed to it ({#offer_request_meta_hold}) -- the opener naming the
+    # operation it made it for, immediately before invoking it. Sharing a
+    # method name is not enough: an operation that begins meanwhile (a list a
+    # notification listener runs on a server the opener's loop has not
+    # reached) would otherwise spend an evaluation weighed for somebody else,
+    # sending its tenant, baggage or nonce on the wrong request and leaving
+    # the right one to go out under an evaluation nothing weighed.
+    # @param method [String] the JSON-RPC method of the request the operation sends
+    # @return [MCPClient::RequestMetadata::HeldRequestMeta] this operation's reservation
+    def open_request_meta_hold(method)
+      stack = (Thread.current[held_request_meta_key] ||= [])
+      reservation = adoptable_request_meta_hold(take_offered_request_meta_hold, stack.last, method) ||
+                    HeldRequestMeta.new(method, false, nil, false)
+      stack.push(reservation)
+      reservation
+    end
+
+    # @param offered [MCPClient::RequestMetadata::HeldRequestMeta, nil] the reservation handed over
+    # @param innermost [MCPClient::RequestMetadata::HeldRequestMeta, nil] the reservation open here
+    # @param method [String] the JSON-RPC method of the request the operation sends
+    # @return [MCPClient::RequestMetadata::HeldRequestMeta, nil] the offer when
+    #   it really is the reservation open here, still waiting for the request
+    #   it was made for
+    def adoptable_request_meta_hold(offered, innermost, method)
+      return nil if offered.nil? || !offered.equal?(innermost)
+
+      offered if offered.request_method == method && !offered.spent
+    end
+
+    # Hand a reservation to the one operation it was opened for: the next
+    # operation this transport opens adopts it, and only if it really is the
+    # reservation currently innermost here. The offer is taken up once; an
+    # opener that never invokes the operation withdraws it.
+    # @param reservation [MCPClient::RequestMetadata::HeldRequestMeta]
+    # @return [void]
+    def offer_request_meta_hold(reservation)
+      Thread.current[offered_request_meta_key] = reservation
+      nil
+    end
+
+    # @return [void]
+    def withdraw_request_meta_hold
+      Thread.current[offered_request_meta_key] = nil
+      nil
+    end
+
+    # @return [MCPClient::RequestMetadata::HeldRequestMeta, nil] the offer,
+    #   which no later operation can take up again
+    def take_offered_request_meta_hold
+      offered = Thread.current[offered_request_meta_key]
+      Thread.current[offered_request_meta_key] = nil unless offered.nil?
+      offered
+    end
+
+    # The boundary a transport crosses when it hands control to host code: a
+    # notification listener, a handler for a server-initiated request. The
+    # reservation the open operation holds is out of reach behind it, so
+    # whatever that code issues -- a nested list, a raw `rpc_request`, a
+    # `fetch_prompts_list`, whatever method it names -- reads the host afresh
+    # and is an operation of its own.
+    # @yield the host code
+    # @return [Object] the block's value
+    def outside_request_meta_hold
+      stack = (Thread.current[held_request_meta_key] ||= [])
+      stack.push(nil)
+      begin
+        yield
+      ensure
+        close_request_meta_hold
+      end
+    end
+
+    # Close the innermost hold scope.
+    # @return [void]
+    def close_request_meta_hold
+      stack = Thread.current[held_request_meta_key]
+      return nil unless stack.is_a?(Array)
+
+      stack.pop
+      Thread.current[held_request_meta_key] = nil if stack.empty?
+      nil
+    end
+
+    # @return [MCPClient::RequestMetadata::HeldRequestMeta, nil] the
+    #   reservation of the innermost operation open on this thread
+    def held_request_meta
+      stack = Thread.current[held_request_meta_key]
+      stack.last if stack.is_a?(Array)
+    end
+
+    # @return [MCPClient::RequestMetadata::HeldRequestMeta, nil] that
+    #   reservation while the request it was made for may still claim it
+    def claimable_request_meta_hold
+      held = held_request_meta
+      held unless held.nil? || held.spent
+    end
+
+    # @return [String] the fingerprint of the effective parameters the next
+    #   request on this transport would carry. Reading it evaluates the
+    #   host's request_meta, and the open operation holds that evaluation for
+    #   the request the decision leads to instead of spending it on the
+    #   decision alone. Outside any operation nothing is held at all: an
+    #   evaluation that no request is waiting for is never kept.
+    def current_params_fingerprint
+      params_fingerprint_of(with_request_meta({}, claim: :model))
+    end
+
+    # Drop a held evaluation of the host's request_meta: the decision that
+    # took it leads to no request of its own, so the next one evaluates
+    # afresh rather than sending metadata read some time ago. The scope drops
+    # it too when the operation ends; this is for a decision that settles
+    # before that.
+    # @return [void]
+    def release_held_request_meta
+      held = held_request_meta
+      return nil unless held
+
+      held.evaluated = false
+      held.value = nil
+      nil
+    end
+
+    # @return [Symbol] this transport's thread-local key for held metadata
+    def held_request_meta_key
+      :"mcp_client_held_request_meta_#{object_id}"
+    end
+
+    # @return [Symbol] this transport's thread-local key for the reservation
+    #   offered to the operation about to be opened on it
+    def offered_request_meta_key
+      :"mcp_client_offered_request_meta_#{object_id}"
+    end
+
+    # A stable fingerprint of the metadata that shapes a result: the
+    # effective `_meta` without the protocol version, the log level and the
+    # per-request identifiers. The client identity and capabilities stay
+    # in: a server may vary a result by who asks and by the extensions and
+    # features a request advertises, and those change when the host sets
+    # client_info, drops it, declares an extension or registers a handler.
+    # @param params [Hash, nil] effective parameters
+    # @return [String]
+    def params_fingerprint_of(params)
+      meta = params.is_a?(Hash) ? (params['_meta'] || params[:_meta]) : nil
+      meta = meta.is_a?(Hash) ? meta.transform_keys(&:to_s) : {}
+      meta = meta.except(META_PROTOCOL_VERSION, META_LOG_LEVEL, *CACHE_NEUTRAL_META_KEYS)
+      Digest::SHA256.hexdigest(JSON.generate(deep_sort_keys(meta)))
+    end
+
+    # @return [Symbol] this transport's thread-local key for the request parameters
+    def request_params_key
+      :"mcp_client_request_params_#{object_id}"
+    end
+
+    # @param value [Object]
+    # @return [Object] the value with every nested Hash sorted by key
+    def deep_sort_keys(value)
+      case value
+      when Hash then value.map { |k, v| [k.to_s, deep_sort_keys(v)] }.sort_by(&:first).to_h
+      when Array then value.map { |v| deep_sort_keys(v) }
+      else value
+      end
+    end
+
+    # Reserved `_meta` keys (MCP 2026-07-28 basic/index "_meta").
+    META_PROTOCOL_VERSION = 'io.modelcontextprotocol/protocolVersion'
+    META_CLIENT_INFO = 'io.modelcontextprotocol/clientInfo'
+    META_CLIENT_CAPABILITIES = 'io.modelcontextprotocol/clientCapabilities'
+    META_LOG_LEVEL = 'io.modelcontextprotocol/logLevel'
+    META_SERVER_INFO = 'io.modelcontextprotocol/serverInfo'
+    META_SUBSCRIPTION_ID = 'io.modelcontextprotocol/subscriptionId'
+
+    # Per-request protocol fields the client owns. A host-supplied `_meta`
+    # may carry anything else (progressToken, trace context, vendor keys),
+    # but these are always set from the transport's own state so the body
+    # can never disagree with what the transport negotiated (on HTTP the
+    # MCP-Protocol-Version header must match the body).
+    PROTECTED_META_KEYS = [META_PROTOCOL_VERSION, META_CLIENT_INFO, META_CLIENT_CAPABILITIES].freeze
+  end
+end

data/lib/mcp_client/resource.rb

@@ -1,8 +1,12 @@
 # frozen_string_literal: true
 
+require_relative 'deep_copy'
+
 module MCPClient
   # Representation of an MCP resource
   class Resource
+    include MCPClient::DeepCopy
+
     # @!attribute [r] uri
     #   @return [String] unique identifier for the resource
     # @!attribute [r] name

data/lib/mcp_client/resource_content.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative 'deep_copy'
+
 module MCPClient
   # Representation of MCP resource content
   # Resources can contain either text or binary data
@@ -45,6 +47,24 @@ module MCPClient
       @meta = meta
     end
 
+    # A copy that shares nothing mutable with the original (cached contents
+    # are handed out as copies, so a caller's edits stay its own).
+    # @param source [ResourceContent]
+    # @return [void]
+    def initialize_copy(source)
+      super
+      @uri = source.uri.dup if source.uri
+      @name = source.name.dup if source.name
+      @title = source.title.dup if source.title
+      @mime_type = source.mime_type.dup if source.mime_type
+      @text = source.text.dup if source.text
+      @blob = source.blob.dup if source.blob
+      # Iterative: peer-supplied annotations or _meta may be nested deeper
+      # than the Ruby stack allows.
+      @annotations = MCPClient::DeepCopy.copy(source.annotations)
+      @meta = MCPClient::DeepCopy.copy(source.meta)
+    end
+
     # Create a ResourceContent instance from JSON data
     # @param data [Hash] JSON data from MCP server
     # @return [MCPClient::ResourceContent] resource content instance

data/lib/mcp_client/resource_template.rb

@@ -1,9 +1,13 @@
 # frozen_string_literal: true
 
+require_relative 'deep_copy'
+
 module MCPClient
   # Representation of an MCP resource template
   # Resource templates allow servers to expose parameterized resources using URI templates
   class ResourceTemplate
+    include MCPClient::DeepCopy
+
     # @!attribute [r] uri_template
     #   @return [String] URI template following RFC 6570
     # @!attribute [r] name