ruby_llm-mcp 0.4.1 → 0.5.1

data/lib/ruby_llm/mcp/configuration.rb

@@ -1,14 +1,106 @@
 # frozen_string_literal: true
 
+require "json"
+require "yaml"
+require "erb"
+
 module RubyLLM
   module MCP
     class Configuration
-      attr_accessor :request_timeout, :log_file, :log_level, :has_support_complex_parameters
-      attr_writer :logger
+      class Sampling
+        attr_accessor :enabled
+        attr_writer :preferred_model
+
+        def initialize
+          set_defaults
+        end
+
+        def reset!
+          set_defaults
+        end
+
+        def guard(&block)
+          @guard = block if block_given?
+          @guard
+        end
+
+        def preferred_model(&block)
+          @preferred_model = block if block_given?
+          @preferred_model
+        end
+
+        def enabled?
+          @enabled
+        end
+
+        private
+
+        def set_defaults
+          @enabled = false
+          @preferred_model = nil
+          @guard = nil
+        end
+      end
+
+      class ConfigFile
+        attr_reader :file_path
+
+        def initialize(file_path)
+          @file_path = file_path
+        end
+
+        def parse
+          @parse ||= if @file_path && File.exist?(@file_path)
+                       config = parse_config_file
+                       load_mcps_config(config)
+                     else
+                       []
+                     end
+        end
+
+        private
+
+        def parse_config_file
+          output = ERB.new(File.read(@file_path)).result
+
+          if [".yaml", ".yml"].include?(File.extname(@file_path))
+            YAML.safe_load(output, symbolize_names: true)
+          else
+            JSON.parse(output, symbolize_names: true)
+          end
+        end
+
+        def load_mcps_config(config)
+          return [] unless config.key?(:mcp_servers)
+
+          config[:mcp_servers].map do |name, configuration|
+            {
+              name: name,
+              transport_type: configuration.delete(:transport_type),
+              start: false,
+              config: configuration
+            }
+          end
+        end
+      end
+
+      attr_accessor :request_timeout,
+                    :log_file,
+                    :log_level,
+                    :has_support_complex_parameters,
+                    :roots,
+                    :sampling,
+                    :max_connections,
+                    :pool_timeout,
+                    :config_path,
+                    :launch_control
+
+      attr_writer :logger, :mcp_configuration
 
       REQUEST_TIMEOUT_DEFAULT = 8000
 
       def initialize
+        @sampling = Sampling.new
         set_defaults
       end
 
@@ -31,6 +123,10 @@ module RubyLLM
         )
       end
 
+      def mcp_configuration
+        @mcp_configuration + load_mcps_config
+      end
+
       def inspect
         redacted = lambda do |name, value|
           if name.match?(/_id|_key|_secret|_token$/)
@@ -51,15 +147,39 @@ module RubyLLM
 
       private
 
+      def load_mcps_config
+        @config_file ||= ConfigFile.new(config_path)
+        @config_file.parse
+      end
+
       def set_defaults
         # Connection configuration
         @request_timeout = REQUEST_TIMEOUT_DEFAULT
 
+        # Connection Pool
+        @max_connections = Float::INFINITY
+        @pool_timeout = 5
+
         # Logging configuration
         @log_file = $stdout
         @log_level = ENV["RUBYLLM_MCP_DEBUG"] ? Logger::DEBUG : Logger::INFO
-        @has_support_complex_parameters = false
         @logger = nil
+
+        # Complex parameters support
+        @has_support_complex_parameters = false
+
+        # MCPs configuration
+        @mcps_config_path = nil
+        @mcp_configuration = []
+
+        # Rails specific configuration
+        @launch_control = :automatic
+
+        # Roots configuration
+        @roots = []
+
+        # Sampling configuration
+        @sampling.reset!
       end
     end
   end

data/lib/ruby_llm/mcp/coordinator.rb

@@ -8,8 +8,7 @@ module RubyLLM
       PROTOCOL_VERSION = "2025-03-26"
       PV_2024_11_05 = "2024-11-05"
 
-      attr_reader :client, :transport_type, :config, :request_timeout, :headers, :transport, :initialize_response,
-                  :capabilities, :protocol_version
+      attr_reader :client, :transport_type, :config, :capabilities, :protocol_version
 
       def initialize(client, transport_type:, config: {})
         @client = client
@@ -17,23 +16,46 @@ module RubyLLM
         @config = config
 
         @protocol_version = PROTOCOL_VERSION
-        @headers = config[:headers] || {}
 
         @transport = nil
         @capabilities = nil
       end
 
+      def name
+        client.name
+      end
+
       def request(body, **options)
-        @transport.request(body, **options)
+        transport.request(body, **options)
       rescue RubyLLM::MCP::Errors::TimeoutError => e
-        if @transport.alive?
+        if transport&.alive?
           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
-        build_transport
+        return unless capabilities.nil?
+
+        transport.start
 
         initialize_response = initialize_request
         initialize_response.raise_error! if initialize_response.error?
@@ -47,16 +69,19 @@ module RubyLLM
           @transport.set_protocol_version(@protocol_version)
         end
 
-        @capabilities = RubyLLM::MCP::Capabilities.new(initialize_response.value["capabilities"])
+        @capabilities = RubyLLM::MCP::ServerCapabilities.new(initialize_response.value["capabilities"])
         initialize_notification
       end
 
       def stop_transport
         @transport&.close
+        @capabilities = nil
         @transport = nil
+        @protocol_version = PROTOCOL_VERSION
       end
 
       def restart_transport
+        @initialize_response = nil
         stop_transport
         start_transport
       end
@@ -70,7 +95,7 @@ module RubyLLM
         if alive?
           result = ping_request.call
         else
-          build_transport
+          transport.start
 
           result = ping_request.call
           @transport = nil
@@ -83,50 +108,26 @@ module RubyLLM
 
       def process_notification(result)
         notification = result.notification
-
-        case notification.type
-        when "notifications/tools/list_changed"
-          client.reset_tools!
-        when "notifications/resources/list_changed"
-          client.reset_resources!
-        when "notifications/resources/updated"
-          uri = notification.params["uri"]
-          resource = client.resources.find { |r| r.uri == uri }
-          resource&.reset_content!
-        when "notifications/prompts/list_changed"
-          client.reset_prompts!
-        when "notifications/message"
-          process_logging_message(notification)
-        when "notifications/progress"
-          process_progress_message(notification)
-        when "notifications/cancelled"
-          # TODO: - do nothing at the moment until we support client operations
-        else
-          message = "Unknown notification type: #{notification.type} params:#{notification.params.to_h}"
-          raise Errors::UnknownNotification.new(message: message)
-        end
+        NotificationHandler.new(self).execute(notification)
       end
 
       def process_request(result)
-        if result.ping?
-          ping_response(id: result.id)
-          return
-        end
-
-        # Handle server-initiated requests
-        # Currently, we do not support any client operations but will
-        raise RubyLLM::MCP::Errors::UnknownRequest.new(message: "Unknown request type: #{result.inspect}")
+        ResponseHandler.new(self).execute(result)
       end
 
       def initialize_request
         RubyLLM::MCP::Requests::Initialization.new(self).call
       end
 
-      def tool_list
-        result = RubyLLM::MCP::Requests::ToolList.new(self).call
+      def tool_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::ToolList.new(self, cursor: cursor).call
         result.raise_error! if result.error?
 
-        result.value["tools"]
+        if result.next_cursor?
+          result.value["tools"] + tool_list(cursor: result.next_cursor)
+        else
+          result.value["tools"]
+        end
       end
 
       def execute_tool(**args)
@@ -149,33 +150,45 @@ module RubyLLM
         RubyLLM::MCP::Requests::ToolCall.new(self, **args).call
       end
 
-      def resource_list
-        result = RubyLLM::MCP::Requests::ResourceList.new(self).call
+      def resource_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::ResourceList.new(self, cursor: cursor).call
         result.raise_error! if result.error?
 
-        result.value["resources"]
+        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
-        result = RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
+      def resource_template_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::ResourceTemplateList.new(self, cursor: cursor).call
         result.raise_error! if result.error?
 
-        result.value["resourceTemplates"]
+        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
-        result = RubyLLM::MCP::Requests::PromptList.new(self).call
+      def prompt_list(cursor: nil)
+        result = RubyLLM::MCP::Requests::PromptList.new(self, cursor: cursor).call
         result.raise_error! if result.error?
 
-        result.value["prompts"]
+        if result.next_cursor?
+          result.value["prompts"] + prompt_list(cursor: result.next_cursor)
+        else
+          result.value["prompts"]
+        end
       end
 
       def execute_prompt(**args)
@@ -190,86 +203,66 @@ module RubyLLM
         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::Requests::InitializeNotification.new(self).call
+        RubyLLM::MCP::Notifications::Initialize.new(self).call
       end
 
       def cancelled_notification(**args)
-        RubyLLM::MCP::Requests::CancelledNotification.new(self, **args).call
-      end
-
-      def ping_response(id: nil)
-        RubyLLM::MCP::Requests::PingResponse.new(self, id: id).call
-      end
-
-      def set_logging(level:)
-        RubyLLM::MCP::Requests::LoggingSetLevel.new(self, level: level).call
-      end
-
-      def build_transport
-        case @transport_type
-        when :sse
-          @transport = RubyLLM::MCP::Transport::SSE.new(@config[:url],
-                                                        request_timeout: @config[:request_timeout],
-                                                        headers: @headers,
-                                                        coordinator: self)
-        when :stdio
-          @transport = RubyLLM::MCP::Transport::Stdio.new(@config[:command],
-                                                          request_timeout: @config[:request_timeout],
-                                                          args: @config[:args],
-                                                          env: @config[:env],
-                                                          coordinator: self)
-        when :streamable
-          @transport = RubyLLM::MCP::Transport::StreamableHTTP.new(@config[:url],
-                                                                   request_timeout: @config[:request_timeout],
-                                                                   headers: @headers,
-                                                                   coordinator: self)
-        else
-          message = "Invalid transport type: :#{transport_type}. Supported types are :sse, :stdio, :streamable"
-          raise Errors::InvalidTransportType.new(message: message)
-        end
+        RubyLLM::MCP::Notifications::Cancelled.new(self, **args).call
       end
 
-      def process_logging_message(notification)
-        if client.logging_handler_enabled?
-          client.on[:logging].call(notification)
-        else
-          default_process_logging_message(notification)
-        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 default_process_logging_message(notification, logger: RubyLLM::MCP.logger)
-        level = notification.params["level"]
-        logger_message = notification.params["logger"]
-        message = notification.params["data"]
-
-        message = "#{logger_message}: #{message}"
-
-        case level
-        when "debug"
-          logger.debug(message["message"])
-        when "info", "notice"
-          logger.info(message["message"])
-        when "warning"
-          logger.warn(message["message"])
-        when "error", "critical"
-          logger.error(message["message"])
-        when "alert", "emergency"
-          logger.fatal(message["message"])
+      def error_response(**args)
+        RubyLLM::MCP::Responses::Error.new(self, **args).call
+      end
+
+      def client_capabilities
+        capabilities = {}
+
+        if client.roots.active?
+          capabilities[:roots] = {
+            listChanged: true
+          }
         end
+
+        if sampling_enabled?
+          capabilities[:sampling] = {}
+        end
+
+        capabilities
       end
 
-      def name
-        client.name
+      def transport
+        @transport ||= RubyLLM::MCP::Transport.new(@transport_type, self, config: @config)
       end
 
       private
 
-      def process_progress_message(notification)
-        progress_obj = RubyLLM::MCP::Progress.new(self, client.on[:progress], notification.params)
-        if client.tracking_progress?
-          progress_obj.execute_progress_handler
-        end
+      def sampling_enabled?
+        MCP.config.sampling.enabled?
       end
     end
   end

data/lib/ruby_llm/mcp/errors.rb

@@ -17,6 +17,8 @@ module RubyLLM
         class ResourceSubscribeNotAvailable < BaseError; end
       end
 
+      class InvalidFormatError < BaseError; end
+
       class InvalidProtocolVersionError < BaseError; end
 
       class InvalidTransportType < BaseError; end
@@ -39,7 +41,7 @@ module RubyLLM
       class TimeoutError < BaseError
         attr_reader :request_id
 
-        def initialize(message:, request_id:)
+        def initialize(message:, request_id: nil)
           @request_id = request_id
           super(message: message)
         end

data/lib/ruby_llm/mcp/notification_handler.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class NotificationHandler
+      attr_reader :coordinator, :client
+
+      def initialize(coordinator)
+        @coordinator = coordinator
+        @client = coordinator.client
+      end
+
+      def execute(notification)
+        case notification.type
+        when "notifications/tools/list_changed"
+          client.reset_tools!
+        when "notifications/resources/list_changed"
+          client.reset_resources!
+        when "notifications/resources/updated"
+          process_resource_updated(notification)
+        when "notifications/prompts/list_changed"
+          client.reset_prompts!
+        when "notifications/message"
+          process_logging_message(notification)
+        when "notifications/progress"
+          process_progress_message(notification)
+        when "notifications/cancelled"
+          # TODO: - do nothing at the moment until we support client operations
+        else
+          process_unknown_notification(notification)
+        end
+      end
+
+      private
+
+      def process_resource_updated(notification)
+        uri = notification.params["uri"]
+        resource = client.resources.find { |r| r.uri == uri }
+        resource&.reset_content!
+      end
+
+      def process_logging_message(notification)
+        if client.logging_handler_enabled?
+          client.on[:logging].call(notification)
+        else
+          default_process_logging_message(notification)
+        end
+      end
+
+      def process_progress_message(notification)
+        if client.tracking_progress?
+          progress_obj = RubyLLM::MCP::Progress.new(self, client.on[:progress], notification.params)
+          progress_obj.execute_progress_handler
+        end
+      end
+
+      def default_process_logging_message(notification, logger: RubyLLM::MCP.logger)
+        level = notification.params["level"]
+        logger_message = notification.params["logger"]
+        message = notification.params["data"]
+
+        message = "#{logger_message}: #{message}"
+
+        case level
+        when "debug"
+          logger.debug(message["message"])
+        when "info", "notice"
+          logger.info(message["message"])
+        when "warning"
+          logger.warn(message["message"])
+        when "error", "critical"
+          logger.error(message["message"])
+        when "alert", "emergency"
+          logger.fatal(message["message"])
+        end
+      end
+
+      def process_unknown_notification(notification)
+        message = "Unknown notification type: #{notification.type} params: #{notification.params.to_h}"
+        RubyLLM::MCP.logger.error(message)
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/{requests/cancelled_notification.rb → notifications/cancelled.rb}

@@ -2,8 +2,8 @@
 
 module RubyLLM
   module MCP
-    module Requests
-      class CancelledNotification
+    module Notifications
+      class Cancelled
         def initialize(coordinator, request_id:, reason:)
           @coordinator = coordinator
           @request_id = request_id

data/lib/ruby_llm/mcp/{requests/initialize_notification.rb → notifications/initialize.rb}

@@ -2,10 +2,14 @@
 
 module RubyLLM
   module MCP
-    module Requests
-      class InitializeNotification < RubyLLM::MCP::Requests::Base
+    module Notifications
+      class Initialize
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
         def call
-          coordinator.request(notification_body, add_id: false, wait_for_response: false)
+          @coordinator.request(notification_body, add_id: false, wait_for_response: false)
         end
 
         def notification_body

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/parameter.rb

@@ -15,7 +15,25 @@ module RubyLLM
       end
 
       def item_type
-        @items["type"].to_sym
+        @items&.dig("type")&.to_sym
+      end
+
+      def as_json(*_args)
+        to_h
+      end
+
+      def to_h
+        {
+          name: @name,
+          type: @type,
+          description: @desc,
+          required: @required,
+          default: @default,
+          union_type: @union_type,
+          items: @items&.to_h,
+          properties: @properties&.values,
+          enum: @enum
+        }
       end
     end
   end

data/lib/ruby_llm/mcp/progress.rb

@@ -17,7 +17,7 @@ module RubyLLM
       end
 
       def execute_progress_handler
-        @progress_handler&.call(self)
+        @progress_handler.call(self)
       end
 
       def to_h
@@ -28,6 +28,8 @@ module RubyLLM
           message: @message
         }
       end
+
+      alias to_json to_h
     end
   end
 end