ruby_llm-mcp 0.4.1 → 0.5.0

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

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",