ruby_llm_swarm-mcp 0.8.0 → 0.8.1

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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class Initialization
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def call
+          @coordinator.request(initialize_body)
+        end
+
+        private
+
+        def initialize_body
+          {
+            jsonrpc: "2.0",
+            method: "initialize",
+            params: {
+              protocolVersion: @coordinator.protocol_version,
+              capabilities: @coordinator.client_capabilities,
+              clientInfo: {
+                name: "RubyLLM-MCP Client",
+                version: RubyLLM::MCP::VERSION
+              }
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class LoggingSetLevel
+        def initialize(coordinator, level:)
+          @coordinator = coordinator
+          @level = level
+        end
+
+        def call
+          @coordinator.request(logging_set_body)
+        end
+
+        def logging_set_body
+          {
+            jsonrpc: "2.0",
+            method: "logging/setLevel",
+            params: {
+              level: @level
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class Ping
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def call
+          @coordinator.request(ping_body)
+        end
+
+        def ping_body
+          {
+            jsonrpc: "2.0",
+            method: "ping"
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class PromptCall
+        def initialize(coordinator, name:, arguments: {})
+          @coordinator = coordinator
+          @name = name
+          @arguments = arguments
+        end
+
+        def call
+          @coordinator.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            method: "prompts/get",
+            params: {
+              name: @name,
+              arguments: @arguments
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class PromptList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
+        def call
+          body = merge_pagination(request_body)
+          @coordinator.request(body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            method: "prompts/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
+        def call
+          body = merge_pagination(resource_list_body)
+          @coordinator.request(body)
+        end
+
+        private
+
+        def resource_list_body
+          {
+            jsonrpc: "2.0",
+            method: "resources/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceRead
+        attr_reader :coordinator, :uri
+
+        def initialize(coordinator, uri:)
+          @coordinator = coordinator
+          @uri = uri
+        end
+
+        def call
+          coordinator.request(reading_resource_body(uri))
+        end
+
+        def reading_resource_body(uri)
+          {
+            jsonrpc: "2.0",
+            method: "resources/read",
+            params: {
+              uri: uri
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourceTemplateList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
+        def call
+          body = merge_pagination(resource_template_list_body)
+          @coordinator.request(body)
+        end
+
+        private
+
+        def resource_template_list_body
+          {
+            jsonrpc: "2.0",
+            method: "resources/templates/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ResourcesSubscribe
+        def initialize(coordinator, uri:)
+          @coordinator = coordinator
+          @uri = uri
+        end
+
+        def call
+          @coordinator.request(resources_subscribe_body, wait_for_response: false)
+        end
+
+        private
+
+        def resources_subscribe_body
+          {
+            jsonrpc: "2.0",
+            method: "resources/subscribe",
+            params: {
+              uri: @uri
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ToolCall
+        include Shared::Meta
+
+        def initialize(coordinator, name:, parameters: {})
+          @coordinator = coordinator
+          @name = name
+          @parameters = parameters
+        end
+
+        def call
+          body = merge_meta(request_body)
+          @coordinator.request(body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            method: "tools/call",
+            params: {
+              name: @name,
+              arguments: @parameters
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class ToolList
+        include Shared::Pagination
+
+        def initialize(coordinator, cursor: nil)
+          @coordinator = coordinator
+          @cursor = cursor
+        end
+
+        def call
+          body = merge_pagination(tool_list_body)
+          @coordinator.request(body)
+        end
+
+        private
+
+        def tool_list_body
+          {
+            jsonrpc: "2.0",
+            method: "tools/list",
+            params: {}
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/resource.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
+require "httpx"
+
 module RubyLLM
   module MCP
     class Resource
-      attr_reader :uri, :name, :description, :mime_type, :adapter, :subscribed
+      attr_reader :uri, :name, :description, :mime_type, :coordinator, :subscribed
 
-      def initialize(adapter, resource)
-        @adapter = adapter
+      def initialize(coordinator, resource)
+        @coordinator = coordinator
         @uri = resource["uri"]
         @name = resource["name"]
         @description = resource["description"]
@@ -34,8 +36,8 @@ module RubyLLM
       end
 
       def subscribe!
-        if @adapter.capabilities.resource_subscribe?
-          @adapter.resources_subscribe(uri: @uri)
+        if @coordinator.capabilities.resource_subscribe?
+          @coordinator.resources_subscribe(uri: @uri)
           @subscribed = true
         else
           message = "Resource subscribe is not available for this MCP server"
@@ -99,7 +101,7 @@ module RubyLLM
         when "http", "https"
           fetch_uri_content(uri)
         else # file:// or git://
-          @adapter.resource_read(uri: uri)
+          @coordinator.resource_read(uri: uri)
         end
       end
 

data/lib/ruby_llm/mcp/resource_template.rb

@@ -5,10 +5,10 @@ require "httpx"
 module RubyLLM
   module MCP
     class ResourceTemplate
-      attr_reader :uri, :name, :description, :mime_type, :adapter, :template
+      attr_reader :uri, :name, :description, :mime_type, :coordinator, :template
 
-      def initialize(adapter, resource)
-        @adapter = adapter
+      def initialize(coordinator, resource)
+        @coordinator = coordinator
         @uri = resource["uriTemplate"]
         @name = resource["name"]
         @description = resource["description"]
@@ -20,7 +20,7 @@ module RubyLLM
         result = read_response(uri)
         content_response = result.value.dig("contents", 0)
 
-        Resource.new(adapter, {
+        Resource.new(coordinator, {
                        "uri" => uri,
                        "name" => "#{@name} (#{uri})",
                        "description" => @description,
@@ -34,8 +34,8 @@ module RubyLLM
       end
 
       def complete(argument, value, context: nil)
-        if @adapter.capabilities.completion?
-          result = @adapter.completion_resource(uri: @uri, argument: argument, value: value, context: context)
+        if @coordinator.capabilities.completion?
+          result = @coordinator.completion_resource(uri: @uri, argument: argument, value: value, context: context)
           result.raise_error! if result.error?
 
           response = result.value["completion"]
@@ -64,7 +64,7 @@ module RubyLLM
         when "http", "https"
           fetch_uri_content(uri)
         else # file:// or git://
-          @adapter.resource_read(uri: uri)
+          @coordinator.resource_read(uri: uri)
         end
       end
 

data/lib/ruby_llm/mcp/response_handler.rb

@@ -0,0 +1,67 @@
+# 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
+        elsif result.elicitation?
+          handle_elicitation_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)
+        RubyLLM::MCP.logger.info("Roots request: #{result.inspect}")
+        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 request: #{result.inspect}")
+        Sample.new(result, coordinator).execute
+      end
+
+      def handle_elicitation_response(result)
+        RubyLLM::MCP.logger.info("Elicitation request: #{result.inspect}")
+        Elicitation.new(coordinator, result).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/elicitation.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Responses
+      class Elicitation
+        def initialize(coordinator, id:, action:, content:)
+          @coordinator = coordinator
+          @id = id
+          @action = action
+          @content = content
+        end
+
+        def call
+          @coordinator.request(elicitation_response_body, add_id: false, wait_for_response: false)
+        end
+
+        private
+
+        def elicitation_response_body
+          {
+            jsonrpc: "2.0",
+            id: @id,
+            result: {
+              action: @action,
+              content: @content
+            }.compact
+          }
+        end
+      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/responses/ping.rb

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

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