Phase 4: Implement Complete Primitives - Resources, Prompts, Roots, and Sampling

Author: nagstler

lib/ruby_mcp/client.rb

@@ -3,6 +3,8 @@
 require_relative 'client/client'
 require_relative 'client/retry'
 require_relative 'client/streaming'
+require_relative 'client/sampling'
+require_relative 'client/roots'
 
 module MCP
   # Creates a new client instance with optional block configuration
@@ -15,6 +17,8 @@ def self.Client(options = {})
     # Add additional capabilities
     client.extend(Client::Retry)
     client.extend(Client::Streaming)
+    client.extend(Client::Sampling)
+    client.extend(Client::Roots)
 
     yield client if block_given?
     client
@@ -29,6 +33,10 @@ class Client
     def initialize(options = {})
       @client = MCP.Client(options)
 
+      # Set up roots and sampling handlers if provided
+      @client.set_roots(options[:roots]) if options[:roots]
+      @client.set_sampling_handler(options[:sampling_handler]) if options[:sampling_handler]
+      
       yield self if block_given?
 
       self
@@ -54,7 +62,7 @@ def connected?
       @client.connected?
     end
 
-    # Get the list of available tools
+    # List available tools on the server
     # @return [Array<Hash>] The list of available tools
     def list_tools
       @client.list_tools
@@ -87,6 +95,74 @@ def with_retry(options = {}, retriable_errors = [StandardError], retry_condition
       @client.with_retry(options, retriable_errors, retry_condition, &block)
     end
 
+    # List available resources on the server
+    # @return [Array<Hash>] The list of available resources
+    def list_resources
+      @client.list_resources
+    end
+    
+    # List available resource templates on the server
+    # @return [Array<Hash>] The list of available resource templates
+    def list_resource_templates
+      @client.list_resource_templates
+    end
+    
+    # Read a resource from the server
+    # @param uri [String] The URI of the resource to read
+    # @param params [Hash] Optional parameters for template resources
+    # @return [Array<Hash>] The resource content
+    def read_resource(uri, params = nil)
+      @client.read_resource(uri, params)
+    end
+    
+    # List available prompts on the server
+    # @return [Array<Hash>] The list of available prompts
+    def list_prompts
+      @client.list_prompts
+    end
+    
+    # Get a prompt from the server
+    # @param name [String] The name of the prompt to get
+    # @param arguments [Hash] Optional arguments for the prompt
+    # @return [Array<Hash>] The prompt messages
+    def get_prompt(name, arguments = {})
+      @client.get_prompt(name, arguments)
+    end
+    
+    # List available roots on the server
+    # @return [Array<Hash>] The list of available roots
+    def list_roots
+      @client.list_roots
+    end
+    
+    # Read a file from a root on the server
+    # @param root [String] The name of the root to read from
+    # @param path [String] The path to read
+    # @return [String] The file content
+    def read_root_file(root, path)
+      @client.read_root_file(root, path)
+    end
+    
+    # Allow models to call their host model for text generation
+    # @param prompt [String, Array<Hash>] The prompt to generate from
+    # @param options [Hash] Generation options
+    # @return [String] The generated text
+    def sample(prompt, options = {})
+      @client.sample(prompt, options)
+    end
+    
+    # Set the roots list handler
+    # @param roots [Array<Hash>] The roots to register
+    def set_roots(roots)
+      @client.set_roots(roots)
+    end
+    
+    # Set the sampling handler
+    # @param handler [Proc] The handler function
+    def set_sampling_handler(handler)
+      @client.set_sampling_handler(handler)
+    end
+    
     # Forward other methods to the client instance
     def method_missing(method, *args, &block)
       if @client.respond_to?(method)

lib/ruby_mcp/client/roots.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module MCP
+  module Client
+    # Client-side roots functionality
+    module Roots
+      # Register the roots list handler with the server
+      # @param roots [Array<Hash>] The roots to register
+      def set_roots(roots)
+        @roots = roots
+        
+        # Register event handlers
+        on_event(:roots_list_changed) do
+          handle_roots_list_changed
+        end
+        
+        # Send the roots list to the server if already connected
+        send_roots_list if connected?
+      end
+      
+      # Send the roots list to the server
+      def send_roots_list
+        ensure_connected
+        
+        # Convert to MCP format
+        roots_list = @roots.map do |root|
+          {
+            name: root[:name],
+            description: root[:description] || "",
+            allowWrites: root[:allow_writes] || false
+          }
+        end
+        
+        # Send the roots list notification
+        request = MCP::Protocol::JsonRPC.notification('roots/list', {
+          roots: roots_list
+        })
+        
+        @connection.send_notification(request)
+      end
+      
+      private
+      
+      # Handle roots/list_changed notification
+      def handle_roots_list_changed
+        # Send the updated roots list
+        send_roots_list
+      end
+    end
+  end
+end

lib/ruby_mcp/client/sampling.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module MCP
+  module Client
+    # Sampling functionality for client-side LLM generation
+    module Sampling
+      # Allows models to call their host model for text generation
+      # @param prompt [String, Array<Hash>] The prompt to generate from
+      # @param options [Hash] Generation options
+      # @return [String] The generated text
+      def sample(prompt, options = {})
+        if @sampling_handler
+          # Call the registered sampling handler
+          @sampling_handler.call(prompt, options)
+        else
+          raise MCP::Errors::ClientError, "No sampling handler registered"
+        end
+      end
+      
+      # Register a sampling handler
+      # @param handler [Proc] The handler function
+      def set_sampling_handler(handler)
+        @sampling_handler = handler
+      end
+      
+      # Add sampling capabilities to a client
+      # @param client [MCP::Client::Client] The client to add sampling to
+      def self.included(client)
+        unless client.included_modules.include?(self)
+          client.include(self)
+        end
+      end
+    end
+    
+    # Default sampling handler implementation
+    class SamplingHandler
+      attr_reader :model
+      
+      # Initialize a sampling handler
+      # @param model [String] The model to use for sampling
+      # @param options [Hash] Default options for the model
+      def initialize(model, options = {})
+        @model = model
+        @default_options = options
+      end
+      
+      # Generate text from a prompt
+      # @param prompt [String, Array<Hash>] The prompt to generate from
+      # @param options [Hash] Generation options
+      # @return [String] The generated text
+      def call(prompt, options = {})
+        # This is a placeholder for actual model integration
+        # In a real implementation, you'd call your model API here
+        raise NotImplementedError, "SamplingHandler#call must be implemented"
+      end
+    end
+  end
+end

lib/ruby_mcp/server.rb

@@ -2,6 +2,12 @@
 
 require_relative 'server/tools/tool'
 require_relative 'server/tools/manager'
+require_relative 'server/resources/resource'
+require_relative 'server/resources/manager'
+require_relative 'server/prompts/prompt'
+require_relative 'server/prompts/manager'
+require_relative 'server/roots/root'
+require_relative 'server/roots/manager'
 require_relative 'server/dsl'
 require_relative 'server/server'