ruby_llm-mcp 0.3.1 → 0.4.0

data/lib/ruby_llm/mcp/coordinator.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "logger"
+
 module RubyLLM
   module MCP
     class Coordinator
@@ -23,30 +25,29 @@ module RubyLLM
 
       def request(body, **options)
         @transport.request(body, **options)
+      rescue RubyLLM::MCP::Errors::TimeoutError => e
+        if @transport.alive?
+          cancelled_notification(reason: "Request timed out", request_id: e.request_id)
+        end
+        raise e
       end
 
       def start_transport
-        case @transport_type
-        when :sse
-          @transport = RubyLLM::MCP::Transport::SSE.new(@config[:url],
-                                                        request_timeout: @config[:request_timeout],
-                                                        headers: @headers)
-        when :stdio
-          @transport = RubyLLM::MCP::Transport::Stdio.new(@config[:command],
-                                                          request_timeout: @config[:request_timeout],
-                                                          args: @config[:args],
-                                                          env: @config[:env])
-        when :streamable
-          @transport = RubyLLM::MCP::Transport::Streamable.new(@config[:url],
-                                                               request_timeout: @config[:request_timeout],
-                                                               headers: @headers)
-        else
-          message = "Invalid transport type: :#{transport_type}. Supported types are :sse, :stdio, :streamable"
-          raise Errors::InvalidTransportType.new(message: message)
+        build_transport
+
+        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"]
+        @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
 
-        @initialize_response = initialize_request
-        @capabilities = RubyLLM::MCP::Capabilities.new(@initialize_response["result"]["capabilities"])
+        @capabilities = RubyLLM::MCP::Capabilities.new(initialize_response.value["capabilities"])
         initialize_notification
       end
 
@@ -64,48 +65,211 @@ module RubyLLM
         !!@transport&.alive?
       end
 
+      def ping
+        ping_request = RubyLLM::MCP::Requests::Ping.new(self)
+        if alive?
+          result = ping_request.call
+        else
+          build_transport
+
+          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
+
+        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
+      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}")
+      end
+
+      def initialize_request
+        RubyLLM::MCP::Requests::Initialization.new(self).call
+      end
+
+      def tool_list
+        result = RubyLLM::MCP::Requests::ToolList.new(self).call
+        result.raise_error! if result.error?
+
+        result.value["tools"]
+      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 resource_list
+        result = RubyLLM::MCP::Requests::ResourceList.new(self).call
+        result.raise_error! if result.error?
+
+        result.value["resources"]
+      end
+
       def resource_read(**args)
         RubyLLM::MCP::Requests::ResourceRead.new(self, **args).call
       end
 
-      def completion_resource(**args)
-        RubyLLM::MCP::Requests::CompletionResource.new(self, **args).call
+      def resource_template_list
+        result = RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
+        result.raise_error! if result.error?
+
+        result.value["resourceTemplates"]
       end
 
-      def completion_prompt(**args)
-        RubyLLM::MCP::Requests::CompletionPrompt.new(self, **args).call
+      def resources_subscribe(**args)
+        RubyLLM::MCP::Requests::ResourcesSubscribe.new(self, **args).call
+      end
+
+      def prompt_list
+        result = RubyLLM::MCP::Requests::PromptList.new(self).call
+        result.raise_error! if result.error?
+
+        result.value["prompts"]
       end
 
       def execute_prompt(**args)
         RubyLLM::MCP::Requests::PromptCall.new(self, **args).call
       end
 
-      def initialize_request
-        RubyLLM::MCP::Requests::Initialization.new(self).call
+      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 initialize_notification
         RubyLLM::MCP::Requests::InitializeNotification.new(self).call
       end
 
-      def tool_list
-        RubyLLM::MCP::Requests::ToolList.new(self).call
+      def cancelled_notification(**args)
+        RubyLLM::MCP::Requests::CancelledNotification.new(self, **args).call
       end
 
-      def resource_list
-        RubyLLM::MCP::Requests::ResourceList.new(self).call
+      def ping_response(id: nil)
+        RubyLLM::MCP::Requests::PingResponse.new(self, id: id).call
       end
 
-      def resource_template_list
-        RubyLLM::MCP::Requests::ResourceTemplateList.new(self).call
+      def set_logging(level:)
+        RubyLLM::MCP::Requests::LoggingSetLevel.new(self, level: level).call
       end
 
-      def prompt_list
-        RubyLLM::MCP::Requests::PromptList.new(self).call
+      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
+      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 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 name
+        client.name
+      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
       end
     end
   end

data/lib/ruby_llm/mcp/error.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Error
+      def initialize(error_data)
+        @code = error_data["code"]
+        @message = error_data["message"]
+        @data = error_data["data"]
+      end
+
+      def type
+        case @code
+        when -32_700
+          :parse_error
+        when -32_600
+          :invalid_request
+        when -32_601
+          :method_not_found
+        when -32_602
+          :invalid_params
+        when -32_603
+          :internal_error
+        else
+          :custom_error
+        end
+      end
+
+      def to_s
+        "Error: code: #{@code} (#{type}), message: #{@message}, data: #{@data}"
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/errors.rb

@@ -12,17 +12,50 @@ module RubyLLM
         end
       end
 
-      class CompletionNotAvailable < BaseError; end
+      module Capabilities
+        class CompletionNotAvailable < BaseError; end
+        class ResourceSubscribeNotAvailable < BaseError; end
+      end
+
+      class InvalidProtocolVersionError < BaseError; end
+
+      class InvalidTransportType < BaseError; end
+
+      class ProgressHandlerNotAvailable < BaseError; end
 
       class PromptArgumentError < BaseError; end
 
-      class InvalidProtocolVersionError < BaseError; end
+      class ResponseError < BaseError
+        attr_reader :error
+
+        def initialize(message:, error:)
+          @error = error
+          super(message: message)
+        end
+      end
 
       class SessionExpiredError < BaseError; end
 
-      class TimeoutError < BaseError; end
+      class TimeoutError < BaseError
+        attr_reader :request_id
 
-      class InvalidTransportType < BaseError; end
+        def initialize(message:, request_id:)
+          @request_id = request_id
+          super(message: message)
+        end
+      end
+
+      class TransportError < BaseError
+        attr_reader :code, :error
+
+        def initialize(message:, code: nil, error: nil)
+          @code = code
+          @error = error
+          super(message: message)
+        end
+      end
+
+      class UnknownRequest < BaseError; end
     end
   end
 end

data/lib/ruby_llm/mcp/logging.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Logging
+      DEBUG = "debug"
+      INFO = "info"
+      NOTICE = "notice"
+      WARNING = "warning"
+      ERROR = "error"
+      CRITICAL = "critical"
+      ALERT = "alert"
+      EMERGENCY = "emergency"
+    end
+  end
+end

data/lib/ruby_llm/mcp/parameter.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "ruby_llm/tool"
+
 module RubyLLM
   module MCP
     class Parameter < RubyLLM::Parameter

data/lib/ruby_llm/mcp/progress.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Progress
+      attr_reader :progress_token, :progress, :total, :message, :client
+
+      def initialize(coordinator, progress_handler, progress_data)
+        @coordinator = coordinator
+        @client = coordinator.client
+        @progress_handler = progress_handler
+
+        @progress_token = progress_data["progressToken"]
+        @progress = progress_data["progress"]
+        @total = progress_data["total"]
+        @message = progress_data["message"]
+      end
+
+      def execute_progress_handler
+        @progress_handler&.call(self)
+      end
+
+      def to_h
+        {
+          progress_token: @progress_token,
+          progress: @progress,
+          total: @total,
+          message: @message
+        }
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/prompt.rb

@@ -44,24 +44,31 @@ module RubyLLM
 
       def complete(argument, value)
         if @coordinator.capabilities.completion?
-          response = @coordinator.completion_prompt(name: @name, argument: argument, value: value)
-          response = response.dig("result", "completion")
+          result = @coordinator.completion_prompt(name: @name, argument: argument, value: value)
+          if result.error?
+            return result.to_error
+          end
+
+          response = result.value["completion"]
 
           Completion.new(values: response["values"], total: response["total"], has_more: response["hasMore"])
         else
-          raise Errors::CompletionNotAvailable.new(message: "Completion is not available for this MCP server")
+          message = "Completion is not available for this MCP server"
+          raise Errors::Capabilities::CompletionNotAvailable.new(message: message)
         end
       end
 
       private
 
       def fetch_prompt_messages(arguments)
-        response = @coordinator.execute_prompt(
+        result = @coordinator.execute_prompt(
           name: @name,
           arguments: arguments
         )
 
-        response["result"]["messages"].map do |message|
+        result.raise_error! if result.error?
+
+        result.value["messages"].map do |message|
           content = create_content_for_message(message["content"])
 
           RubyLLM::Message.new(

data/lib/ruby_llm/mcp/providers/anthropic/complex_parameter_support.rb

@@ -23,11 +23,13 @@ module RubyLLM
               if param.item_type == :object
                 {
                   type: param.type,
+                  description: param.description,
                   items: { type: param.item_type, properties: clean_parameters(param.properties) }
-                }
+                }.compact
               else
                 {
                   type: param.type,
+                  description: param.description,
                   default: param.default,
                   items: { type: param.item_type, enum: param.enum }.compact
                 }.compact
@@ -35,9 +37,10 @@ module RubyLLM
             when :object
               {
                 type: param.type,
+                description: param.description,
                 properties: clean_parameters(param.properties),
                 required: required_parameters(param.properties)
-              }
+              }.compact
             when :union
               {
                 param.union_type => param.properties.map { |property| build_properties(property) }

data/lib/ruby_llm/mcp/providers/gemini/complex_parameter_support.rb

@@ -16,20 +16,22 @@ module RubyLLM
             }
           end
 
-          def build_properties(param)
+          def build_properties(param) # rubocop:disable Metrics/MethodLength
             properties = case param.type
                          when :array
                            if param.item_type == :object
                              {
                                type: param_type_for_gemini(param.type),
+                               description: param.description,
                                items: {
                                  type: param_type_for_gemini(param.item_type),
                                  properties: param.properties.transform_values { |value| build_properties(value) }
                                }
-                             }
+                             }.compact
                            else
                              {
                                type: param_type_for_gemini(param.type),
+                               description: param.description,
                                default: param.default,
                                items: { type: param_type_for_gemini(param.item_type), enum: param.enum }.compact
                              }.compact
@@ -37,9 +39,10 @@ module RubyLLM
                          when :object
                            {
                              type: param_type_for_gemini(param.type),
+                             description: param.description,
                              properties: param.properties.transform_values { |value| build_properties(value) },
                              required: param.properties.select { |_, p| p.required }.keys
-                           }
+                           }.compact
                          when :union
                            {
                              param.union_type => param.properties.map { |properties| build_properties(properties) }

data/lib/ruby_llm/mcp/providers/openai/complex_parameter_support.rb

@@ -7,20 +7,22 @@ module RubyLLM
         module ComplexParameterSupport
           module_function
 
-          def param_schema(param)
+          def param_schema(param) # rubocop:disable Metrics/MethodLength
             properties = case param.type
                          when :array
                            if param.item_type == :object
                              {
                                type: param.type,
+                               description: param.description,
                                items: {
                                  type: param.item_type,
                                  properties: param.properties.transform_values { |value| param_schema(value) }
                                }
-                             }
+                             }.compact
                            else
                              {
                                type: param.type,
+                               description: param.description,
                                default: param.default,
                                items: { type: param.item_type, enum: param.enum }.compact
                              }.compact
@@ -28,9 +30,10 @@ module RubyLLM
                          when :object
                            {
                              type: param.type,
+                             description: param.description,
                              properties: param.properties.transform_values { |value| param_schema(value) },
                              required: param.properties.select { |_, p| p.required }.keys
-                           }
+                           }.compact
                          when :union
                            {
                              param.union_type => param.properties.map { |property| param_schema(property) }

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

@@ -6,10 +6,10 @@ module RubyLLM
   module MCP
     module Requests
       class Base
-        attr_reader :client
+        attr_reader :coordinator
 
-        def initialize(client)
-          @client = client
+        def initialize(coordinator)
+          @coordinator = coordinator
         end
 
         def call

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

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class CancelledNotification
+        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/requests/completion_prompt.rb

@@ -4,15 +4,15 @@ module RubyLLM
   module MCP
     module Requests
       class CompletionPrompt
-        def initialize(client, name:, argument:, value:)
-          @client = client
+        def initialize(coordinator, name:, argument:, value:)
+          @coordinator = coordinator
           @name = name
           @argument = argument
           @value = value
         end
 
         def call
-          @client.request(request_body)
+          @coordinator.request(request_body)
         end
 
         private

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

@@ -4,15 +4,15 @@ module RubyLLM
   module MCP
     module Requests
       class CompletionResource
-        def initialize(client, uri:, argument:, value:)
-          @client = client
+        def initialize(coordinator, uri:, argument:, value:)
+          @coordinator = coordinator
           @uri = uri
           @argument = argument
           @value = value
         end
 
         def call
-          @client.request(request_body)
+          @coordinator.request(request_body)
         end
 
         private