ruby_llm-mcp 0.7.1 → 1.0.0

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

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class ResourceRead
-        attr_reader :coordinator, :uri
-
-        def initialize(coordinator, uri:)
-          @coordinator = coordinator
-          @uri = uri
-        end
-
-        def call
-          coordinator.request(reading_resource_body(uri))
-        end
-
-        def reading_resource_body(uri)
-          {
-            jsonrpc: "2.0",
-            method: "resources/read",
-            params: {
-              uri: uri
-            }
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class ResourceTemplateList
-        include Shared::Pagination
-
-        def initialize(coordinator, cursor: nil)
-          @coordinator = coordinator
-          @cursor = cursor
-        end
-
-        def call
-          body = merge_pagination(resource_template_list_body)
-          @coordinator.request(body)
-        end
-
-        private
-
-        def resource_template_list_body
-          {
-            jsonrpc: "2.0",
-            method: "resources/templates/list",
-            params: {}
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,30 +0,0 @@
-# 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/shared/meta.rb

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

data/lib/ruby_llm/mcp/requests/shared/pagination.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      module Shared
-        module Pagination
-          def merge_pagination(body)
-            body[:params] ||= {}
-            body[:params].merge!({ cursor: @cursor }) if @cursor
-            body
-          end
-        end
-      end
-    end
-  end
-end

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

@@ -1,35 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class ToolCall
-        include Shared::Meta
-
-        def initialize(coordinator, name:, parameters: {})
-          @coordinator = coordinator
-          @name = name
-          @parameters = parameters
-        end
-
-        def call
-          body = merge_meta(request_body)
-          @coordinator.request(body)
-        end
-
-        private
-
-        def request_body
-          {
-            jsonrpc: "2.0",
-            method: "tools/call",
-            params: {
-              name: @name,
-              arguments: @parameters
-            }
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class ToolList
-        include Shared::Pagination
-
-        def initialize(coordinator, cursor: nil)
-          @coordinator = coordinator
-          @cursor = cursor
-        end
-
-        def call
-          body = merge_pagination(tool_list_body)
-          @coordinator.request(body)
-        end
-
-        private
-
-        def tool_list_body
-          {
-            jsonrpc: "2.0",
-            method: "tools/list",
-            params: {}
-          }
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/mcp/response_handler.rb

@@ -1,67 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    class ResponseHandler
-      attr_reader :coordinator, :client
-
-      def initialize(coordinator)
-        @coordinator = coordinator
-        @client = coordinator.client
-      end
-
-      def execute(result) # rubocop:disable Naming/PredicateMethod
-        if result.ping?
-          coordinator.ping_response(id: result.id)
-          true
-        elsif result.roots?
-          handle_roots_response(result)
-          true
-        elsif result.sampling?
-          handle_sampling_response(result)
-          true
-        elsif result.elicitation?
-          handle_elicitation_response(result)
-          true
-        else
-          handle_unknown_request(result)
-          RubyLLM::MCP.logger.error("MCP client was sent unknown method type and could not respond: #{result.inspect}")
-          false
-        end
-      end
-
-      private
-
-      def handle_roots_response(result)
-        RubyLLM::MCP.logger.info("Roots request: #{result.inspect}")
-        if client.roots.active?
-          coordinator.roots_list_response(id: result.id, roots: client.roots)
-        else
-          coordinator.error_response(id: result.id, message: "Roots are not enabled", code: -32_000)
-        end
-      end
-
-      def handle_sampling_response(result)
-        unless MCP.config.sampling.enabled?
-          RubyLLM::MCP.logger.info("Sampling is disabled, yet server requested sampling")
-          coordinator.error_response(id: result.id, message: "Sampling is disabled", code: -32_000)
-          return
-        end
-
-        RubyLLM::MCP.logger.info("Sampling request: #{result.inspect}")
-        Sample.new(result, coordinator).execute
-      end
-
-      def handle_elicitation_response(result)
-        RubyLLM::MCP.logger.info("Elicitation request: #{result.inspect}")
-        Elicitation.new(coordinator, result).execute
-      end
-
-      def handle_unknown_request(result)
-        coordinator.error_response(id: result.id,
-                                   message: "Unknown method and could not respond: #{result.method}",
-                                   code: -32_000)
-      end
-    end
-  end
-end

data/lib/ruby_llm/mcp/responses/elicitation.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Responses
-      class Elicitation
-        def initialize(coordinator, id:, action:, content:)
-          @coordinator = coordinator
-          @id = id
-          @action = action
-          @content = content
-        end
-
-        def call
-          @coordinator.request(elicitation_response_body, add_id: false, wait_for_response: false)
-        end
-
-        private
-
-        def elicitation_response_body
-          {
-            jsonrpc: "2.0",
-            id: @id,
-            result: {
-              action: @action,
-              content: @content
-            }.compact
-          }
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/mcp/responses/error.rb

@@ -1,33 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Responses
-      class Error
-        def initialize(coordinator, id:, message:, code: -32_000)
-          @coordinator = coordinator
-          @id = id
-          @message = message
-          @code = code
-        end
-
-        def call
-          @coordinator.request(sampling_error_body, add_id: false, wait_for_response: false)
-        end
-
-        private
-
-        def sampling_error_body
-          {
-            jsonrpc: "2.0",
-            id: @id,
-            error: {
-              code: @code,
-              message: @message
-            }
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,28 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Responses
-      class Ping
-        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/responses/roots_list.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Responses
-      class RootsList
-        def initialize(coordinator, roots:, id:)
-          @coordinator = coordinator
-          @roots = roots
-          @id = id
-        end
-
-        def call
-          @coordinator.request(roots_list_body, add_id: false, wait_for_response: false)
-        end
-
-        private
-
-        def roots_list_body
-          {
-            jsonrpc: "2.0",
-            id: @id,
-            result: {
-              roots: @roots.to_request
-            }
-          }
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/mcp/responses/sampling_create_message.rb

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Responses
-      class SamplingCreateMessage
-        def initialize(coordinator, id:, message:, model:)
-          @coordinator = coordinator
-          @id = id
-          @message = message
-          @model = model
-        end
-
-        def call
-          @coordinator.request(sampling_create_message_body, add_id: false, wait_for_response: false)
-        end
-
-        private
-
-        def sampling_create_message_body
-          {
-            jsonrpc: "2.0",
-            id: @id,
-            result: {
-              role: @message.role,
-              content: format_content(@message.content),
-              model: @model,
-              # TODO: We are going to assume it was a endTurn
-              # Look into getting RubyLLM to expose stopReason in message response
-              stopReason: "endTurn"
-            }
-          }
-        end
-
-        def format_content(content)
-          if content.is_a?(RubyLLM::Content)
-            if context.text.none? && content.attachments.any?
-              attachment = content.attachments.first
-              { type: attachment.type, data: attachment.content, mime_type: attachment.mime_type }
-            else
-              { type: "text", text: content.text }
-            end
-          else
-            { type: "text", text: content }
-          end
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/mcp/transport.rb

@@ -1,58 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    class Transport
-      class << self
-        def transports
-          @transports ||= {}
-        end
-
-        def register_transport(transport_type, transport_class)
-          transports[transport_type] = transport_class
-        end
-      end
-
-      extend Forwardable
-
-      register_transport(:sse, RubyLLM::MCP::Transports::SSE)
-      register_transport(:stdio, RubyLLM::MCP::Transports::Stdio)
-      register_transport(:streamable, RubyLLM::MCP::Transports::StreamableHTTP)
-      register_transport(:streamable_http, RubyLLM::MCP::Transports::StreamableHTTP)
-
-      attr_reader :transport_type, :coordinator, :config, :pid
-
-      def initialize(transport_type, coordinator, config:)
-        @transport_type = transport_type
-        @coordinator = coordinator
-        @config = config
-        @pid = Process.pid
-      end
-
-      def_delegators :transport_protocol, :request, :alive?, :close, :start, :set_protocol_version
-
-      def transport_protocol
-        if @pid != Process.pid
-          @pid = Process.pid
-          @transport = build_transport
-          coordinator.restart_transport
-        end
-
-        @transport_protocol ||= build_transport
-      end
-
-      private
-
-      def build_transport
-        unless RubyLLM::MCP::Transport.transports.key?(transport_type)
-          supported_types = RubyLLM::MCP::Transport.transports.keys.join(", ")
-          message = "Invalid transport type: :#{transport_type}. Supported types are #{supported_types}"
-          raise Errors::InvalidTransportType.new(message: message)
-        end
-
-        transport_klass = RubyLLM::MCP::Transport.transports[transport_type]
-        transport_klass.new(coordinator: coordinator, **config)
-      end
-    end
-  end
-end