ruby-mcp-client 0.7.3 → 0.8.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: fd6b4269c644ed783b7d574e5a60b26ef0c749c3fe0a58fc86b4d7d5d8786a0d
-  data.tar.gz: 58eb4935ec413db8478dc29983f5baa68d7c28627968ffb5189d1b9754090a51
+  metadata.gz: 27b97462ec0c99d98299df120726f90944f495aaddf198272d72725544240ec0
+  data.tar.gz: b58b8a6ba53f698abe1cb3576fba8030d66cb0bd7eafa2e39e28943e7ef1337f
 SHA512:
-  metadata.gz: ee86e5f1e58fb98df9a9a7e715049eb8d7ae5f182430060633c9f97d7b2268d1a02859403ace69f6a400344cffad80dd9238169a638e27491a6bc99ce70fb462
-  data.tar.gz: 27e82788b84bc0887c273ab3c1277180e85f4930f413500fab4dbf2a7474dcb151bf510ec2509caf7a95bf53311dee587e65d8826b226e7ef164d9acd640582a
+  metadata.gz: 50d5791642a74f521133a057d924d3daf14e657ec617e73ad8f95510b4d97f3d52742c5a467c54d75dc02030a087f29e63ee346429271e8c80eb71cb96e38f94
+  data.tar.gz: 5f92d87a5d176e3271a11e9bbea7eafc6720107c6ae795601250e088cde69e6d6340911eecd6ea8ab32776d97d9bfb0b4d3740087509eb704cb400bf4e23e5aa

data/README.md

@@ -49,6 +49,8 @@ This Ruby MCP Client implements key features from the latest MCP specification (
 - **Streamable HTTP Transport** - Enhanced transport with Server-Sent Event formatted responses and session management
 - **HTTP Redirect Support** - Automatic redirect handling for both SSE and HTTP transports with configurable limits
 - **FastMCP Compatibility** - Full compatibility with FastMCP servers including proper line ending handling
+- **Prompts Support** - Full implementation of MCP prompts for dynamic content generation
+- **Resources Support** - Complete resources implementation for accessing files and data with URI-based identification
 
 ## Usage
 
@@ -87,6 +89,17 @@ client = MCPClient.create_client(
       retries: 3,       # Optional number of retry attempts (default: 3)
       retry_backoff: 1, # Optional backoff delay in seconds (default: 1)
       logger: Logger.new($stdout, level: Logger::INFO) # Optional logger for this server
+    ),
+    # Streamable HTTP server (HTTP POST with SSE responses and session management)
+    MCPClient.streamable_http_config(
+      base_url: 'https://api.example.com/mcp',
+      endpoint: '/rpc', # Optional JSON-RPC endpoint path (default: '/rpc')
+      headers: { 'Authorization' => 'Bearer YOUR_TOKEN' },
+      name: 'streamable_api', # Optional name for this server
+      read_timeout: 60, # Optional timeout in seconds (default: 30)
+      retries: 3,       # Optional number of retry attempts (default: 3)
+      retry_backoff: 1, # Optional backoff delay in seconds (default: 1)
+      logger: Logger.new($stdout, level: Logger::INFO) # Optional logger for this server
     )
   ],
   # Optional logger for the client and all servers without explicit loggers
@@ -100,13 +113,14 @@ client = MCPClient.create_client(
 )
 
 # MCP server configuration JSON format can be:
-# 1. A single server object: 
+# 1. A single server object:
 #    { "type": "sse", "url": "http://example.com/sse" }
 #    { "type": "http", "url": "http://example.com", "endpoint": "/rpc" }
-# 2. An array of server objects: 
-#    [{ "type": "stdio", "command": "npx server" }, { "type": "sse", "url": "http://..." }, { "type": "http", "url": "http://..." }]
+#    { "type": "streamable_http", "url": "http://example.com/mcp", "endpoint": "/rpc" }
+# 2. An array of server objects:
+#    [{ "type": "stdio", "command": "npx server" }, { "type": "sse", "url": "http://..." }, { "type": "streamable_http", "url": "http://..." }]
 # 3. An object with "mcpServers" key containing named servers:
-#    { "mcpServers": { "server1": { "type": "sse", "url": "http://..." }, "server2": { "type": "http", "url": "http://..." } } }
+#    { "mcpServers": { "server1": { "type": "sse", "url": "http://..." }, "server2": { "type": "streamable_http", "url": "http://..." } } }
 #    Note: When using this format, server1/server2 will be accessible by name
 
 # List available tools
@@ -140,6 +154,26 @@ client.call_tool_streaming('streaming_tool', { param: 'value' }, server: 'api').
   puts chunk
 end
 
+# === Working with Prompts ===
+# List available prompts from all servers
+prompts = client.list_prompts
+
+# Get a specific prompt with parameters
+result = client.get_prompt('greeting', { name: 'Ruby Developer' })
+
+# Get a prompt from a specific server
+result = client.get_prompt('greeting', { name: 'Ruby Developer' }, server: 'filesystem')
+
+# === Working with Resources ===
+# List available resources from all servers
+resources = client.list_resources
+
+# Read a specific resource by URI
+contents = client.read_resource('file:///example.txt')
+
+# Read a resource from a specific server
+contents = client.read_resource('file:///example.txt', server: 'filesystem')
+
 # Format tools for specific AI services
 openai_tools = client.to_openai_tools
 anthropic_tools = client.to_anthropic_tools
@@ -333,15 +367,21 @@ puts "Ping successful: #{ping_result.inspect}"
 mcp_client.cleanup
 ```
 
-See `examples/mcp_sse_server_example.rb` for the full Playwright SSE example.
+See `examples/streamable_http_example.rb` for the full Playwright SSE example.
 
 ### FastMCP Example
 
-The repository includes a complete FastMCP server example that demonstrates the Ruby MCP client working with a Python FastMCP server:
+The repository includes complete FastMCP server examples that demonstrate the Ruby MCP client working with Python FastMCP servers, including full MCP protocol support with tools, prompts, and resources:
+
+#### Basic FastMCP Example
+
+**For FastMCP server with SSE transport (includes tools, prompts, and resources):**
+```bash
+# From the ruby-mcp-client directory
+python examples/echo_server.py
+```
 
 ```ruby
-# Start the FastMCP server
-# python examples/echo_server.py
 
 # Run the Ruby client
 # bundle exec ruby examples/echo_server_client.rb
@@ -352,17 +392,72 @@ require 'mcp_client'
 client = MCPClient.create_client(
   mcp_server_configs: [
     MCPClient.sse_config(
-      base_url: 'http://127.0.0.1:8000/sse/',
+      base_url: 'http://127.0.0.1:8000/sse',
       read_timeout: 30
     )
   ]
 )
 
-# List available tools
+# List and use tools
 tools = client.list_tools
 puts "Found #{tools.length} tools:"
 tools.each { |tool| puts "- #{tool.name}: #{tool.description}" }
 
+result = client.call_tool('echo', { message: 'Hello FastMCP!' })
+
+# List and use prompts
+prompts = client.list_prompts
+puts "Found #{prompts.length} prompts:"
+prompts.each { |prompt| puts "- #{prompt.name}: #{prompt.description}" }
+
+greeting = client.get_prompt('greeting', { name: 'Ruby Developer' })
+
+# List and read resources
+resources = client.list_resources
+puts "Found #{resources.length} resources:"
+resources.each { |resource| puts "- #{resource.name} (#{resource.uri})" }
+
+readme_content = client.read_resource('file:///sample/README.md')
+```
+
+#### Streamable HTTP Example
+
+**For FastMCP server with Streamable HTTP transport (includes tools, prompts, and resources):**
+```bash
+# From the ruby-mcp-client directory
+python examples/echo_server_streamable.py
+```
+
+```ruby
+
+# Run the streamable HTTP client
+# bundle exec ruby examples/echo_server_streamable_client.rb
+
+require 'mcp_client'
+
+# Connect to streamable HTTP server with full MCP protocol support
+client = MCPClient.create_client(
+  mcp_server_configs: [
+    MCPClient.streamable_http_config(
+      base_url: 'http://localhost:8931/mcp',
+      read_timeout: 60
+    )
+  ]
+)
+
+# Full protocol support including real-time notifications
+client.on_notification do |method, params|
+  puts "Server notification: #{method} - #{params}"
+end
+
+# Use all MCP features: tools, prompts, resources
+tools = client.list_tools
+prompts = client.list_prompts
+resources = client.list_resources
+
+# Real-time progress notifications for long-running tasks
+result = client.call_tool('long_task', { duration: 5, steps: 5 })
+
 # Use the tools
 result = client.call_tool('echo', { message: 'Hello from Ruby!' })
 result = client.call_tool('reverse', { text: 'FastMCP rocks!' })
@@ -371,8 +466,10 @@ client.cleanup
 ```
 
 The FastMCP example includes:
-- **`echo_server.py`** - A Python FastMCP server with 4 interactive tools
-- **`echo_server_client.rb`** - Ruby client demonstrating all features
+- **`echo_server.py`** - A Python FastMCP server with tools, prompts, and resources
+- **`echo_server_client.rb`** - Ruby client demonstrating all features including prompts and resources
+- **`echo_server_streamable.py`** - Enhanced streamable HTTP server with tools, prompts, and resources
+- **`echo_server_streamable_client.rb`** - Ruby client demonstrating streamable HTTP transport
 - **`README_ECHO_SERVER.md`** - Complete setup and usage instructions
 
 This example showcases redirect support, proper line ending handling, and seamless integration between Ruby and Python MCP implementations.
@@ -464,8 +561,9 @@ Complete examples can be found in the `examples/` directory:
 - `openai_ruby_mcp.rb` - Integration with official openai/openai-ruby gem
 - `ruby_anthropic_mcp.rb` - Integration with alexrudall/ruby-anthropic gem
 - `gemini_ai_mcp.rb` - Integration with Google Vertex AI and Gemini models
-- `mcp_sse_server_example.rb` - SSE transport with Playwright MCP
+- `streamable_http_example.rb` - Streamable HTTP transport with Playwright MCP
 - `echo_server.py` & `echo_server_client.rb` - FastMCP server example with full setup
+- `echo_server_streamable.py` & `echo_server_streamable_client.rb` - Enhanced streamable HTTP server example
 
 ## MCP Server Compatibility
 
@@ -679,6 +777,8 @@ For complete OAuth documentation, see [OAUTH.md](OAUTH.md).
 - **Server disambiguation** - Specify which server to use when tools with same name exist in multiple servers
 - **Atomic tool calls** - Simple API for invoking tools with parameters
 - **Batch support** - Call multiple tools in a single operation
+- **Prompts support** - List and get prompts with parameters from MCP servers
+- **Resources support** - List and read resources by URI from MCP servers
 - **API conversions** - Built-in format conversion for OpenAI, Anthropic, and Google Vertex AI APIs
 - **Thread safety** - Synchronized access for thread-safe operation
 - **Server notifications** - Support for JSON-RPC notifications

data/lib/mcp_client/client.rb

@@ -9,10 +9,14 @@ module MCPClient
     # @!attribute [r] servers
     #   @return [Array<MCPClient::ServerBase>] list of servers
     # @!attribute [r] tool_cache
-    #   @return [Hash<String, MCPClient::Tool>] cache of tools by name
+    #   @return [Hash<String, MCPClient::Tool>] cache of tools by composite key (server_id:name)
+    # @!attribute [r] prompt_cache
+    #   @return [Hash<String, MCPClient::Prompt>] cache of prompts by composite key (server_id:name)
+    # @!attribute [r] resource_cache
+    #   @return [Hash<String, MCPClient::Resource>] cache of resources by composite key (server_id:uri)
     # @!attribute [r] logger
     #   @return [Logger] logger for client operations
-    attr_reader :servers, :tool_cache, :logger
+    attr_reader :servers, :tool_cache, :prompt_cache, :resource_cache, :logger
 
     # Initialize a new MCPClient::Client
     # @param mcp_server_configs [Array<Hash>] configurations for MCP servers
@@ -26,6 +30,8 @@ module MCPClient
         MCPClient::ServerFactory.create(config, logger: @logger)
       end
       @tool_cache = {}
+      @prompt_cache = {}
+      @resource_cache = {}
       # JSON-RPC notification listeners
       @notification_listeners = []
       # Register default and user-defined notification handlers on each server
@@ -39,6 +45,163 @@ module MCPClient
       end
     end
 
+    # Lists all available prompts from all connected MCP servers
+    # @param cache [Boolean] whether to use cached prompts or fetch fresh
+    # @return [Array<MCPClient::Prompt>] list of available prompts
+    # @raise [MCPClient::Errors::ConnectionError] on authorization failures
+    # @raise [MCPClient::Errors::PromptGetError] if no prompts could be retrieved from any server
+    def list_prompts(cache: true)
+      return @prompt_cache.values if cache && !@prompt_cache.empty?
+
+      prompts = []
+      connection_errors = []
+
+      servers.each do |server|
+        server.list_prompts.each do |prompt|
+          cache_key = cache_key_for(server, prompt.name)
+          @prompt_cache[cache_key] = prompt
+          prompts << prompt
+        end
+      rescue MCPClient::Errors::ConnectionError => e
+        # Fast-fail on authorization errors for better user experience
+        # If this is the first server or we haven't collected any prompts yet,
+        # raise the auth error directly to avoid cascading error messages
+        raise e if e.message.include?('Authorization failed') && prompts.empty?
+
+        # Store the error and try other servers
+        connection_errors << e
+        @logger.error("Server error: #{e.message}")
+      end
+
+      prompts
+    end
+
+    # Gets a specific prompt by name 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
+    # @param server [String, Symbol, Integer, MCPClient::ServerBase, nil] optional server to use
+    # @return [Object] the final prompt
+    def get_prompt(prompt_name, parameters, server: nil)
+      prompts = list_prompts
+
+      if server
+        # Use the specified server
+        srv = select_server(server)
+        # Find the prompt on this specific server
+        prompt = prompts.find { |t| t.name == prompt_name && t.server == srv }
+        unless prompt
+          raise MCPClient::Errors::PromptNotFound,
+                "Prompt '#{prompt_name}' not found on server '#{srv.name || srv.class.name}'"
+        end
+      else
+        # Find the prompt across all servers
+        matching_prompts = prompts.select { |t| t.name == prompt_name }
+
+        if matching_prompts.empty?
+          raise MCPClient::Errors::PromptNotFound, "Prompt '#{prompt_name}' not found"
+        elsif matching_prompts.size > 1
+          # If multiple matches, disambiguate with server names
+          server_names = matching_prompts.map { |t| t.server&.name || 'unnamed' }
+          raise MCPClient::Errors::AmbiguousPromptName,
+                "Multiple prompts named '#{prompt_name}' found across servers (#{server_names.join(', ')}). " \
+                "Please specify a server using the 'server' parameter."
+        end
+
+        prompt = matching_prompts.first
+      end
+
+      # Use the prompt's associated server
+      server = prompt.server
+      raise MCPClient::Errors::ServerNotFound, "No server found for prompt '#{prompt_name}'" unless server
+
+      begin
+        server.get_prompt(prompt_name, parameters)
+      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::PromptGetError,
+              "Error getting prompt '#{prompt_name}': #{e.message} (Server: #{server_id})"
+      end
+    end
+
+    # 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
+    # @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?
+
+      resources = []
+      connection_errors = []
+
+      servers.each do |server|
+        server.list_resources.each do |resource|
+          cache_key = cache_key_for(server, resource.uri)
+          @resource_cache[cache_key] = resource
+          resources << resource
+        end
+      rescue MCPClient::Errors::ConnectionError => e
+        # Fast-fail on authorization errors for better user experience
+        # If this is the first server or we haven't collected any resources yet,
+        # raise the auth error directly to avoid cascading error messages
+        raise e if e.message.include?('Authorization failed') && resources.empty?
+
+        # Store the error and try other servers
+        connection_errors << e
+        @logger.error("Server error: #{e.message}")
+      end
+
+      resources
+    end
+
+    # Reads a specific resource by URI
+    # @param uri [String] the URI of the resource to read
+    # @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
+
+      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
+
+      # 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
+    end
+
     # Lists all available tools from all connected MCP servers
     # @param cache [Boolean] whether to use cached tools or fetch fresh
     # @return [Array<MCPClient::Tool>] list of available tools
@@ -52,7 +215,8 @@ module MCPClient
 
       servers.each do |server|
         server.list_tools.each do |tool|
-          @tool_cache[tool.name] = tool
+          cache_key = cache_key_for(server, tool.name)
+          @tool_cache[cache_key] = tool
           tools << tool
         end
       rescue MCPClient::Errors::ConnectionError => e
@@ -162,6 +326,8 @@ module MCPClient
     # @return [void]
     def clear_cache
       @tool_cache.clear
+      @prompt_cache.clear
+      @resource_cache.clear
     end
 
     # Register a callback for JSON-RPC notifications from servers
@@ -316,9 +482,11 @@ module MCPClient
       when 'notifications/resources/updated'
         logger.warn("[#{server_id}] Resource #{params['uri']} updated")
       when 'notifications/prompts/list_changed'
-        logger.warn("[#{server_id}] Prompt list has changed")
+        logger.warn("[#{server_id}] Prompt list has changed, clearing prompt cache")
+        @prompt_cache.clear
       when 'notifications/resources/list_changed'
-        logger.warn("[#{server_id}] Resource list has changed")
+        logger.warn("[#{server_id}] Resource list has changed, clearing resource cache")
+        @resource_cache.clear
       else
         # Log unknown notification types for debugging purposes
         logger.debug("[#{server_id}] Received unknown notification: #{method} - #{params}")
@@ -379,5 +547,14 @@ module MCPClient
         server.list_tools.any? { |t| t.name == tool.name }
       end
     end
+
+    # Generate a cache key for server-specific items
+    # @param server [MCPClient::ServerBase] the server
+    # @param item_id [String] the item identifier (name or URI)
+    # @return [String] composite cache key
+    def cache_key_for(server, item_id)
+      server_id = server.object_id.to_s
+      "#{server_id}:#{item_id}"
+    end
   end
 end

data/lib/mcp_client/errors.rb

@@ -9,12 +9,24 @@ module MCPClient
     # Raised when a tool is not found
     class ToolNotFound < MCPError; end
 
+    # Raised when a prompt is not found
+    class PromptNotFound < MCPError; end
+
+    # Raised when a resource is not found
+    class ResourceNotFound < MCPError; end
+
     # Raised when a server is not found
     class ServerNotFound < MCPError; end
 
     # Raised when there's an error calling a tool
     class ToolCallError < MCPError; end
 
+    # Raised when there's an error getting a prompt
+    class PromptGetError < MCPError; end
+
+    # Raised when there's an error reading a resource
+    class ResourceReadError < MCPError; end
+
     # Raised when there's a connection error with an MCP server
     class ConnectionError < MCPError; end
 
@@ -29,5 +41,11 @@ module MCPClient
 
     # Raised when multiple tools with the same name exist across different servers
     class AmbiguousToolName < MCPError; end
+
+    # Raised when multiple prompts with the same name exist across different servers
+    class AmbiguousPromptName < MCPError; end
+
+    # Raised when multiple resources with the same URI exist across different servers
+    class AmbiguousResourceURI < MCPError; end
   end
 end

data/lib/mcp_client/prompt.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Representation of an MCP prompt
+  class Prompt
+    # @!attribute [r] name
+    #   @return [String] the name of the prompt
+    # @!attribute [r] description
+    #   @return [String] the description of the prompt
+    # @!attribute [r] arguments
+    #   @return [Hash] the JSON arguments for the prompt
+    # @!attribute [r] server
+    #   @return [MCPClient::ServerBase, nil] the server this prompt belongs to
+    attr_reader :name, :description, :arguments, :server
+
+    # Initialize a new prompt
+    # @param name [String] the name of the prompt
+    # @param description [String] the description of the prompt
+    # @param arguments [Hash] the JSON arguments for the prompt
+    # @param server [MCPClient::ServerBase, nil] the server this prompt belongs to
+    def initialize(name:, description:, arguments: {}, server: nil)
+      @name = name
+      @description = description
+      @arguments = arguments
+      @server = server
+    end
+
+    # Create a Prompt instance from JSON data
+    # @param data [Hash] JSON data from MCP server
+    # @param server [MCPClient::ServerBase, nil] the server this prompt belongs to
+    # @return [MCPClient::Prompt] prompt instance
+    def self.from_json(data, server: nil)
+      new(
+        name: data['name'],
+        description: data['description'],
+        arguments: data['arguments'] || {},
+        server: server
+      )
+    end
+  end
+end

data/lib/mcp_client/resource.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module MCPClient
+  # Representation of an MCP resource
+  class Resource
+    # @!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 of the resource for display purposes
+    # @!attribute [r] description
+    #   @return [String, nil] optional description
+    # @!attribute [r] mime_type
+    #   @return [String, nil] optional MIME type
+    # @!attribute [r] size
+    #   @return [Integer, nil] optional size in bytes
+    # @!attribute [r] annotations
+    #   @return [Hash, nil] optional annotations that provide hints to clients
+    # @!attribute [r] server
+    #   @return [MCPClient::ServerBase, nil] the server this resource belongs to
+    attr_reader :uri, :name, :title, :description, :mime_type, :size, :annotations, :server
+
+    # Initialize a new resource
+    # @param uri [String] unique identifier for the resource
+    # @param name [String] the name of the resource
+    # @param title [String, nil] optional human-readable name of the resource for display purposes
+    # @param description [String, nil] optional description
+    # @param mime_type [String, nil] optional MIME type
+    # @param size [Integer, nil] optional size in bytes
+    # @param annotations [Hash, nil] optional annotations that provide hints to clients
+    # @param server [MCPClient::ServerBase, nil] the server this resource belongs to
+    def initialize(uri:, name:, title: nil, description: nil, mime_type: nil, size: nil, annotations: nil, server: nil)
+      @uri = uri
+      @name = name
+      @title = title
+      @description = description
+      @mime_type = mime_type
+      @size = size
+      @annotations = annotations
+      @server = server
+    end
+
+    # Create a Resource instance from JSON data
+    # @param data [Hash] JSON data from MCP server
+    # @param server [MCPClient::ServerBase, nil] the server this resource belongs to
+    # @return [MCPClient::Resource] resource instance
+    def self.from_json(data, server: nil)
+      new(
+        uri: data['uri'],
+        name: data['name'],
+        title: data['title'],
+        description: data['description'],
+        mime_type: data['mimeType'],
+        size: data['size'],
+        annotations: data['annotations'],
+        server: server
+      )
+    end
+  end
+end

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.rb

@@ -99,6 +99,10 @@ module MCPClient
       @read_timeout = opts[:read_timeout]
       @tools = nil
       @tools_data = nil
+      @prompts = nil
+      @prompts_data = nil
+      @resources = nil
+      @resources_data = nil
       @request_id = 0
       @mutex = Monitor.new
       @connection_established = false
@@ -211,6 +215,93 @@ module MCPClient
       end
     end
 
+    # List all prompts available from the MCP server
+    # @return [Array<MCPClient::Prompt>] list of available prompts
+    # @raise [MCPClient::Errors::PromptGetError] if prompts list retrieval fails
+    def list_prompts
+      @mutex.synchronize do
+        return @prompts if @prompts
+      end
+
+      begin
+        ensure_connected
+
+        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 (with string keys for backward compatibility)
+    # @raise [MCPClient::Errors::PromptGetError] if prompt retrieval fails
+    def get_prompt(prompt_name, parameters)
+      rpc_request('prompts/get', {
+                    name: prompt_name,
+                    arguments: parameters.except(:_meta),
+                    **parameters.slice(:_meta)
+                  })
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
+      # Re-raise connection/transport errors directly
+      raise
+    rescue StandardError => e
+      # For all other errors, wrap in PromptGetError
+      raise MCPClient::Errors::PromptGetError, "Error getting 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::ResourceReadError] if resources list retrieval fails
+    def list_resources
+      @mutex.synchronize do
+        return @resources if @resources
+      end
+
+      begin
+        ensure_connected
+
+        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::ResourceReadError] if resource reading fails
+    def read_resource(uri)
+      rpc_request('resources/read', { uri: uri })
+    rescue MCPClient::Errors::ConnectionError, MCPClient::Errors::TransportError
+      # Re-raise connection/transport errors directly
+      raise
+    rescue StandardError => e
+      # For all other errors, wrap in ResourceReadError
+      raise MCPClient::Errors::ResourceReadError, "Error reading resource '#{uri}': #{e.message}"
+    end
+
     # Override apply_request_headers to add session and SSE headers for MCP protocol
     def apply_request_headers(req, request)
       super
@@ -294,6 +385,10 @@ module MCPClient
         # Clear cached data
         @tools = nil
         @tools_data = nil
+        @prompts = nil
+        @prompts_data = nil
+        @resources = nil
+        @resources_data = nil
         @buffer = ''
 
         @logger.info('Cleanup completed')
@@ -381,6 +476,56 @@ module MCPClient
       raise MCPClient::Errors::ToolCallError, 'Failed to get tools list from JSON-RPC request'
     end
 
+    # Request the prompts list using JSON-RPC
+    # @return [Array<Hash>] the prompts data
+    # @raise [MCPClient::Errors::PromptGetError] if prompts list retrieval fails
+    def request_prompts_list
+      @mutex.synchronize do
+        return @prompts_data if @prompts_data
+      end
+
+      result = rpc_request('prompts/list')
+
+      if result.is_a?(Hash) && result['prompts']
+        @mutex.synchronize do
+          @prompts_data = result['prompts']
+        end
+        return @mutex.synchronize { @prompts_data.dup }
+      elsif result.is_a?(Array) || 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
+    def request_resources_list
+      @mutex.synchronize do
+        return @resources_data if @resources_data
+      end
+
+      result = rpc_request('resources/list')
+
+      if result.is_a?(Hash) && result['resources']
+        @mutex.synchronize do
+          @resources_data = result['resources']
+        end
+        return @mutex.synchronize { @resources_data.dup }
+      elsif result.is_a?(Array) || 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
+
     # Start the long-lived GET connection for server events
     # Creates a separate thread to maintain SSE connection for server notifications
     # @return [void]

data/lib/mcp_client/version.rb

@@ -2,7 +2,7 @@
 
 module MCPClient
   # Current version of the MCP client gem
-  VERSION = '0.7.3'
+  VERSION = '0.8.0'
 
   # MCP protocol version (date-based) - unified across all transports
   PROTOCOL_VERSION = '2025-03-26'

data/lib/mcp_client.rb

@@ -3,6 +3,8 @@
 # Load all MCPClient components
 require_relative 'mcp_client/errors'
 require_relative 'mcp_client/tool'
+require_relative 'mcp_client/prompt'
+require_relative 'mcp_client/resource'
 require_relative 'mcp_client/server_base'
 require_relative 'mcp_client/server_stdio'
 require_relative 'mcp_client/server_sse'

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: ruby-mcp-client
 version: !ruby/object:Gem::Version
-  version: 0.7.3
+  version: 0.8.0
 platform: ruby
 authors:
 - Szymon Kurcab
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2025-09-01 00:00:00.000000000 Z
+date: 2025-09-16 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -127,6 +127,8 @@ files:
 - lib/mcp_client/http_transport_base.rb
 - lib/mcp_client/json_rpc_common.rb
 - lib/mcp_client/oauth_client.rb
+- lib/mcp_client/prompt.rb
+- lib/mcp_client/resource.rb
 - lib/mcp_client/server_base.rb
 - lib/mcp_client/server_factory.rb
 - lib/mcp_client/server_http.rb