ruby_llm-mcp 0.3.1 → 0.4.0

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

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

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

@@ -1,14 +1,20 @@
 # frozen_string_literal: true
 
-class RubyLLM::MCP::Requests::InitializeNotification < RubyLLM::MCP::Requests::Base
-  def call
-    client.request(notification_body, add_id: false, wait_for_response: false)
-  end
+module RubyLLM
+  module MCP
+    module Requests
+      class InitializeNotification < RubyLLM::MCP::Requests::Base
+        def call
+          coordinator.request(notification_body, add_id: false, wait_for_response: false)
+        end
 
-  def notification_body
-    {
-      jsonrpc: "2.0",
-      method: "notifications/initialized"
-    }
+        def notification_body
+          {
+            jsonrpc: "2.0",
+            method: "notifications/initialized"
+          }
+        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/meta.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "securerandom"
+
+module RubyLLM
+  module MCP
+    module Requests
+      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

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

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Requests
+      class Ping < Base
+        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/ping_response.rb

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

@@ -4,14 +4,14 @@ module RubyLLM
   module MCP
     module Requests
       class PromptCall
-        def initialize(client, name:, arguments: {})
-          @client = client
+        def initialize(coordinator, name:, arguments: {})
+          @coordinator = coordinator
           @name = name
           @arguments = arguments
         end
 
         def call
-          @client.request(request_body)
+          @coordinator.request(request_body)
         end
 
         private

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

@@ -5,7 +5,7 @@ module RubyLLM
     module Requests
       class PromptList < Base
         def call
-          client.request(request_body)
+          coordinator.request(request_body)
         end
 
         private

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

@@ -5,7 +5,7 @@ module RubyLLM
     module Requests
       class ResourceList < Base
         def call
-          client.request(resource_list_body)
+          coordinator.request(resource_list_body)
         end
 
         def resource_list_body

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

@@ -4,15 +4,15 @@ module RubyLLM
   module MCP
     module Requests
       class ResourceRead
-        attr_reader :client, :uri
+        attr_reader :coordinator, :uri
 
-        def initialize(client, uri:)
-          @client = client
+        def initialize(coordinator, uri:)
+          @coordinator = coordinator
           @uri = uri
         end
 
         def call
-          client.request(reading_resource_body(uri))
+          coordinator.request(reading_resource_body(uri))
         end
 
         def reading_resource_body(uri)

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

@@ -5,7 +5,7 @@ module RubyLLM
     module Requests
       class ResourceTemplateList < Base
         def call
-          client.request(resource_template_list_body)
+          coordinator.request(resource_template_list_body)
         end
 
         def resource_template_list_body

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

@@ -4,14 +4,17 @@ module RubyLLM
   module MCP
     module Requests
       class ToolCall
-        def initialize(client, name:, parameters: {})
-          @client = client
+        include Meta
+
+        def initialize(coordinator, name:, parameters: {})
+          @coordinator = coordinator
           @name = name
           @parameters = parameters
         end
 
         def call
-          @client.request(request_body)
+          body = merge_meta(request_body)
+          @coordinator.request(body)
         end
 
         private

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

@@ -1,17 +1,23 @@
 # frozen_string_literal: true
 
-class RubyLLM::MCP::Requests::ToolList < RubyLLM::MCP::Requests::Base
-  def call
-    client.request(tool_list_body)
-  end
+module RubyLLM
+  module MCP
+    module Requests
+      class ToolList < RubyLLM::MCP::Requests::Base
+        def call
+          coordinator.request(tool_list_body)
+        end
 
-  private
+        private
 
-  def tool_list_body
-    {
-      jsonrpc: "2.0",
-      method: "tools/list",
-      params: {}
-    }
+        def tool_list_body
+          {
+            jsonrpc: "2.0",
+            method: "tools/list",
+            params: {}
+          }
+        end
+      end
+    end
   end
 end

data/lib/ruby_llm/mcp/resource.rb

@@ -1,9 +1,11 @@
 # frozen_string_literal: true
 
+require "httpx"
+
 module RubyLLM
   module MCP
     class Resource
-      attr_reader :uri, :name, :description, :mime_type, :coordinator
+      attr_reader :uri, :name, :description, :mime_type, :coordinator, :subscribed
 
       def initialize(coordinator, resource)
         @coordinator = coordinator
@@ -15,16 +17,35 @@ module RubyLLM
           @content_response = resource["content_response"]
           @content = @content_response["text"] || @content_response["blob"]
         end
+
+        @subscribed = false
       end
 
       def content
         return @content unless @content.nil?
 
-        response = read_response
-        @content_response = response.dig("result", "contents", 0)
+        result = read_response
+        result.raise_error! if result.error?
+
+        @content_response = result.value.dig("contents", 0)
         @content = @content_response["text"] || @content_response["blob"]
       end
 
+      def subscribe!
+        if @coordinator.capabilities.resource_subscribe?
+          @coordinator.resources_subscribe(uri: @uri)
+          @subscribed = true
+        else
+          message = "Resource subscribe is not available for this MCP server"
+          raise Errors::Capabilities::ResourceSubscribeNotAvailable.new(message: message)
+        end
+      end
+
+      def reset_content!
+        @content = nil
+        @content_response = nil
+      end
+
       def include(chat, **args)
         message = Message.new(
           role: "user",
@@ -64,12 +85,12 @@ module RubyLLM
         when "http", "https"
           fetch_uri_content(uri)
         else # file:// or git://
-          @read_response ||= @coordinator.resource_read(uri: uri)
+          @coordinator.resource_read(uri: uri)
         end
       end
 
       def fetch_uri_content(uri)
-        response = Faraday.get(uri)
+        response = HTTPX.get(uri)
         { "result" => { "contents" => [{ "text" => response.body }] } }
       end
     end

data/lib/ruby_llm/mcp/resource_template.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require "httpx"
+
 module RubyLLM
   module MCP
     class ResourceTemplate
@@ -15,8 +17,8 @@ module RubyLLM
 
       def fetch_resource(arguments: {})
         uri = apply_template(@uri, arguments)
-        response = read_response(uri)
-        content_response = response.dig("result", "contents", 0)
+        result = read_response(uri)
+        content_response = result.value.dig("contents", 0)
 
         Resource.new(coordinator, {
                        "uri" => uri,
@@ -33,12 +35,15 @@ module RubyLLM
 
       def complete(argument, value)
         if @coordinator.capabilities.completion?
-          response = @coordinator.completion_resource(uri: @uri, argument: argument, value: value)
-          response = response.dig("result", "completion")
+          result = @coordinator.completion_resource(uri: @uri, argument: argument, value: value)
+          result.raise_error! if result.error?
+
+          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
 
@@ -63,7 +68,7 @@ module RubyLLM
       end
 
       def fetch_uri_content(uri)
-        response = Faraday.get(uri)
+        response = HTTPX.get(uri)
         { "result" => { "contents" => [{ "text" => response.body }] } }
       end
 

data/lib/ruby_llm/mcp/result.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Notification
+      attr_reader :type, :params
+
+      def initialize(response)
+        @type = response["method"]
+        @params = response["params"]
+      end
+    end
+
+    class Result
+      attr_reader :result, :error, :params, :id, :response, :session_id
+
+      def initialize(response, session_id: nil)
+        @response = response
+        @session_id = session_id
+        @id = response["id"]
+        @method = response["method"]
+        @result = response["result"] || {}
+        @params = response["params"] || {}
+        @error = response["error"] || {}
+
+        @result_is_error = response.dig("result", "isError") || false
+      end
+
+      alias value result
+
+      def notification
+        Notification.new(@response)
+      end
+
+      def to_error
+        Error.new(@error)
+      end
+
+      def execution_error?
+        @result_is_error
+      end
+
+      def raise_error!
+        error = to_error
+        message = "Response error: #{error}"
+        raise Errors::ResponseError.new(message: message, error: error)
+      end
+
+      def matching_id?(request_id)
+        @id&.to_s == request_id
+      end
+
+      def ping?
+        @method == "ping"
+      end
+
+      def notification?
+        @method&.include?("notifications") || false
+      end
+
+      def request?
+        @method && !notification? && @result.none? && @error.none?
+      end
+
+      def response?
+        @id && (@result || @error.any?) && !@method
+      end
+
+      def success?
+        !@result.empty?
+      end
+
+      def tool_success?
+        success? && !@result_is_error
+      end
+
+      def error?
+        !@error.empty?
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} id: #{@id}, result: #{@result}, error: #{@error}, method: #{@method}, params: #{@params}>" # rubocop:disable Layout/LineLength
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/tool.rb

@@ -2,6 +2,18 @@
 
 module RubyLLM
   module MCP
+    class Annotation
+      attr_reader :title, :read_only_hint, :destructive_hint, :idempotent_hint, :open_world_hint
+
+      def initialize(annotation)
+        @title = annotation["title"] || ""
+        @read_only_hint = annotation["readOnlyHint"] || false
+        @destructive_hint = annotation["destructiveHint"] || true
+        @idempotent_hint = annotation["idempotentHint"] || false
+        @open_world_hint = annotation["openWorldHint"] || true
+      end
+    end
+
     class Tool < RubyLLM::Tool
       attr_reader :name, :description, :parameters, :coordinator, :tool_response
 
@@ -12,18 +24,31 @@ module RubyLLM
         @name = tool_response["name"]
         @description = tool_response["description"].to_s
         @parameters = create_parameters(tool_response["inputSchema"])
+        @annotations = tool_response["annotations"] ? Annotation.new(tool_response["annotations"]) : nil
+      end
+
+      def display_name
+        "#{@coordinator.name}: #{@name}"
       end
 
       def execute(**params)
-        response = @coordinator.execute_tool(
+        result = @coordinator.execute_tool(
           name: @name,
           parameters: params
         )
 
-        text_values = response.dig("result", "content").map { |content| content["text"] }.compact.join("\n")
+        if result.error?
+          error = result.to_error
+          return { error: error.to_s }
+        end
+
+        text_values = result.value["content"].map { |content| content["text"] }.compact.join("\n")
+        if result.execution_error?
+          return { error: "Tool execution error: #{text_values}" }
+        end
 
         if text_values.empty?
-          create_content_for_message(response.dig("result", "content", 0))
+          create_content_for_message(result.value.dig("content", 0))
         else
           create_content_for_message({ "type" => "text", "text" => text_values })
         end