ruby_llm-mcp 0.4.1 → 0.5.1

data/lib/ruby_llm/mcp/prompt.rb

@@ -11,6 +11,14 @@ module RubyLLM
           @description = description
           @required = required
         end
+
+        def to_h
+          {
+            name: @name,
+            description: @description,
+            required: @required
+          }
+        end
       end
 
       attr_reader :name, :description, :arguments, :coordinator
@@ -58,6 +66,16 @@ module RubyLLM
         end
       end
 
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          arguments: @arguments.map(&:to_h)
+        }
+      end
+
+      alias to_json to_h
+
       private
 
       def fetch_prompt_messages(arguments)

data/lib/ruby_llm/mcp/railtie.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Railtie < Rails::Railtie
+      config.after_initialize do
+        if RubyLLM::MCP.config.launch_control == :automatic
+          RubyLLM::MCP.clients.map(&:start)
+          at_exit do
+            RubyLLM::MCP.clients.map(&:stop)
+          end
+        end
+      end
+
+      generators do
+        require_relative "../../generators/ruby_llm/mcp/install_generator"
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/initialization.rb

@@ -3,9 +3,13 @@
 module RubyLLM
   module MCP
     module Requests
-      class Initialization < RubyLLM::MCP::Requests::Base
+      class Initialization
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
         def call
-          coordinator.request(initialize_body)
+          @coordinator.request(initialize_body)
         end
 
         private
@@ -15,8 +19,8 @@ module RubyLLM
             jsonrpc: "2.0",
             method: "initialize",
             params: {
-              protocolVersion: coordinator.protocol_version,
-              capabilities: {},
+              protocolVersion: @coordinator.protocol_version,
+              capabilities: @coordinator.client_capabilities,
               clientInfo: {
                 name: "RubyLLM-MCP Client",
                 version: RubyLLM::MCP::VERSION

data/lib/ruby_llm/mcp/requests/ping.rb

@@ -3,9 +3,13 @@
 module RubyLLM
   module MCP
     module Requests
-      class Ping < Base
+      class Ping
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
         def call
-          coordinator.request(ping_body)
+          @coordinator.request(ping_body)
         end
 
         def ping_body

data/lib/ruby_llm/mcp/requests/prompt_list.rb

@@ -3,9 +3,17 @@
 module RubyLLM
   module MCP
     module Requests
-      class PromptList < Base
+      class PromptList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
         def call
-          coordinator.request(request_body)
+          body = merge_pagination(request_body)
+          @coordinator.request(body)
         end
 
         private

data/lib/ruby_llm/mcp/requests/resource_list.rb

@@ -3,11 +3,21 @@
 module RubyLLM
   module MCP
     module Requests
-      class ResourceList < Base
+      class ResourceList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
         def call
-          coordinator.request(resource_list_body)
+          body = merge_pagination(resource_list_body)
+          @coordinator.request(body)
         end
 
+        private
+
         def resource_list_body
           {
             jsonrpc: "2.0",

data/lib/ruby_llm/mcp/requests/resource_template_list.rb

@@ -3,11 +3,21 @@
 module RubyLLM
   module MCP
     module Requests
-      class ResourceTemplateList < Base
+      class ResourceTemplateList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
         def call
-          coordinator.request(resource_template_list_body)
+          body = merge_pagination(resource_template_list_body)
+          @coordinator.request(body)
         end
 
+        private
+
         def resource_template_list_body
           {
             jsonrpc: "2.0",

data/lib/ruby_llm/mcp/requests/shared/meta.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module RubyLLM
+  module MCP
+    module Requests
+      module Shared
+        module Meta
+          def merge_meta(body)
+            meta = {}
+            meta.merge!(progress_token) if @coordinator.client.tracking_progress?
+
+            body[:params] ||= {}
+            body[:params].merge!({ _meta: meta }) unless meta.empty?
+            body
+          end
+
+          private
+
+          def progress_token
+            { progressToken: generate_progress_token }
+          end
+
+          def generate_progress_token
+            SecureRandom.uuid
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/shared/pagination.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      module Shared
+        module Pagination
+          def merge_pagination(body)
+            body[:params] ||= {}
+            body[:params].merge!({ cursor: @cursor }) if @cursor
+            body
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/requests/tool_call.rb

@@ -4,7 +4,7 @@ module RubyLLM
   module MCP
     module Requests
       class ToolCall
-        include Meta
+        include Shared::Meta
 
         def initialize(coordinator, name:, parameters: {})
           @coordinator = coordinator

data/lib/ruby_llm/mcp/requests/tool_list.rb

@@ -3,9 +3,17 @@
 module RubyLLM
   module MCP
     module Requests
-      class ToolList < RubyLLM::MCP::Requests::Base
+      class ToolList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
         def call
-          coordinator.request(tool_list_body)
+          body = merge_pagination(tool_list_body)
+          @coordinator.request(body)
         end
 
         private

data/lib/ruby_llm/mcp/resource.rb

@@ -31,6 +31,10 @@ module RubyLLM
         @content = @content_response["text"] || @content_response["blob"]
       end
 
+      def content_loaded?
+        !@content.nil?
+      end
+
       def subscribe!
         if @coordinator.capabilities.resource_subscribe?
           @coordinator.resources_subscribe(uri: @uri)
@@ -67,6 +71,19 @@ module RubyLLM
         end
       end
 
+      def to_h
+        {
+          uri: @uri,
+          name: @name,
+          description: @description,
+          mime_type: @mime_type,
+          contented_loaded: content_loaded?,
+          content: @content
+        }
+      end
+
+      alias to_json to_h
+
       private
 
       def content_type

data/lib/ruby_llm/mcp/response_handler.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class ResponseHandler
+      attr_reader :coordinator, :client
+
+      def initialize(coordinator)
+        @coordinator = coordinator
+        @client = coordinator.client
+      end
+
+      def execute(result) # rubocop:disable Naming/PredicateMethod
+        if result.ping?
+          coordinator.ping_response(id: result.id)
+          true
+        elsif result.roots?
+          handle_roots_response(result)
+          true
+        elsif result.sampling?
+          handle_sampling_response(result)
+          true
+        else
+          handle_unknown_request(result)
+          RubyLLM::MCP.logger.error("MCP client was sent unknown method type and could not respond: #{result.inspect}")
+          false
+        end
+      end
+
+      private
+
+      def handle_roots_response(result)
+        if client.roots.active?
+          coordinator.roots_list_response(id: result.id, roots: client.roots)
+        else
+          coordinator.error_response(id: result.id, message: "Roots are not enabled", code: -32_000)
+        end
+      end
+
+      def handle_sampling_response(result)
+        unless MCP.config.sampling.enabled?
+          RubyLLM::MCP.logger.info("Sampling is disabled, yet server requested sampling")
+          coordinator.error_response(id: result.id, message: "Sampling is disabled", code: -32_000)
+          return
+        end
+
+        RubyLLM::MCP.logger.info("Sampling response: #{result.inspect}")
+        Sample.new(result, coordinator).execute
+      end
+
+      def handle_unknown_request(result)
+        coordinator.error_response(id: result.id,
+                                   message: "Unknown method and could not respond: #{result.method}",
+                                   code: -32_000)
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/responses/error.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Responses
+      class Error
+        def initialize(coordinator, id:, message:, code: -32_000)
+          @coordinator = coordinator
+          @id = id
+          @message = message
+          @code = code
+        end
+
+        def call
+          @coordinator.request(sampling_error_body, add_id: false, wait_for_response: false)
+        end
+
+        private
+
+        def sampling_error_body
+          {
+            jsonrpc: "2.0",
+            id: @id,
+            error: {
+              code: @code,
+              message: @message
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/{requests/ping_response.rb → responses/ping.rb}

@@ -2,8 +2,8 @@
 
 module RubyLLM
   module MCP
-    module Requests
-      class PingResponse
+    module Responses
+      class Ping
         def initialize(coordinator, id:)
           @coordinator = coordinator
           @id = id

data/lib/ruby_llm/mcp/responses/roots_list.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Responses
+      class RootsList
+        def initialize(coordinator, roots:, id:)
+          @coordinator = coordinator
+          @roots = roots
+          @id = id
+        end
+
+        def call
+          @coordinator.request(roots_list_body, add_id: false, wait_for_response: false)
+        end
+
+        private
+
+        def roots_list_body
+          {
+            jsonrpc: "2.0",
+            id: @id,
+            result: {
+              roots: @roots.to_request
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/responses/sampling_create_message.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Responses
+      class SamplingCreateMessage
+        def initialize(coordinator, id:, message:, model:)
+          @coordinator = coordinator
+          @id = id
+          @message = message
+          @model = model
+        end
+
+        def call
+          @coordinator.request(sampling_create_message_body, add_id: false, wait_for_response: false)
+        end
+
+        private
+
+        def sampling_create_message_body
+          {
+            jsonrpc: "2.0",
+            id: @id,
+            result: {
+              role: @message.role,
+              content: format_content(@message.content),
+              model: @model,
+              # TODO: We are going to assume it was a endTurn
+              # Look into getting RubyLLM to expose stopReason in message response
+              stopReason: "endTurn"
+            }
+          }
+        end
+
+        def format_content(content)
+          if content.is_a?(RubyLLM::Content)
+            if context.text.none? && content.attachments.any?
+              attachment = content.attachments.first
+              { type: attachment.type, data: attachment.content, mime_type: attachment.mime_type }
+            else
+              { type: "text", text: content.text }
+            end
+          else
+            { type: "text", text: content }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/result.rb

@@ -12,7 +12,13 @@ module RubyLLM
     end
 
     class Result
-      attr_reader :result, :error, :params, :id, :response, :session_id
+      attr_reader :response, :session_id, :id, :method, :result, :params, :error, :next_cursor
+
+      REQUEST_METHODS = {
+        ping: "ping",
+        roots: "roots/list",
+        sampling: "sampling/createMessage"
+      }.freeze
 
       def initialize(response, session_id: nil)
         @response = response
@@ -24,6 +30,13 @@ module RubyLLM
         @error = response["error"] || {}
 
         @result_is_error = response.dig("result", "isError") || false
+        @next_cursor = response.dig("result", "nextCursor")
+      end
+
+      REQUEST_METHODS.each do |method_name, method_value|
+        define_method "#{method_name}?" do
+          @method == method_value
+        end
       end
 
       alias value result
@@ -47,23 +60,23 @@ module RubyLLM
       end
 
       def matching_id?(request_id)
-        @id&.to_s == request_id
-      end
-
-      def ping?
-        @method == "ping"
+        @id&.to_s == request_id.to_s
       end
 
       def notification?
         @method&.include?("notifications") || false
       end
 
+      def next_cursor?
+        !@next_cursor.nil?
+      end
+
       def request?
-        @method && !notification? && @result.none? && @error.none?
+        !@method.nil? && !notification? && @result.none? && @error.none?
       end
 
       def response?
-        @id && (@result || @error.any?) && !@method
+        !@id.nil? && (@result || @error.any?) && !@method
       end
 
       def success?

data/lib/ruby_llm/mcp/roots.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Roots
+      attr_reader :paths
+
+      def initialize(paths: [], coordinator: nil)
+        @paths = paths
+        @coordinator = coordinator
+      end
+
+      def active?
+        @paths.any?
+      end
+
+      def add(path)
+        @paths << path
+        @coordinator.roots_list_change_notification
+      end
+
+      def remove(path)
+        @paths.delete(path)
+        @coordinator.roots_list_change_notification
+      end
+
+      def to_request
+        @paths.map do |path|
+          name = File.basename(path, ".*")
+
+          {
+            uri: "file://#{path}",
+            name: name
+          }
+        end
+      end
+
+      def to_h
+        {
+          paths: to_request
+        }
+      end
+    end
+  end
+end