ruby_llm-mcp 0.8.0 → 1.0.0

data/lib/ruby_llm/mcp/coordinator.rb

@@ -1,304 +0,0 @@
-# frozen_string_literal: true
-
-require "logger"
-
-module RubyLLM
-  module MCP
-    class Coordinator
-      attr_reader :client, :transport_type, :config, :capabilities, :protocol_version
-
-      def initialize(client, transport_type:, config: {})
-        @client = client
-        @transport_type = transport_type
-        @config = config
-
-        @protocol_version = MCP.config.protocol_version || MCP::Protocol.default_negotiated_version
-
-        @transport = nil
-        @capabilities = nil
-      end
-
-      def name
-        client.name
-      end
-
-      def request(body, **options)
-        transport.request(body, **options)
-      rescue RubyLLM::MCP::Errors::TimeoutError => e
-        if transport&.alive? && !e.request_id.nil?
-          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
-        return unless capabilities.nil?
-
-        transport.start
-
-        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"]
-
-        if negotiated_version && !MCP::Protocol.supported_version?(negotiated_version)
-          raise Errors::UnsupportedProtocolVersion.new(
-            message: <<~MESSAGE
-              Unsupported protocol version, and could not negotiate a supported version: #{negotiated_version}.
-              Supported versions: #{MCP::Protocol.supported_versions.join(', ')}
-            MESSAGE
-          )
-        end
-
-        @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
-
-        @capabilities = RubyLLM::MCP::ServerCapabilities.new(initialize_response.value["capabilities"])
-        initialize_notification
-
-        if client.logging_handler_enabled?
-          set_logging(level: client.on_logging_level)
-        end
-      end
-
-      def stop_transport
-        @transport&.close
-        @capabilities = nil
-        @transport = nil
-        @protocol_version = MCP::Protocol.default_negotiated_version
-      end
-
-      def restart_transport
-        @initialize_response = nil
-        stop_transport
-        start_transport
-      end
-
-      def alive?
-        !!@transport&.alive?
-      end
-
-      def ping
-        ping_request = RubyLLM::MCP::Requests::Ping.new(self)
-        if alive?
-          result = ping_request.call
-        else
-          transport.start
-
-          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
-        NotificationHandler.new(self).execute(notification)
-      end
-
-      def process_request(result)
-        ResponseHandler.new(self).execute(result)
-      end
-
-      def initialize_request
-        RubyLLM::MCP::Requests::Initialization.new(self).call
-      end
-
-      def tool_list(cursor: nil)
-        result = RubyLLM::MCP::Requests::ToolList.new(self, cursor: cursor).call
-        result.raise_error! if result.error?
-
-        if result.next_cursor?
-          result.value["tools"] + tool_list(cursor: result.next_cursor)
-        else
-          result.value["tools"]
-        end
-      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 register_resource(resource)
-        @client.linked_resources << resource
-        @client.resources[resource.name] = resource
-      end
-
-      def resource_list(cursor: nil)
-        result = RubyLLM::MCP::Requests::ResourceList.new(self, cursor: cursor).call
-        result.raise_error! if result.error?
-
-        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(cursor: nil)
-        result = RubyLLM::MCP::Requests::ResourceTemplateList.new(self, cursor: cursor).call
-        result.raise_error! if result.error?
-
-        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(cursor: nil)
-        result = RubyLLM::MCP::Requests::PromptList.new(self, cursor: cursor).call
-        result.raise_error! if result.error?
-
-        if result.next_cursor?
-          result.value["prompts"] + prompt_list(cursor: result.next_cursor)
-        else
-          result.value["prompts"]
-        end
-      end
-
-      def execute_prompt(**args)
-        RubyLLM::MCP::Requests::PromptCall.new(self, **args).call
-      end
-
-      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 set_logging(**args)
-        RubyLLM::MCP::Requests::LoggingSetLevel.new(self, **args).call
-      end
-
-      ## Notifications
-      #
-      def initialize_notification
-        RubyLLM::MCP::Notifications::Initialize.new(self).call
-      end
-
-      def cancelled_notification(**args)
-        RubyLLM::MCP::Notifications::Cancelled.new(self, **args).call
-      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 error_response(**args)
-        RubyLLM::MCP::Responses::Error.new(self, **args).call
-      end
-
-      def elicitation_response(**args)
-        RubyLLM::MCP::Responses::Elicitation.new(self, **args).call
-      end
-
-      def client_capabilities
-        capabilities = {}
-
-        if client.roots.active?
-          capabilities[:roots] = {
-            listChanged: true
-          }
-        end
-
-        if sampling_enabled?
-          capabilities[:sampling] = {}
-        end
-
-        if client.elicitation_enabled?
-          capabilities[:elicitation] = {}
-        end
-
-        capabilities
-      end
-
-      def transport
-        @transport ||= RubyLLM::MCP::Transport.new(@transport_type, self, config: @config)
-      end
-
-      # Get OAuth provider from transport if available
-      # @return [OAuthProvider, BrowserOAuthProvider, nil] OAuth provider or nil
-      def transport_oauth_provider
-        return nil unless @transport
-
-        transport_protocol = @transport.transport_protocol
-        return nil unless transport_protocol.respond_to?(:oauth_provider)
-
-        transport_protocol.oauth_provider
-      end
-
-      private
-
-      def sampling_enabled?
-        MCP.config.sampling.enabled?
-      end
-    end
-  end
-end

data/lib/ruby_llm/mcp/notifications/cancelled.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Notifications
-      class Cancelled
-        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/notifications/initialize.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Notifications
-      class Initialize
-        def initialize(coordinator)
-          @coordinator = coordinator
-        end
-
-        def call
-          @coordinator.request(notification_body, add_id: true, wait_for_response: false)
-        end
-
-        def notification_body
-          {
-            jsonrpc: "2.0",
-            method: "notifications/initialized"
-          }
-        end
-      end
-    end
-  end
-end

data/lib/ruby_llm/mcp/notifications/roots_list_change.rb

@@ -1,26 +0,0 @@
-# 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/protocol.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Protocol
-      module_function
-
-      LATEST_PROTOCOL_VERSION = "2025-06-18"
-      DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26"
-      SUPPORTED_PROTOCOL_VERSIONS = [
-        LATEST_PROTOCOL_VERSION,
-        "2025-03-26",
-        "2024-11-05",
-        "2024-10-07"
-      ].freeze
-
-      def supported_version?(version)
-        SUPPORTED_PROTOCOL_VERSIONS.include?(version)
-      end
-
-      def supported_versions
-        SUPPORTED_PROTOCOL_VERSIONS
-      end
-
-      def latest_version
-        LATEST_PROTOCOL_VERSION
-      end
-
-      def default_negotiated_version
-        DEFAULT_NEGOTIATED_PROTOCOL_VERSION
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class CompletionPrompt
-        def initialize(coordinator, name:, argument:, value:, context: nil)
-          @coordinator = coordinator
-          @name = name
-          @argument = argument
-          @value = value
-          @context = context
-        end
-
-        def call
-          @coordinator.request(request_body)
-        end
-
-        private
-
-        def request_body
-          {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "completion/complete",
-            params: {
-              ref: {
-                type: "ref/prompt",
-                name: @name
-              },
-              argument: {
-                name: @argument,
-                value: @value
-              },
-              context: format_context
-            }.compact
-          }
-        end
-
-        def format_context
-          return nil if @context.nil?
-
-          {
-            arguments: @context
-          }
-        end
-      end
-    end
-  end
-end

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

@@ -1,50 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class CompletionResource
-        def initialize(coordinator, uri:, argument:, value:, context: nil)
-          @coordinator = coordinator
-          @uri = uri
-          @argument = argument
-          @value = value
-          @context = context
-        end
-
-        def call
-          @coordinator.request(request_body)
-        end
-
-        private
-
-        def request_body
-          {
-            jsonrpc: "2.0",
-            id: 1,
-            method: "completion/complete",
-            params: {
-              ref: {
-                type: "ref/resource",
-                uri: @uri
-              },
-              argument: {
-                name: @argument,
-                value: @value
-              },
-              context: format_context
-            }.compact
-          }
-        end
-
-        def format_context
-          return nil if @context.nil?
-
-          {
-            arguments: @context
-          }
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,28 +0,0 @@
-# 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/ping.rb

@@ -1,24 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class Ping
-        def initialize(coordinator)
-          @coordinator = coordinator
-        end
-
-        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/prompt_call.rb

@@ -1,32 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Requests
-      class PromptCall
-        def initialize(coordinator, name:, arguments: {})
-          @coordinator = coordinator
-          @name = name
-          @arguments = arguments
-        end
-
-        def call
-          @coordinator.request(request_body)
-        end
-
-        private
-
-        def request_body
-          {
-            jsonrpc: "2.0",
-            method: "prompts/get",
-            params: {
-              name: @name,
-              arguments: @arguments
-            }
-          }
-        end
-      end
-    end
-  end
-end

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

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

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

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