ruby_llm_swarm-mcp 0.8.0 → 0.8.1

data/lib/ruby_llm/mcp/coordinator.rb

@@ -0,0 +1,304 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module RubyLLM
+  module MCP
+    class Coordinator
+      attr_reader :client, :transport_type, :config, :capabilities, :protocol_version
+
+      def initialize(client, transport_type:, config: {})
+        @client = client
+        @transport_type = transport_type
+        @config = config
+
+        @protocol_version = MCP.config.protocol_version || MCP::Protocol.default_negotiated_version
+
+        @transport = nil
+        @capabilities = nil
+      end
+
+      def name
+        client.name
+      end
+
+      def request(body, **options)
+        transport.request(body, **options)
+      rescue RubyLLM::MCP::Errors::TimeoutError => e
+        if transport&.alive? && !e.request_id.nil?
+          cancelled_notification(reason: "Request timed out", request_id: e.request_id)
+        end
+        raise e
+      end
+
+      def process_result(result)
+        if result.notification?
+          process_notification(result)
+          return nil
+        end
+
+        if result.request?
+          process_request(result) if alive?
+          return nil
+        end
+
+        if result.response?
+          return result
+        end
+
+        nil
+      end
+
+      def start_transport
+        return unless capabilities.nil?
+
+        transport.start
+
+        initialize_response = initialize_request
+        initialize_response.raise_error! if initialize_response.error?
+
+        # Extract and store the negotiated protocol version
+        negotiated_version = initialize_response.value["protocolVersion"]
+
+        if negotiated_version && !MCP::Protocol.supported_version?(negotiated_version)
+          raise Errors::UnsupportedProtocolVersion.new(
+            message: <<~MESSAGE
+              Unsupported protocol version, and could not negotiate a supported version: #{negotiated_version}.
+              Supported versions: #{MCP::Protocol.supported_versions.join(', ')}
+            MESSAGE
+          )
+        end
+
+        @protocol_version = negotiated_version if negotiated_version
+
+        # Set the protocol version on the transport for subsequent requests
+        if @transport.respond_to?(:set_protocol_version)
+          @transport.set_protocol_version(@protocol_version)
+        end
+
+        @capabilities = RubyLLM::MCP::ServerCapabilities.new(initialize_response.value["capabilities"])
+        initialize_notification
+
+        if client.logging_handler_enabled?
+          set_logging(level: client.on_logging_level)
+        end
+      end
+
+      def stop_transport
+        @transport&.close
+        @capabilities = nil
+        @transport = nil
+        @protocol_version = MCP::Protocol.default_negotiated_version
+      end
+
+      def restart_transport
+        @initialize_response = nil
+        stop_transport
+        start_transport
+      end
+
+      def alive?
+        !!@transport&.alive?
+      end
+
+      def ping
+        ping_request = RubyLLM::MCP::Requests::Ping.new(self)
+        if alive?
+          result = ping_request.call
+        else
+          transport.start
+
+          result = ping_request.call
+          @transport = nil
+        end
+
+        result.value == {}
+      rescue RubyLLM::MCP::Errors::TimeoutError, RubyLLM::MCP::Errors::TransportError
+        false
+      end
+
+      def process_notification(result)
+        notification = result.notification
+        NotificationHandler.new(self).execute(notification)
+      end
+
+      def process_request(result)
+        ResponseHandler.new(self).execute(result)
+      end
+
+      def initialize_request
+        RubyLLM::MCP::Requests::Initialization.new(self).call
+      end
+
+      def tool_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::ToolList.new(self, cursor: cursor).call
+        result.raise_error! if result.error?
+
+        if result.next_cursor?
+          result.value["tools"] + tool_list(cursor: result.next_cursor)
+        else
+          result.value["tools"]
+        end
+      end
+
+      def execute_tool(**args)
+        if client.human_in_the_loop?
+          name = args[:name]
+          params = args[:parameters]
+          unless client.on[:human_in_the_loop].call(name, params)
+            result = Result.new(
+              {
+                "result" => {
+                  "isError" => true,
+                  "content" => [{ "type" => "text", "text" => "Tool call was cancelled by the client" }]
+                }
+              }
+            )
+            return result
+          end
+        end
+
+        RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
+      end
+
+      def register_resource(resource)
+        @client.linked_resources << resource
+        @client.resources[resource.name] = resource
+      end
+
+      def resource_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::ResourceList.new(self, cursor: cursor).call
+        result.raise_error! if result.error?
+
+        if result.next_cursor?
+          result.value["resources"] + resource_list(cursor: result.next_cursor)
+        else
+          result.value["resources"]
+        end
+      end
+
+      def resource_read(**args)
+        RubyLLM::MCP::Requests::ResourceRead.new(self, **args).call
+      end
+
+      def resource_template_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::ResourceTemplateList.new(self, cursor: cursor).call
+        result.raise_error! if result.error?
+
+        if result.next_cursor?
+          result.value["resourceTemplates"] + resource_template_list(cursor: result.next_cursor)
+        else
+          result.value["resourceTemplates"]
+        end
+      end
+
+      def resources_subscribe(**args)
+        RubyLLM::MCP::Requests::ResourcesSubscribe.new(self, **args).call
+      end
+
+      def prompt_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::PromptList.new(self, cursor: cursor).call
+        result.raise_error! if result.error?
+
+        if result.next_cursor?
+          result.value["prompts"] + prompt_list(cursor: result.next_cursor)
+        else
+          result.value["prompts"]
+        end
+      end
+
+      def execute_prompt(**args)
+        RubyLLM::MCP::Requests::PromptCall.new(self, **args).call
+      end
+
+      def completion_resource(**args)
+        RubyLLM::MCP::Requests::CompletionResource.new(self, **args).call
+      end
+
+      def completion_prompt(**args)
+        RubyLLM::MCP::Requests::CompletionPrompt.new(self, **args).call
+      end
+
+      def set_logging(**args)
+        RubyLLM::MCP::Requests::LoggingSetLevel.new(self, **args).call
+      end
+
+      ## Notifications
+      #
+      def initialize_notification
+        RubyLLM::MCP::Notifications::Initialize.new(self).call
+      end
+
+      def cancelled_notification(**args)
+        RubyLLM::MCP::Notifications::Cancelled.new(self, **args).call
+      end
+
+      def roots_list_change_notification
+        RubyLLM::MCP::Notifications::RootsListChange.new(self).call
+      end
+
+      ## Responses
+      #
+      def ping_response(**args)
+        RubyLLM::MCP::Responses::Ping.new(self, **args).call
+      end
+
+      def roots_list_response(**args)
+        RubyLLM::MCP::Responses::RootsList.new(self, **args).call
+      end
+
+      def sampling_create_message_response(**args)
+        RubyLLM::MCP::Responses::SamplingCreateMessage.new(self, **args).call
+      end
+
+      def error_response(**args)
+        RubyLLM::MCP::Responses::Error.new(self, **args).call
+      end
+
+      def elicitation_response(**args)
+        RubyLLM::MCP::Responses::Elicitation.new(self, **args).call
+      end
+
+      def client_capabilities
+        capabilities = {}
+
+        if client.roots.active?
+          capabilities[:roots] = {
+            listChanged: true
+          }
+        end
+
+        if sampling_enabled?
+          capabilities[:sampling] = {}
+        end
+
+        if client.elicitation_enabled?
+          capabilities[:elicitation] = {}
+        end
+
+        capabilities
+      end
+
+      def transport
+        @transport ||= RubyLLM::MCP::Transport.new(@transport_type, self, config: @config)
+      end
+
+      # Get OAuth provider from transport if available
+      # @return [OAuthProvider, BrowserOAuthProvider, nil] OAuth provider or nil
+      def transport_oauth_provider
+        return nil unless @transport
+
+        transport_protocol = @transport.transport_protocol
+        return nil unless transport_protocol.respond_to?(:oauth_provider)
+
+        transport_protocol.oauth_provider
+      end
+
+      private
+
+      def sampling_enabled?
+        MCP.config.sampling.enabled?
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/elicitation.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "json-schema"
+
 module RubyLLM
   module MCP
     class Elicitation
@@ -19,20 +21,16 @@ module RubyLLM
       end
 
       def execute
-        success = @coordinator.elicitation_callback&.call(self)
-
+        success = @coordinator.client.on[:elicitation].call(self)
         if success
           valid = validate_response
           if valid
-            @coordinator.elicitation_response(id: @id,
-                                              elicitation: {
-                                                action: ACCEPT_ACTION, content: @structured_response
-                                              })
+            @coordinator.elicitation_response(id: @id, action: ACCEPT_ACTION, content: @structured_response)
           else
-            @coordinator.elicitation_response(id: @id, elicitation: { action: CANCEL_ACTION, content: nil })
+            @coordinator.elicitation_response(id: @id, action: CANCEL_ACTION, content: nil)
           end
         else
-          @coordinator.elicitation_response(id: @id, elicitation: { action: REJECT_ACTION, content: nil })
+          @coordinator.elicitation_response(id: @id, action: REJECT_ACTION, content: nil)
         end
       end
 

data/lib/ruby_llm/mcp/errors.rb

@@ -71,21 +71,6 @@ module RubyLLM
       class UnknownRequest < BaseError; end
 
       class UnsupportedProtocolVersion < BaseError; end
-
-      class UnsupportedFeature < BaseError; end
-
-      class UnsupportedTransport < BaseError; end
-
-      class AdapterConfigurationError < BaseError; end
-
-      class RequestCancelled < BaseError
-        attr_reader :request_id
-
-        def initialize(message:, request_id:)
-          @request_id = request_id
-          super(message: message)
-        end
-      end
     end
   end
 end

data/lib/ruby_llm/mcp/notification_handler.rb

@@ -3,10 +3,11 @@
 module RubyLLM
   module MCP
     class NotificationHandler
-      attr_reader :client
+      attr_reader :coordinator, :client
 
-      def initialize(client)
-        @client = client
+      def initialize(coordinator)
+        @coordinator = coordinator
+        @client = coordinator.client
       end
 
       def execute(notification)
@@ -24,7 +25,7 @@ module RubyLLM
         when "notifications/progress"
           process_progress_message(notification)
         when "notifications/cancelled"
-          process_cancelled_notification(notification)
+          # TODO: - do nothing at the moment until we support client operations
         else
           process_unknown_notification(notification)
         end
@@ -74,23 +75,6 @@ module RubyLLM
         end
       end
 
-      def process_cancelled_notification(notification)
-        request_id = notification.params["requestId"]
-        reason = notification.params["reason"] || "No reason provided"
-
-        RubyLLM::MCP.logger.info(
-          "Received cancellation for request #{request_id}: #{reason}"
-        )
-
-        success = client.cancel_in_flight_request(request_id)
-
-        unless success
-          RubyLLM::MCP.logger.debug(
-            "Request #{request_id} was not found or already completed"
-          )
-        end
-      end
-
       def process_unknown_notification(notification)
         message = "Unknown notification type: #{notification.type} params: #{notification.params.to_h}"
         RubyLLM::MCP.logger.error(message)

data/lib/ruby_llm/mcp/notifications/cancelled.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Notifications
+      class Cancelled
+        def initialize(coordinator, request_id:, reason:)
+          @coordinator = coordinator
+          @request_id = request_id
+          @reason = reason
+        end
+
+        def call
+          @coordinator.request(cancelled_notification_body, add_id: false, wait_for_response: false)
+        end
+
+        private
+
+        def cancelled_notification_body
+          {
+            jsonrpc: "2.0",
+            method: "notifications/cancelled",
+            params: {
+              requestId: @request_id,
+              reason: @reason
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/notifications/initialize.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Notifications
+      class Initialize
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def call
+          @coordinator.request(notification_body, add_id: true, wait_for_response: false)
+        end
+
+        def notification_body
+          {
+            jsonrpc: "2.0",
+            method: "notifications/initialized"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/notifications/roots_list_change.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Notifications
+      class RootsListChange
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def call
+          @coordinator.request(roots_list_change_notification_body, add_id: false, wait_for_response: false)
+        end
+
+        private
+
+        def roots_list_change_notification_body
+          {
+            jsonrpc: "2.0",
+            method: "notifications/roots/list_changed"
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/prompt.rb

@@ -21,10 +21,10 @@ module RubyLLM
         end
       end
 
-      attr_reader :name, :description, :arguments, :adapter
+      attr_reader :name, :description, :arguments, :coordinator
 
-      def initialize(adapter, prompt)
-        @adapter = adapter
+      def initialize(coordinator, prompt)
+        @coordinator = coordinator
         @name = prompt["name"]
         @description = prompt["description"]
         @arguments = parse_arguments(prompt["arguments"])
@@ -51,8 +51,8 @@ module RubyLLM
       alias say ask
 
       def complete(argument, value, context: nil)
-        if @adapter.capabilities.completion?
-          result = @adapter.completion_prompt(name: @name, argument: argument, value: value, context: context)
+        if @coordinator.capabilities.completion?
+          result = @coordinator.completion_prompt(name: @name, argument: argument, value: value, context: context)
           if result.error?
             return result.to_error
           end
@@ -80,7 +80,7 @@ module RubyLLM
       private
 
       def fetch_prompt_messages(arguments)
-        result = @adapter.execute_prompt(
+        result = @coordinator.execute_prompt(
           name: @name,
           arguments: arguments
         )
@@ -113,7 +113,7 @@ module RubyLLM
           attachment = MCP::Attachment.new(content["content"], content["mime_type"])
           MCP::Content.new(text: nil, attachments: [attachment])
         when "resource"
-          resource = Resource.new(adapter, content["resource"])
+          resource = Resource.new(coordinator, content["resource"])
           resource.to_content
         end
       end

data/lib/ruby_llm/mcp/protocol.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Protocol
+      module_function
+
+      LATEST_PROTOCOL_VERSION = "2025-06-18"
+      DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26"
+      SUPPORTED_PROTOCOL_VERSIONS = [
+        LATEST_PROTOCOL_VERSION,
+        "2025-03-26",
+        "2024-11-05",
+        "2024-10-07"
+      ].freeze
+
+      def supported_version?(version)
+        SUPPORTED_PROTOCOL_VERSIONS.include?(version)
+      end
+
+      def supported_versions
+        SUPPORTED_PROTOCOL_VERSIONS
+      end
+
+      def latest_version
+        LATEST_PROTOCOL_VERSION
+      end
+
+      def default_negotiated_version
+        DEFAULT_NEGOTIATED_PROTOCOL_VERSION
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/railtie.rb

@@ -1,13 +1,11 @@
 # frozen_string_literal: true
 
-if defined?(Rails::Railtie)
-  module RubyLLM
-    module MCP
-      class Railtie < Rails::Railtie
-        generators do
-          require_relative "../../generators/ruby_llm/mcp/install/install_generator"
-          require_relative "../../generators/ruby_llm/mcp/oauth/install_generator"
-        end
+module RubyLLM
+  module MCP
+    class Railtie < Rails::Railtie
+      generators do
+        require_relative "../../generators/ruby_llm/mcp/install/install_generator"
+        require_relative "../../generators/ruby_llm/mcp/oauth/install_generator"
       end
     end
   end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class CompletionPrompt
+        def initialize(coordinator, name:, argument:, value:, context: nil)
+          @coordinator = coordinator
+          @name = name
+          @argument = argument
+          @value = value
+          @context = context
+        end
+
+        def call
+          @coordinator.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "completion/complete",
+            params: {
+              ref: {
+                type: "ref/prompt",
+                name: @name
+              },
+              argument: {
+                name: @argument,
+                value: @value
+              },
+              context: format_context
+            }.compact
+          }
+        end
+
+        def format_context
+          return nil if @context.nil?
+
+          {
+            arguments: @context
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class CompletionResource
+        def initialize(coordinator, uri:, argument:, value:, context: nil)
+          @coordinator = coordinator
+          @uri = uri
+          @argument = argument
+          @value = value
+          @context = context
+        end
+
+        def call
+          @coordinator.request(request_body)
+        end
+
+        private
+
+        def request_body
+          {
+            jsonrpc: "2.0",
+            id: 1,
+            method: "completion/complete",
+            params: {
+              ref: {
+                type: "ref/resource",
+                uri: @uri
+              },
+              argument: {
+                name: @argument,
+                value: @value
+              },
+              context: format_context
+            }.compact
+          }
+        end
+
+        def format_context
+          return nil if @context.nil?
+
+          {
+            arguments: @context
+          }
+        end
+      end
+    end
+  end
+end