ruby_llm-mcp 0.4.1 → 0.5.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

data/lib/ruby_llm/mcp/sample.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Sample
+      class Hint
+        attr_reader :model, :cost_priority, :speed_priority, :intelligence_priority
+
+        def initialize(model, model_preferences)
+          @model = model
+          @model_preferences = model_preferences
+
+          @hints = model_preferences&.fetch("hints", [])
+          @cost_priority = model_preferences&.fetch("costPriority", nil)
+          @speed_priority = model_preferences&.fetch("speedPriority", nil)
+          @intelligence_priority = model_preferences&.fetch("intelligencePriority", nil)
+        end
+
+        def hints
+          @hints.map { |hint| hint["name"] }
+        end
+
+        def to_h
+          {
+            model: model,
+            hints: hints,
+            cost_priority: @cost_priority,
+            speed_priority: @speed_priority,
+            intelligence_priority: @intelligence_priority
+          }
+        end
+      end
+
+      REJECTED_MESSAGE = "Sampling request was rejected"
+
+      attr_reader :model_preferences, :system_prompt, :max_tokens, :raw_messages
+
+      def initialize(result, coordinator)
+        params = result.params
+        @id = result.id
+        @coordinator = coordinator
+
+        @raw_messages = params["messages"] || []
+        @model_preferences = Hint.new(params["model"], params["modelPreferences"])
+        @system_prompt = params["systemPrompt"]
+        @max_tokens = params["maxTokens"]
+      end
+
+      def execute
+        return unless callback_guard_success?
+
+        model = preferred_model
+        return unless model
+
+        chat_message = chat(model)
+        @coordinator.sampling_create_message_response(
+          id: @id, message: chat_message, model: model
+        )
+      end
+
+      def message
+        @message ||= raw_messages.map { |message| message.fetch("content")&.fetch("text") }.join("\n")
+      end
+
+      def to_h
+        {
+          id: @id,
+          model_preferences: @model_preferences.to_h,
+          system_prompt: @system_prompt,
+          max_tokens: @max_tokens
+        }
+      end
+
+      alias to_json to_h
+
+      private
+
+      def callback_guard_success?
+        return true unless @coordinator.client.sampling_callback_enabled?
+
+        unless @coordinator.client.on[:sampling].call(self)
+          @coordinator.error_response(id: @id, message: REJECTED_MESSAGE)
+          return false
+        end
+
+        true
+      rescue StandardError => e
+        RubyLLM::MCP.logger.error("Error in callback guard: #{e.message}, #{e.backtrace.join("\n")}")
+        @coordinator.error_response(id: @id, message: "Error executing sampling request")
+        false
+      end
+
+      def chat(model)
+        chat = RubyLLM::Chat.new(
+          model: model
+        )
+        if system_prompt
+          formated_system_message = create_message(system_message)
+          chat.add_message(formated_system_message)
+        end
+        raw_messages.each { |message| chat.add_message(create_message(message)) }
+
+        chat.complete
+      end
+
+      def preferred_model
+        @preferred_model ||= begin
+          model = RubyLLM::MCP.config.sampling.preferred_model
+          if model.respond_to?(:call)
+            model.call(model_preferences)
+          else
+            model
+          end
+        end
+      rescue StandardError => e
+        RubyLLM::MCP.logger.error("Error in preferred model: #{e.message}, #{e.backtrace.join("\n")}")
+        @coordinator.error_response(id: @id, message: "Failed to determine preferred model: #{e.message}")
+        false
+      end
+
+      def create_message(message)
+        role = message["role"]
+        content = create_content_for_message(message["content"])
+
+        RubyLLM::Message.new({ role: role, content: content })
+      end
+
+      def create_content_for_message(content)
+        case content["type"]
+        when "text"
+          MCP::Content.new(text: content["text"])
+        when "image", "audio"
+          attachment = MCP::Attachment.new(content["data"], content["mimeType"])
+          MCP::Content.new(text: nil, attachments: [attachment])
+        else
+          raise RubyLLM::MCP::Errors::InvalidFormatError.new(message: "Invalid content type: #{content['type']}")
+        end
+      end
+
+      def system_message
+        {
+          "role" => "system",
+          "content" => { "type" => "text", "text" => system_prompt }
+        }
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/{capabilities.rb → server_capabilities.rb}

@@ -2,7 +2,7 @@
 
 module RubyLLM
   module MCP
-    class Capabilities
+    class ServerCapabilities
       attr_accessor :capabilities
 
       def initialize(capabilities = {})

data/lib/ruby_llm/mcp/tool.rb

@@ -12,16 +12,28 @@ module RubyLLM
         @idempotent_hint = annotation["idempotentHint"] || false
         @open_world_hint = annotation["openWorldHint"] || true
       end
+
+      def to_h
+        {
+          title: @title,
+          readOnlyHint: @read_only_hint,
+          destructiveHint: @destructive_hint,
+          idempotentHint: @idempotent_hint,
+          openWorldHint: @open_world_hint
+        }
+      end
     end
 
     class Tool < RubyLLM::Tool
-      attr_reader :name, :description, :parameters, :coordinator, :tool_response
+      attr_reader :name, :description, :parameters, :coordinator, :tool_response, :with_prefix
 
-      def initialize(coordinator, tool_response)
+      def initialize(coordinator, tool_response, with_prefix: false)
         super()
         @coordinator = coordinator
 
-        @name = tool_response["name"]
+        @with_prefix = with_prefix
+        @name = format_name(tool_response["name"])
+        @mcp_name = tool_response["name"]
         @description = tool_response["description"].to_s
         @parameters = create_parameters(tool_response["inputSchema"])
         @annotations = tool_response["annotations"] ? Annotation.new(tool_response["annotations"]) : nil
@@ -33,7 +45,7 @@ module RubyLLM
 
       def execute(**params)
         result = @coordinator.execute_tool(
-          name: @name,
+          name: @mcp_name,
           parameters: params
         )
 
@@ -54,6 +66,17 @@ module RubyLLM
         end
       end
 
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          parameters: @parameters.to_h,
+          annotations: @annotations&.to_h
+        }
+      end
+
+      alias to_json to_h
+
       private
 
       def create_parameters(input_schema)
@@ -136,6 +159,14 @@ module RubyLLM
           resource.to_content
         end
       end
+
+      def format_name(name)
+        if @with_prefix
+          "#{@coordinator.name}_#{name}"
+        else
+          name
+        end
+      end
     end
   end
 end