ruby-mcp-client 0.8.0 → 0.9.0

data/lib/mcp_client/client.rb

@@ -21,7 +21,8 @@ module MCPClient
     # Initialize a new MCPClient::Client
     # @param mcp_server_configs [Array<Hash>] configurations for MCP servers
     # @param logger [Logger, nil] optional logger, defaults to STDOUT
-    def initialize(mcp_server_configs: [], logger: nil)
+    # @param elicitation_handler [Proc, nil] optional handler for elicitation requests (MCP 2025-06-18)
+    def initialize(mcp_server_configs: [], logger: nil, elicitation_handler: nil)
       @logger = logger || Logger.new($stdout, level: Logger::WARN)
       @logger.progname = self.class.name
       @logger.formatter = proc { |severity, _datetime, progname, msg| "#{severity} [#{progname}] #{msg}\n" }
@@ -34,6 +35,8 @@ module MCPClient
       @resource_cache = {}
       # JSON-RPC notification listeners
       @notification_listeners = []
+      # Elicitation handler (MCP 2025-06-18)
+      @elicitation_handler = elicitation_handler
       # Register default and user-defined notification handlers on each server
       @servers.each do |server|
         server.on_notification do |method, params|
@@ -42,6 +45,10 @@ module MCPClient
           # Invoke user-defined listeners
           @notification_listeners.each { |cb| cb.call(server, method, params) }
         end
+        # Register elicitation handler on each server
+        if server.respond_to?(:on_elicitation_request)
+          server.on_elicitation_request(&method(:handle_elicitation_request))
+        end
       end
     end
 
@@ -126,17 +133,32 @@ module MCPClient
 
     # Lists all available resources from all connected MCP servers
     # @param cache [Boolean] whether to use cached resources or fetch fresh
-    # @return [Array<MCPClient::Resource>] list of available resources
+    # @param cursor [String, nil] optional cursor for pagination (only works with single server)
+    # @return [Hash] result containing 'resources' array and optional 'nextCursor'
     # @raise [MCPClient::Errors::ConnectionError] on authorization failures
     # @raise [MCPClient::Errors::ResourceReadError] if no resources could be retrieved from any server
-    def list_resources(cache: true)
-      return @resource_cache.values if cache && !@resource_cache.empty?
+    def list_resources(cache: true, cursor: nil)
+      # If cursor is provided, we can only query one server (the one that provided the cursor)
+      # This is a limitation of aggregating multiple servers
+      if cursor
+        # For now, just use the first server when cursor is provided
+        # In a real implementation, you'd need to track which server the cursor came from
+        return servers.first.list_resources(cursor: cursor) if servers.any?
+
+        return { 'resources' => [], 'nextCursor' => nil }
+      end
+
+      # Use cache if available and no cursor
+      return { 'resources' => @resource_cache.values, 'nextCursor' => nil } if cache && !@resource_cache.empty?
 
       resources = []
       connection_errors = []
 
       servers.each do |server|
-        server.list_resources.each do |resource|
+        result = server.list_resources
+        resource_list = result['resources'] || []
+
+        resource_list.each do |resource|
           cache_key = cache_key_for(server, resource.uri)
           @resource_cache[cache_key] = resource
           resources << resource
@@ -152,7 +174,8 @@ module MCPClient
         @logger.error("Server error: #{e.message}")
       end
 
-      resources
+      # Return hash format consistent with server methods
+      { 'resources' => resources, 'nextCursor' => nil }
     end
 
     # Reads a specific resource by URI
@@ -160,46 +183,16 @@ module MCPClient
     # @param server [String, Symbol, Integer, MCPClient::ServerBase, nil] optional server to use
     # @return [Object] the resource contents
     def read_resource(uri, server: nil)
-      resources = list_resources
+      result = list_resources
+      resources = result['resources'] || []
 
-      if server
-        # Use the specified server
-        srv = select_server(server)
-        # Find the resource on this specific server
-        resource = resources.find { |r| r.uri == uri && r.server == srv }
-        unless resource
-          raise MCPClient::Errors::ResourceNotFound,
-                "Resource '#{uri}' not found on server '#{srv.name || srv.class.name}'"
-        end
-      else
-        # Find the resource across all servers
-        matching_resources = resources.select { |r| r.uri == uri }
-
-        if matching_resources.empty?
-          raise MCPClient::Errors::ResourceNotFound, "Resource '#{uri}' not found"
-        elsif matching_resources.size > 1
-          # If multiple matches, disambiguate with server names
-          server_names = matching_resources.map { |r| r.server&.name || 'unnamed' }
-          raise MCPClient::Errors::AmbiguousResourceURI,
-                "Multiple resources with URI '#{uri}' found across servers (#{server_names.join(', ')}). " \
-                "Please specify a server using the 'server' parameter."
-        end
-
-        resource = matching_resources.first
-      end
+      resource = if server
+                   find_resource_on_server(uri, resources, server)
+                 else
+                   find_resource_across_servers(uri, resources)
+                 end
 
-      # Use the resource's associated server
-      server = resource.server
-      raise MCPClient::Errors::ServerNotFound, "No server found for resource '#{uri}'" unless server
-
-      begin
-        server.read_resource(uri)
-      rescue MCPClient::Errors::ConnectionError => e
-        # Add server identity information to the error for better context
-        server_id = server.name ? "#{server.class}[#{server.name}]" : server.class.name
-        raise MCPClient::Errors::ResourceReadError,
-              "Error reading resource '#{uri}': #{e.message} (Server: #{server_id})"
-      end
+      execute_resource_read(resource, uri)
     end
 
     # Lists all available tools from all connected MCP servers
@@ -478,7 +471,7 @@ module MCPClient
       case method
       when 'notifications/tools/list_changed'
         logger.warn("[#{server_id}] Tool list has changed, clearing tool cache")
-        clear_cache
+        @tool_cache.clear
       when 'notifications/resources/updated'
         logger.warn("[#{server_id}] Resource #{params['uri']} updated")
       when 'notifications/prompts/list_changed'
@@ -556,5 +549,126 @@ module MCPClient
       server_id = server.object_id.to_s
       "#{server_id}:#{item_id}"
     end
+
+    # Find a resource on a specific server
+    # @param uri [String] the URI of the resource
+    # @param resources [Array<Resource>] available resources
+    # @param server [String, Symbol, Integer, MCPClient::ServerBase] server selector
+    # @return [Resource] the found resource
+    # @raise [MCPClient::Errors::ResourceNotFound] if resource not found
+    def find_resource_on_server(uri, resources, server)
+      srv = select_server(server)
+      resource = resources.find { |r| r.uri == uri && r.server == srv }
+      unless resource
+        raise MCPClient::Errors::ResourceNotFound,
+              "Resource '#{uri}' not found on server '#{srv.name || srv.class.name}'"
+      end
+      resource
+    end
+
+    # Find a resource across all servers
+    # @param uri [String] the URI of the resource
+    # @param resources [Array<Resource>] available resources
+    # @return [Resource] the found resource
+    # @raise [MCPClient::Errors::ResourceNotFound] if resource not found
+    # @raise [MCPClient::Errors::AmbiguousResourceURI] if multiple resources found
+    def find_resource_across_servers(uri, resources)
+      matching_resources = resources.select { |r| r.uri == uri }
+
+      if matching_resources.empty?
+        raise MCPClient::Errors::ResourceNotFound, "Resource '#{uri}' not found"
+      elsif matching_resources.size > 1
+        server_names = matching_resources.map { |r| r.server&.name || 'unnamed' }
+        raise MCPClient::Errors::AmbiguousResourceURI,
+              "Multiple resources with URI '#{uri}' found across servers (#{server_names.join(', ')}). " \
+              "Please specify a server using the 'server' parameter."
+      end
+
+      matching_resources.first
+    end
+
+    # Execute the resource read operation
+    # @param resource [Resource] the resource to read
+    # @param uri [String] the URI of the resource
+    # @return [Object] the resource contents
+    # @raise [MCPClient::Errors::ServerNotFound] if no server found
+    # @raise [MCPClient::Errors::ResourceReadError] on read errors
+    def execute_resource_read(resource, uri)
+      server = resource.server
+      raise MCPClient::Errors::ServerNotFound, "No server found for resource '#{uri}'" unless server
+
+      begin
+        server.read_resource(uri)
+      rescue MCPClient::Errors::ConnectionError => e
+        server_id = server.name ? "#{server.class}[#{server.name}]" : server.class.name
+        raise MCPClient::Errors::ResourceReadError,
+              "Error reading resource '#{uri}': #{e.message} (Server: #{server_id})"
+      end
+    end
+
+    # Handle elicitation request from server (MCP 2025-06-18)
+    # @param request_id [String, Integer] the JSON-RPC request ID
+    # @param params [Hash] the elicitation parameters
+    # @return [Hash] the elicitation response
+    def handle_elicitation_request(_request_id, params)
+      # If no handler is configured, decline the request
+      unless @elicitation_handler
+        @logger.warn('Received elicitation request but no handler configured, declining')
+        return { 'action' => 'decline' }
+      end
+
+      message = params['message']
+      schema = params['schema'] || params['requestedSchema']
+      metadata = params['metadata']
+
+      begin
+        # Call the user-defined handler
+        result = case @elicitation_handler.arity
+                 when 0
+                   @elicitation_handler.call
+                 when 1
+                   @elicitation_handler.call(message)
+                 when 2, -1
+                   @elicitation_handler.call(message, schema)
+                 else
+                   @elicitation_handler.call(message, schema, metadata)
+                 end
+
+        # Validate and format response
+        case result
+        when Hash
+          if result['action']
+            normalised_action_response(result)
+          elsif result[:action]
+            # Convert symbol keys to strings
+            {
+              'action' => result[:action].to_s,
+              'content' => result[:content]
+            }.compact.then { |payload| normalised_action_response(payload) }
+          else
+            # Assume it's content for an accept action
+            { 'action' => 'accept', 'content' => result }
+          end
+        when nil
+          { 'action' => 'cancel' }
+        else
+          { 'action' => 'accept', 'content' => result }
+        end
+      rescue StandardError => e
+        @logger.error("Elicitation handler error: #{e.message}")
+        @logger.debug(e.backtrace.join("\n"))
+        { 'action' => 'decline' }
+      end
+    end
+
+    # Ensure the action value conforms to MCP spec (accept, decline, cancel)
+    # Falls back to accept for unknown action values.
+    def normalised_action_response(result)
+      action = result['action']
+      return result if %w[accept decline cancel].include?(action)
+
+      @logger.warn("Unknown elicitation action '#{action}', defaulting to accept")
+      result.merge('action' => 'accept')
+    end
   end
 end

data/lib/mcp_client/json_rpc_common.rb

@@ -64,7 +64,9 @@ module MCPClient
     def initialization_params
       {
         'protocolVersion' => MCPClient::PROTOCOL_VERSION,
-        'capabilities' => {},
+        'capabilities' => {
+          'elicitation' => {} # MCP 2025-06-18: Support for server-initiated user interactions
+        },
         'clientInfo' => { 'name' => 'ruby-mcp-client', 'version' => MCPClient::VERSION }
       }
     end

data/lib/mcp_client/resource_content.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Representation of MCP resource content
+  # Resources can contain either text or binary data
+  class ResourceContent
+    # @!attribute [r] uri
+    #   @return [String] unique identifier for the resource
+    # @!attribute [r] name
+    #   @return [String] the name of the resource
+    # @!attribute [r] title
+    #   @return [String, nil] optional human-readable name for display purposes
+    # @!attribute [r] mime_type
+    #   @return [String, nil] optional MIME type
+    # @!attribute [r] text
+    #   @return [String, nil] text content (mutually exclusive with blob)
+    # @!attribute [r] blob
+    #   @return [String, nil] base64-encoded binary content (mutually exclusive with text)
+    # @!attribute [r] annotations
+    #   @return [Hash, nil] optional annotations that provide hints to clients
+    attr_reader :uri, :name, :title, :mime_type, :text, :blob, :annotations
+
+    # Initialize resource content
+    # @param uri [String] unique identifier for the resource
+    # @param name [String] the name of the resource
+    # @param title [String, nil] optional human-readable name for display purposes
+    # @param mime_type [String, nil] optional MIME type
+    # @param text [String, nil] text content (mutually exclusive with blob)
+    # @param blob [String, nil] base64-encoded binary content (mutually exclusive with text)
+    # @param annotations [Hash, nil] optional annotations that provide hints to clients
+    def initialize(uri:, name:, title: nil, mime_type: nil, text: nil, blob: nil, annotations: nil)
+      raise ArgumentError, 'ResourceContent cannot have both text and blob' if text && blob
+      raise ArgumentError, 'ResourceContent must have either text or blob' if !text && !blob
+
+      @uri = uri
+      @name = name
+      @title = title
+      @mime_type = mime_type
+      @text = text
+      @blob = blob
+      @annotations = annotations
+    end
+
+    # Create a ResourceContent instance from JSON data
+    # @param data [Hash] JSON data from MCP server
+    # @return [MCPClient::ResourceContent] resource content instance
+    def self.from_json(data)
+      new(
+        uri: data['uri'],
+        name: data['name'],
+        title: data['title'],
+        mime_type: data['mimeType'],
+        text: data['text'],
+        blob: data['blob'],
+        annotations: data['annotations']
+      )
+    end
+
+    # Check if content is text
+    # @return [Boolean] true if content is text
+    def text?
+      !@text.nil?
+    end
+
+    # Check if content is binary
+    # @return [Boolean] true if content is binary
+    def binary?
+      !@blob.nil?
+    end
+
+    # Get the content (text or decoded blob)
+    # @return [String] the content
+    def content
+      return @text if text?
+
+      require 'base64'
+      Base64.decode64(@blob)
+    end
+  end
+end

data/lib/mcp_client/resource_template.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Representation of an MCP resource template
+  # Resource templates allow servers to expose parameterized resources using URI templates
+  class ResourceTemplate
+    # @!attribute [r] uri_template
+    #   @return [String] URI template following RFC 6570
+    # @!attribute [r] name
+    #   @return [String] the name of the resource template
+    # @!attribute [r] title
+    #   @return [String, nil] optional human-readable name for display purposes
+    # @!attribute [r] description
+    #   @return [String, nil] optional description
+    # @!attribute [r] mime_type
+    #   @return [String, nil] optional MIME type for resources created from this template
+    # @!attribute [r] annotations
+    #   @return [Hash, nil] optional annotations that provide hints to clients
+    # @!attribute [r] server
+    #   @return [MCPClient::ServerBase, nil] the server this resource template belongs to
+    attr_reader :uri_template, :name, :title, :description, :mime_type, :annotations, :server
+
+    # Initialize a new resource template
+    # @param uri_template [String] URI template following RFC 6570
+    # @param name [String] the name of the resource template
+    # @param title [String, nil] optional human-readable name for display purposes
+    # @param description [String, nil] optional description
+    # @param mime_type [String, nil] optional MIME type
+    # @param annotations [Hash, nil] optional annotations that provide hints to clients
+    # @param server [MCPClient::ServerBase, nil] the server this resource template belongs to
+    def initialize(uri_template:, name:, title: nil, description: nil, mime_type: nil, annotations: nil, server: nil)
+      @uri_template = uri_template
+      @name = name
+      @title = title
+      @description = description
+      @mime_type = mime_type
+      @annotations = annotations
+      @server = server
+    end
+
+    # Create a ResourceTemplate instance from JSON data
+    # @param data [Hash] JSON data from MCP server
+    # @param server [MCPClient::ServerBase, nil] the server this resource template belongs to
+    # @return [MCPClient::ResourceTemplate] resource template instance
+    def self.from_json(data, server: nil)
+      new(
+        uri_template: data['uriTemplate'],
+        name: data['name'],
+        title: data['title'],
+        description: data['description'],
+        mime_type: data['mimeType'],
+        annotations: data['annotations'],
+        server: server
+      )
+    end
+  end
+end

data/lib/mcp_client/server_base.rb

@@ -48,18 +48,46 @@ module MCPClient
     end
 
     # List all resources available from the MCP server
-    # @return [Array<MCPClient::Resource>] list of available resources
-    def list_resources
+    # @param cursor [String, nil] optional cursor for pagination
+    # @return [Hash] result containing resources array and optional nextCursor
+    def list_resources(cursor: nil)
       raise NotImplementedError, 'Subclasses must implement list_resources'
     end
 
     # Read a resource by its URI
     # @param uri [String] the URI of the resource to read
-    # @return [Object] the resource contents
+    # @return [Array<MCPClient::ResourceContent>] array of resource contents
     def read_resource(uri)
       raise NotImplementedError, 'Subclasses must implement read_resource'
     end
 
+    # List all resource templates available from the MCP server
+    # @param cursor [String, nil] optional cursor for pagination
+    # @return [Hash] result containing resourceTemplates array and optional nextCursor
+    def list_resource_templates(cursor: nil)
+      raise NotImplementedError, 'Subclasses must implement list_resource_templates'
+    end
+
+    # Subscribe to resource updates
+    # @param uri [String] the URI of the resource to subscribe to
+    # @return [Boolean] true if subscription successful
+    def subscribe_resource(uri)
+      raise NotImplementedError, 'Subclasses must implement subscribe_resource'
+    end
+
+    # Unsubscribe from resource updates
+    # @param uri [String] the URI of the resource to unsubscribe from
+    # @return [Boolean] true if unsubscription successful
+    def unsubscribe_resource(uri)
+      raise NotImplementedError, 'Subclasses must implement unsubscribe_resource'
+    end
+
+    # Get server capabilities
+    # @return [Hash, nil] server capabilities
+    def capabilities
+      raise NotImplementedError, 'Subclasses must implement capabilities'
+    end
+
     # Clean up the server connection
     def cleanup
       raise NotImplementedError, 'Subclasses must implement cleanup'

data/lib/mcp_client/server_factory.rb

@@ -76,7 +76,8 @@ module MCPClient
         retries: config[:retries] || 3,
         retry_backoff: config[:retry_backoff] || 1,
         name: config[:name],
-        logger: logger
+        logger: logger,
+        oauth_provider: config[:oauth_provider]
       )
     end
 
@@ -95,7 +96,8 @@ module MCPClient
         retries: config[:retries] || 3,
         retry_backoff: config[:retry_backoff] || 1,
         name: config[:name],
-        logger: logger
+        logger: logger,
+        oauth_provider: config[:oauth_provider]
       )
     end
 

data/lib/mcp_client/server_http.rb

@@ -12,6 +12,14 @@ module MCPClient
   # Implementation of MCP server that communicates via HTTP requests/responses
   # Useful for communicating with MCP servers that support HTTP-based transport
   # without Server-Sent Events streaming
+  #
+  # @note Elicitation Support (MCP 2025-06-18)
+  #   This transport does NOT support server-initiated elicitation requests.
+  #   The HTTP transport uses a pure request-response architecture where only the client
+  #   can initiate requests. For elicitation support, use one of these transports instead:
+  #   - ServerStdio: Full bidirectional JSON-RPC over stdin/stdout
+  #   - ServerSSE: Server requests via SSE stream, client responses via HTTP POST
+  #   - ServerStreamableHTTP: Server requests via SSE-formatted responses, client responses via HTTP POST
   class ServerHTTP < ServerBase
     require_relative 'server_http/json_rpc_transport'
 
@@ -216,6 +224,148 @@ module MCPClient
       end
     end
 
+    # List all prompts available from the MCP server
+    # @return [Array<MCPClient::Prompt>] list of available prompts
+    # @raise [MCPClient::Errors::ServerError] if server returns an error
+    # @raise [MCPClient::Errors::TransportError] if response isn't valid JSON
+    # @raise [MCPClient::Errors::PromptGetError] for other errors during prompt listing
+    def list_prompts
+      @mutex.synchronize do
+        return @prompts if @prompts
+      end
+
+      begin
+        ensure_connected
+
+        prompts_data = rpc_request('prompts/list')
+        prompts = prompts_data['prompts'] || []
+
+        @mutex.synchronize do
+          @prompts = prompts.map do |prompt_data|
+            MCPClient::Prompt.from_json(prompt_data, server: self)
+          end
+        end
+
+        @mutex.synchronize { @prompts }
+      rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+        raise
+      rescue StandardError => e
+        raise MCPClient::Errors::PromptGetError, "Error listing prompts: #{e.message}"
+      end
+    end
+
+    # Get a prompt with the given parameters
+    # @param prompt_name [String] the name of the prompt to get
+    # @param parameters [Hash] the parameters to pass to the prompt
+    # @return [Object] the result of the prompt interpolation
+    # @raise [MCPClient::Errors::ServerError] if server returns an error
+    # @raise [MCPClient::Errors::TransportError] if response isn't valid JSON
+    # @raise [MCPClient::Errors::PromptGetError] for other errors during prompt interpolation
+    def get_prompt(prompt_name, parameters)
+      rpc_request('prompts/get', {
+                    name: prompt_name,
+                    arguments: parameters
+                  })
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
+      raise
+    rescue StandardError => e
+      raise MCPClient::Errors::PromptGetError, "Error getting prompt '#{prompt_name}': #{e.message}"
+    end
+
+    # List all resources available from the MCP server
+    # @param cursor [String, nil] optional cursor for pagination
+    # @return [Hash] result containing resources array and optional nextCursor
+    # @raise [MCPClient::Errors::ResourceReadError] if resources list retrieval fails
+    def list_resources(cursor: nil)
+      @mutex.synchronize do
+        return @resources_result if @resources_result && !cursor
+      end
+
+      begin
+        ensure_connected
+
+        params = {}
+        params['cursor'] = cursor if cursor
+        result = rpc_request('resources/list', params)
+
+        resources = (result['resources'] || []).map do |resource_data|
+          MCPClient::Resource.from_json(resource_data, server: self)
+        end
+
+        resources_result = { 'resources' => resources, 'nextCursor' => result['nextCursor'] }
+
+        @mutex.synchronize do
+          @resources_result = resources_result unless cursor
+        end
+
+        resources_result
+      rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+        raise
+      rescue StandardError => e
+        raise MCPClient::Errors::ResourceReadError, "Error listing resources: #{e.message}"
+      end
+    end
+
+    # Read a resource by its URI
+    # @param uri [String] the URI of the resource to read
+    # @return [Array<MCPClient::ResourceContent>] array of resource contents
+    # @raise [MCPClient::Errors::ResourceReadError] if resource reading fails
+    def read_resource(uri)
+      result = rpc_request('resources/read', { uri: uri })
+      contents = result['contents'] || []
+      contents.map { |content| MCPClient::ResourceContent.from_json(content) }
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
+      raise
+    rescue StandardError => e
+      raise MCPClient::Errors::ResourceReadError, "Error reading resource '#{uri}': #{e.message}"
+    end
+
+    # List all resource templates available from the MCP server
+    # @param cursor [String, nil] optional cursor for pagination
+    # @return [Hash] result containing resourceTemplates array and optional nextCursor
+    # @raise [MCPClient::Errors::ResourceReadError] for other errors during resource template listing
+    def list_resource_templates(cursor: nil)
+      params = {}
+      params['cursor'] = cursor if cursor
+      result = rpc_request('resources/templates/list', params)
+
+      templates = (result['resourceTemplates'] || []).map do |template_data|
+        MCPClient::ResourceTemplate.from_json(template_data, server: self)
+      end
+
+      { 'resourceTemplates' => templates, 'nextCursor' => result['nextCursor'] }
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+      raise
+    rescue StandardError => e
+      raise MCPClient::Errors::ResourceReadError, "Error listing resource templates: #{e.message}"
+    end
+
+    # Subscribe to resource updates
+    # @param uri [String] the URI of the resource to subscribe to
+    # @return [Boolean] true if subscription successful
+    # @raise [MCPClient::Errors::ResourceReadError] for other errors during subscription
+    def subscribe_resource(uri)
+      rpc_request('resources/subscribe', { uri: uri })
+      true
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+      raise
+    rescue StandardError => e
+      raise MCPClient::Errors::ResourceReadError, "Error subscribing to resource '#{uri}': #{e.message}"
+    end
+
+    # Unsubscribe from resource updates
+    # @param uri [String] the URI of the resource to unsubscribe from
+    # @return [Boolean] true if unsubscription successful
+    # @raise [MCPClient::Errors::ResourceReadError] for other errors during unsubscription
+    def unsubscribe_resource(uri)
+      rpc_request('resources/unsubscribe', { uri: uri })
+      true
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+      raise
+    rescue StandardError => e
+      raise MCPClient::Errors::ResourceReadError, "Error unsubscribing from resource '#{uri}': #{e.message}"
+    end
+
     # Stream tool call (default implementation returns single-value stream)
     # @param tool_name [String] the name of the tool to call
     # @param parameters [Hash] the parameters to pass to the tool

data/lib/mcp_client/server_sse/sse_parser.rb

@@ -31,6 +31,7 @@ module MCPClient
           data = JSON.parse(event[:data])
 
           return if process_error_in_message(data)
+          return if process_server_request?(data)
           return if process_notification?(data)
 
           process_response?(data)
@@ -58,6 +59,16 @@ module MCPClient
         true
       end
 
+      # Process a JSON-RPC request from server (has both id AND method)
+      # @param data [Hash] the parsed JSON payload
+      # @return [Boolean] true if we saw & handled a server request
+      def process_server_request?(data)
+        return false unless data['method'] && data.key?('id')
+
+        handle_server_request(data)
+        true
+      end
+
       # Process a JSON-RPC notification (no id => notification)
       # @param data [Hash] the parsed JSON payload
       # @return [Boolean] true if we saw & handled a notification