ruby-mcp-client 0.7.2 → 0.8.0

data/lib/mcp_client/server_base.rb

@@ -33,6 +33,33 @@ module MCPClient
       raise NotImplementedError, 'Subclasses must implement call_tool'
     end
 
+    # List all prompts available from the MCP server
+    # @return [Array<MCPClient::Prompt>] list of available prompts
+    def list_prompts
+      raise NotImplementedError, 'Subclasses must implement list_prompts'
+    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
+    def get_prompt(prompt_name, parameters)
+      raise NotImplementedError, 'Subclasses must implement get_prompt'
+    end
+
+    # List all resources available from the MCP server
+    # @return [Array<MCPClient::Resource>] list of available resources
+    def list_resources
+      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
+    def read_resource(uri)
+      raise NotImplementedError, 'Subclasses must implement read_resource'
+    end
+
     # Clean up the server connection
     def cleanup
       raise NotImplementedError, 'Subclasses must implement cleanup'

data/lib/mcp_client/server_sse/json_rpc_transport.rb

@@ -7,6 +7,7 @@ module MCPClient
     # JSON-RPC request/notification plumbing for SSE transport
     module JsonRpcTransport
       include JsonRpcCommon
+
       # Generic JSON-RPC request: send method with params and return result
       # @param method [String] JSON-RPC method name
       # @param params [Hash] parameters for the request

data/lib/mcp_client/server_sse.rb

@@ -17,9 +17,11 @@ module MCPClient
 
     include SseParser
     include JsonRpcTransport
+
     require_relative 'server_sse/reconnect_monitor'
 
     include ReconnectMonitor
+
     # Ratio of close_after timeout to ping interval
     CLOSE_AFTER_PING_RATIO = 2.5
 
@@ -36,7 +38,11 @@ module MCPClient
     #   @return [String] The base URL of the MCP server
     # @!attribute [r] tools
     #   @return [Array<MCPClient::Tool>, nil] List of available tools (nil if not fetched yet)
-    attr_reader :base_url, :tools
+    # @!attribute [r] prompts
+    #   @return [Array<MCPClient::Prompt>, nil] List of available prompts (nil if not fetched yet)
+    # @!attribute [r] resources
+    #   @return [Array<MCPClient::Resource>, nil] List of available resources (nil if not fetched yet)
+    attr_reader :base_url, :tools, :prompts, :resources
 
     # Server information from initialize response
     # @return [Hash, nil] Server information
@@ -104,6 +110,104 @@ 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_initialized
+
+        prompts_data = request_prompts_list
+        @mutex.synchronize do
+          @prompts = prompts_data.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
+        # Re-raise these errors directly
+        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
+    # @raise [MCPClient::Errors::ConnectionError] if server is disconnected
+    def get_prompt(prompt_name, parameters)
+      rpc_request('prompts/get', {
+                    name: prompt_name,
+                    arguments: parameters
+                  })
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
+      # Re-raise connection/transport errors directly to match test expectations
+      raise
+    rescue StandardError => e
+      # For all other errors, wrap in PromptGetError
+      raise MCPClient::Errors::PromptGetError, "Error get prompt '#{prompt_name}': #{e.message}"
+    end
+
+    # List all resources available from the MCP server
+    # @return [Array<MCPClient::Resource>] list of available resources
+    # @raise [MCPClient::Errors::ServerError] if server returns an error
+    # @raise [MCPClient::Errors::TransportError] if response isn't valid JSON
+    # @raise [MCPClient::Errors::ResourceReadError] for other errors during resource listing
+    def list_resources
+      @mutex.synchronize do
+        return @resources if @resources
+      end
+
+      begin
+        ensure_initialized
+
+        resources_data = request_resources_list
+        @mutex.synchronize do
+          @resources = resources_data.map do |resource_data|
+            MCPClient::Resource.from_json(resource_data, server: self)
+          end
+        end
+
+        @mutex.synchronize { @resources }
+      rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError, MCPClient::Errors::ServerError
+        # Re-raise these errors directly
+        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 [Object] the resource contents
+    # @raise [MCPClient::Errors::ServerError] if server returns an error
+    # @raise [MCPClient::Errors::TransportError] if response isn't valid JSON
+    # @raise [MCPClient::Errors::ResourceReadError] for other errors during resource reading
+    # @raise [MCPClient::Errors::ConnectionError] if server is disconnected
+    def read_resource(uri)
+      rpc_request('resources/read', {
+                    uri: uri
+                  })
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
+      # Re-raise connection/transport errors directly to match test expectations
+      raise
+    rescue StandardError => e
+      # For all other errors, wrap in ResourceReadError
+      raise MCPClient::Errors::ResourceReadError, "Error reading resource '#{uri}': #{e.message}"
+    end
+
     # List all tools available from the MCP server
     # @return [Array<MCPClient::Tool>] list of available tools
     # @raise [MCPClient::Errors::ServerError] if server returns an error
@@ -465,6 +569,58 @@ module MCPClient
       raise MCPClient::Errors::ConnectionError, "Authorization failed: #{error_message}"
     end
 
+    # Request the prompts list using JSON-RPC
+    # @return [Array<Hash>] the prompts data
+    # @raise [MCPClient::Errors::PromptGetError] if prompts list retrieval fails
+    # @private
+    def request_prompts_list
+      @mutex.synchronize do
+        return @prompts_data if @prompts_data
+      end
+
+      result = rpc_request('prompts/list')
+
+      if result && result['prompts']
+        @mutex.synchronize do
+          @prompts_data = result['prompts']
+        end
+        return @mutex.synchronize { @prompts_data.dup }
+      elsif result
+        @mutex.synchronize do
+          @prompts_data = result
+        end
+        return @mutex.synchronize { @prompts_data.dup }
+      end
+
+      raise MCPClient::Errors::PromptGetError, 'Failed to get prompts list from JSON-RPC request'
+    end
+
+    # Request the resources list using JSON-RPC
+    # @return [Array<Hash>] the resources data
+    # @raise [MCPClient::Errors::ResourceReadError] if resources list retrieval fails
+    # @private
+    def request_resources_list
+      @mutex.synchronize do
+        return @resources_data if @resources_data
+      end
+
+      result = rpc_request('resources/list')
+
+      if result && result['resources']
+        @mutex.synchronize do
+          @resources_data = result['resources']
+        end
+        return @mutex.synchronize { @resources_data.dup }
+      elsif result
+        @mutex.synchronize do
+          @resources_data = result
+        end
+        return @mutex.synchronize { @resources_data.dup }
+      end
+
+      raise MCPClient::Errors::ResourceReadError, 'Failed to get resources list from JSON-RPC request'
+    end
+
     # Request the tools list using JSON-RPC
     # @return [Array<Hash>] the tools data
     # @raise [MCPClient::Errors::ToolCallError] if tools list retrieval fails

data/lib/mcp_client/server_stdio/json_rpc_transport.rb

@@ -7,6 +7,7 @@ module MCPClient
     # JSON-RPC request/notification plumbing for stdio transport
     module JsonRpcTransport
       include JsonRpcCommon
+
       # Ensure the server process is started and initialized (handshake)
       # @return [void]
       # @raise [MCPClient::Errors::ConnectionError] if initialization fails

data/lib/mcp_client/server_stdio.rb

@@ -102,6 +102,97 @@ module MCPClient
       # Skip non-JSONRPC lines in the output stream
     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::PromptGetError] for other errors during prompt listing
+    def list_prompts
+      ensure_initialized
+      req_id = next_id
+      req = { 'jsonrpc' => '2.0', 'id' => req_id, 'method' => 'prompts/list', 'params' => {} }
+      send_request(req)
+      res = wait_response(req_id)
+      if (err = res['error'])
+        raise MCPClient::Errors::ServerError, err['message']
+      end
+
+      (res.dig('result', 'prompts') || []).map { |td| MCPClient::Prompt.from_json(td, server: self) }
+    rescue StandardError => e
+      raise MCPClient::Errors::PromptGetError, "Error listing prompts: #{e.message}"
+    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::PromptGetError] for other errors during prompt interpolation
+    def get_prompt(prompt_name, parameters)
+      ensure_initialized
+      req_id = next_id
+      # JSON-RPC method for getting a prompt
+      req = {
+        'jsonrpc' => '2.0',
+        'id' => req_id,
+        'method' => 'prompts/get',
+        'params' => { 'name' => prompt_name, 'arguments' => parameters }
+      }
+      send_request(req)
+      res = wait_response(req_id)
+      if (err = res['error'])
+        raise MCPClient::Errors::ServerError, err['message']
+      end
+
+      res['result']
+    rescue StandardError => e
+      raise MCPClient::Errors::PromptGetError, "Error calling prompt '#{prompt_name}': #{e.message}"
+    end
+
+    # List all resources available from the MCP server
+    # @return [Array<MCPClient::Resource>] list of available resources
+    # @raise [MCPClient::Errors::ServerError] if server returns an error
+    # @raise [MCPClient::Errors::ResourceReadError] for other errors during resource listing
+    def list_resources
+      ensure_initialized
+      req_id = next_id
+      req = { 'jsonrpc' => '2.0', 'id' => req_id, 'method' => 'resources/list', 'params' => {} }
+      send_request(req)
+      res = wait_response(req_id)
+      if (err = res['error'])
+        raise MCPClient::Errors::ServerError, err['message']
+      end
+
+      (res.dig('result', 'resources') || []).map { |td| MCPClient::Resource.from_json(td, server: self) }
+    rescue StandardError => e
+      raise MCPClient::Errors::ResourceReadError, "Error listing resources: #{e.message}"
+    end
+
+    # Read a resource by its URI
+    # @param uri [String] the URI of the resource to read
+    # @return [Object] the resource contents
+    # @raise [MCPClient::Errors::ServerError] if server returns an error
+    # @raise [MCPClient::Errors::ResourceReadError] for other errors during resource reading
+    def read_resource(uri)
+      ensure_initialized
+      req_id = next_id
+      # JSON-RPC method for reading a resource
+      req = {
+        'jsonrpc' => '2.0',
+        'id' => req_id,
+        'method' => 'resources/read',
+        'params' => { 'uri' => uri }
+      }
+      send_request(req)
+      res = wait_response(req_id)
+      if (err = res['error'])
+        raise MCPClient::Errors::ServerError, err['message']
+      end
+
+      res['result']
+    rescue StandardError => e
+      raise MCPClient::Errors::ResourceReadError, "Error reading resource '#{uri}': #{e.message}"
+    end
+
     # List all tools available from the MCP server
     # @return [Array<MCPClient::Tool>] list of available tools
     # @raise [MCPClient::Errors::ServerError] if server returns an error

data/lib/mcp_client/server_streamable_http/json_rpc_transport.rb

@@ -45,30 +45,44 @@ module MCPClient
       # @return [Hash] the parsed JSON data
       # @raise [MCPClient::Errors::TransportError] if no data found in SSE response
       def parse_sse_response(sse_body)
-        # Extract JSON data and event ID from SSE format
+        # Extract JSON data from SSE format, processing events separately
         # SSE format: event: message\nid: 123\ndata: {...}\n\n
-        data_lines = []
-        event_id = nil
+        events = []
+        current_event = { type: nil, data_lines: [], id: nil }
 
         sse_body.lines.each do |line|
           line = line.strip
-          if line.start_with?('data:')
-            data_lines << line.sub(/^data:\s*/, '').strip
+
+          if line.empty?
+            # Empty line marks end of an event
+            events << current_event.dup if current_event[:type] && !current_event[:data_lines].empty?
+            current_event = { type: nil, data_lines: [], id: nil }
+          elsif line.start_with?('event:')
+            current_event[:type] = line.sub(/^event:\s*/, '').strip
+          elsif line.start_with?('data:')
+            current_event[:data_lines] << line.sub(/^data:\s*/, '').strip
           elsif line.start_with?('id:')
-            event_id = line.sub(/^id:\s*/, '').strip
+            current_event[:id] = line.sub(/^id:\s*/, '').strip
           end
         end
 
-        raise MCPClient::Errors::TransportError, 'No data found in SSE response' if data_lines.empty?
+        # Handle last event if no trailing empty line
+        events << current_event if current_event[:type] && !current_event[:data_lines].empty?
+
+        # Find the first 'message' event which contains the JSON-RPC response
+        message_event = events.find { |e| e[:type] == 'message' }
+
+        raise MCPClient::Errors::TransportError, 'No data found in SSE response' unless message_event
+        raise MCPClient::Errors::TransportError, 'No data found in message event' if message_event[:data_lines].empty?
 
-        # Track the last event ID for resumability
-        if event_id && !event_id.empty?
-          @last_event_id = event_id
-          @logger.debug("Tracking event ID for resumability: #{event_id}")
+        # Track the event ID for resumability
+        if message_event[:id] && !message_event[:id].empty?
+          @last_event_id = message_event[:id]
+          @logger.debug("Tracking event ID for resumability: #{message_event[:id]}")
         end
 
         # Join multiline data fields according to SSE spec
-        json_data = data_lines.join("\n")
+        json_data = message_event[:data_lines].join("\n")
         JSON.parse(json_data)
       end
     end