ruby_llm-mcp 0.7.1 → 1.0.0

data/lib/ruby_llm/mcp/native/notification.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      class Notification
+        attr_reader :type, :params
+
+        def initialize(response)
+          @type = response["method"]
+          @params = response["params"]
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/native/protocol.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      module Protocol
+        module_function
+
+        LATEST_PROTOCOL_VERSION = "2025-11-25"
+        EXTENSIONS_PROTOCOL_VERSION = "2025-06-18"
+        DRAFT_PROTOCOL_VERSION = "2026-01-26"
+        DEFAULT_NEGOTIATED_PROTOCOL_VERSION = "2025-03-26"
+        SUPPORTED_PROTOCOL_VERSIONS = [
+          DRAFT_PROTOCOL_VERSION,
+          LATEST_PROTOCOL_VERSION,
+          EXTENSIONS_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 draft_version
+          DRAFT_PROTOCOL_VERSION
+        end
+
+        def default_negotiated_version
+          DEFAULT_NEGOTIATED_PROTOCOL_VERSION
+        end
+
+        def date_version?(value)
+          return false unless value.is_a?(String)
+
+          /\A\d{4}-\d{2}-\d{2}\z/.match?(value)
+        end
+
+        def compare_date_versions(version_a, version_b)
+          return nil unless date_version?(version_a) && date_version?(version_b)
+
+          Date.iso8601(version_a) <=> Date.iso8601(version_b)
+        rescue Date::Error
+          nil
+        end
+
+        def draft_or_newer?(version)
+          return false if version.nil?
+
+          normalized = version.to_s
+          return true if normalized.start_with?("DRAFT-")
+
+          comparison = compare_date_versions(normalized, DRAFT_PROTOCOL_VERSION)
+          !comparison.nil? && comparison >= 0
+        end
+
+        # Extensions are part of the stable protocol track from 2025-06-18 onward.
+        def extensions_supported?(version)
+          return false if version.nil?
+
+          normalized = version.to_s
+          return true if normalized.start_with?("DRAFT-")
+
+          comparison = compare_date_versions(normalized, EXTENSIONS_PROTOCOL_VERSION)
+          !comparison.nil? && comparison >= 0
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/native/response_handler.rb

@@ -0,0 +1,220 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      class ResponseHandler
+        attr_reader :coordinator
+
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def execute(result)
+          operation = CancellableOperation.new(result.id)
+          coordinator.register_in_flight_request(result.id, operation)
+          is_deferred = false
+
+          begin
+            # Execute in a separate thread that can be terminated on cancellation
+            operation.execute do
+              handled, deferred = dispatch_request(result)
+              is_deferred = deferred
+              handled
+            end
+          rescue Errors::RequestCancelled => e
+            RubyLLM::MCP.logger.info("Request #{result.id} was cancelled: #{e.message}")
+            # Don't send response - cancellation means result is unused
+            # Clean up if this was a deferred elicitation
+            Handlers::ElicitationRegistry.remove(result.id) if is_deferred
+            true
+          ensure
+            # Only unregister if not deferred (async operations stay registered)
+            coordinator.unregister_in_flight_request(result.id) unless is_deferred
+          end
+        end
+
+        private
+
+        def dispatch_request(result)
+          case result.method
+          when Native::Messages::METHOD_PING
+            coordinator.ping_response(id: result.id)
+            [true, false]
+          when "roots/list"
+            handle_roots_response(result)
+            [true, false]
+          when "sampling/createMessage"
+            handle_sampling_response(result)
+            [true, false]
+          when "elicitation/create"
+            [true, handle_elicitation_response(result)]
+          when Native::Messages::METHOD_TASKS_LIST
+            handle_tasks_list_response(result)
+            [true, false]
+          when Native::Messages::METHOD_TASKS_GET
+            handle_task_get_response(result)
+            [true, false]
+          when Native::Messages::METHOD_TASKS_RESULT
+            handle_task_result_response(result)
+            [true, false]
+          when Native::Messages::METHOD_TASKS_CANCEL
+            handle_task_cancel_response(result)
+            [true, false]
+          else
+            handle_unknown_request(result)
+            RubyLLM::MCP.logger.error("MCP client was sent unknown method type and \
+              could not respond: #{result.inspect}.")
+            [false, false]
+          end
+        end
+
+        def handle_roots_response(result)
+          RubyLLM::MCP.logger.info("Roots request: #{result.inspect}")
+          roots_paths = coordinator.roots_paths
+          if roots_paths&.any?
+            coordinator.roots_list_response(id: result.id)
+          else
+            coordinator.error_response(
+              id: result.id,
+              message: "Roots are not enabled",
+              code: Native::JsonRpc::ErrorCodes::SERVER_ERROR
+            )
+          end
+        rescue StandardError => e
+          RubyLLM::MCP.logger.error("Error in roots request: #{e.message}\n#{e.backtrace.join("\n")}")
+          coordinator.error_response(
+            id: result.id,
+            message: "Internal error processing roots request",
+            code: Native::JsonRpc::ErrorCodes::INTERNAL_ERROR,
+            data: { detail: e.message }
+          )
+        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: Native::JsonRpc::ErrorCodes::SERVER_ERROR
+            )
+            return
+          end
+
+          RubyLLM::MCP.logger.info("Sampling request: #{result.inspect}")
+          Sample.new(result, coordinator).execute
+        rescue StandardError => e
+          RubyLLM::MCP.logger.error("Error in sampling request: #{e.message}\n#{e.backtrace.join("\n")}")
+          coordinator.error_response(
+            id: result.id,
+            message: "Internal error processing sampling request",
+            code: Native::JsonRpc::ErrorCodes::INTERNAL_ERROR,
+            data: { detail: e.message }
+          )
+        end
+
+        def handle_elicitation_response(result)
+          RubyLLM::MCP.logger.info("Elicitation request: #{result.inspect}")
+          elicitation = Elicitation.new(coordinator, result)
+          elicitation.execute
+
+          # Return true if this elicitation is deferred (async)
+          elicitation.instance_variable_get(:@deferred)
+        rescue StandardError => e
+          RubyLLM::MCP.logger.error("Error in elicitation request: #{e.message}\n#{e.backtrace.join("\n")}")
+          coordinator.error_response(
+            id: result.id,
+            message: "Internal error processing elicitation request",
+            code: Native::JsonRpc::ErrorCodes::INTERNAL_ERROR,
+            data: { detail: e.message }
+          )
+          false
+        end
+
+        def handle_unknown_request(result)
+          coordinator.error_response(
+            id: result.id,
+            message: "Method not found: #{result.method}",
+            code: Native::JsonRpc::ErrorCodes::METHOD_NOT_FOUND
+          )
+        end
+
+        def handle_tasks_list_response(result)
+          coordinator.result_response(
+            id: result.id,
+            value: { tasks: coordinator.task_registry.tasks }
+          )
+        end
+
+        def handle_task_get_response(result)
+          task_id = result.params["taskId"]
+          return error_invalid_task_id(result.id) if task_id.nil? || task_id.empty?
+
+          task = coordinator.task_registry.task(task_id)
+          if task.nil?
+            error_unknown_task(result.id, task_id)
+          else
+            coordinator.result_response(id: result.id, value: task)
+          end
+        end
+
+        def handle_task_result_response(result)
+          task_id = result.params["taskId"]
+          return error_invalid_task_id(result.id) if task_id.nil? || task_id.empty?
+
+          payload = coordinator.task_registry.payload(task_id)
+          if payload.nil?
+            error_unknown_task(result.id, task_id)
+          else
+            coordinator.result_response(id: result.id, value: payload)
+          end
+        end
+
+        def handle_task_cancel_response(result)
+          task_id = result.params["taskId"]
+          return error_invalid_task_id(result.id) if task_id.nil? || task_id.empty?
+
+          task = coordinator.task_registry.update_status(
+            task_id,
+            status: "cancelled",
+            status_message: "Cancelled by server request"
+          )
+
+          coordinator.result_response(
+            id: result.id,
+            value: task || build_missing_task(task_id, "cancelled", "Task not found; treated as cancelled")
+          )
+        end
+
+        def error_invalid_task_id(request_id)
+          coordinator.error_response(
+            id: request_id,
+            message: "Invalid task request: taskId is required",
+            code: Native::JsonRpc::ErrorCodes::INVALID_PARAMS
+          )
+        end
+
+        def error_unknown_task(request_id, task_id)
+          coordinator.error_response(
+            id: request_id,
+            message: "Task not found: #{task_id}",
+            code: Native::JsonRpc::ErrorCodes::INVALID_PARAMS
+          )
+        end
+
+        def build_missing_task(task_id, status, status_message)
+          timestamp = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+          {
+            "taskId" => task_id,
+            "status" => status,
+            "statusMessage" => status_message,
+            "createdAt" => timestamp,
+            "lastUpdatedAt" => timestamp,
+            "ttl" => 0
+          }
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/native/task_registry.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      # In-memory task state cache used by the native client.
+      # This keeps task metadata/status synchronized across list/get/cancel calls
+      # and out-of-band status notifications.
+      class TaskRegistry
+        def initialize
+          @tasks = {}
+          @payloads = {}
+          @mutex = Mutex.new
+        end
+
+        def upsert(task_hash)
+          return if task_hash.nil? || task_hash["taskId"].nil?
+
+          @mutex.synchronize do
+            @tasks[task_hash["taskId"]] = task_hash
+          end
+        end
+
+        def upsert_many(task_hashes)
+          Array(task_hashes).each { |task| upsert(task) }
+        end
+
+        def store_payload(task_id, payload)
+          return if task_id.nil?
+
+          @mutex.synchronize do
+            @payloads[task_id] = payload
+          end
+        end
+
+        def task(task_id)
+          @mutex.synchronize { @tasks[task_id] }
+        end
+
+        def payload(task_id)
+          @mutex.synchronize { @payloads[task_id] }
+        end
+
+        def tasks
+          @mutex.synchronize { @tasks.values }
+        end
+
+        def update_status(task_id, status:, status_message: nil)
+          @mutex.synchronize do
+            task = @tasks[task_id]
+            return nil unless task
+
+            task["status"] = status
+            task["statusMessage"] = status_message unless status_message.nil?
+            task["lastUpdatedAt"] = Time.now.utc.strftime("%Y-%m-%dT%H:%M:%SZ")
+            task
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/native/transport.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      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::Native::Transports::SSE)
+        register_transport(:stdio, RubyLLM::MCP::Native::Transports::Stdio)
+        register_transport(:streamable, RubyLLM::MCP::Native::Transports::StreamableHTTP)
+        register_transport(:streamable_http, RubyLLM::MCP::Native::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_protocol = nil
+            @transport_protocol = build_transport
+          end
+
+          @transport_protocol ||= build_transport
+        end
+
+        private
+
+        def build_transport
+          unless RubyLLM::MCP::Native::Transport.transports.key?(transport_type)
+            supported_types = RubyLLM::MCP::Native::Transport.transports.keys.join(", ")
+            message = "Invalid transport type: :#{transport_type}. Supported types are #{supported_types}"
+            raise Errors::InvalidTransportType.new(message: message)
+          end
+
+          # Extract and merge options if present (from OAuth helper preparation)
+          transport_config = config.dup
+          if transport_config[:options]
+            options = transport_config.delete(:options)
+            transport_config.merge!(options)
+          end
+
+          # Handle SSE transport specially - it uses options hash pattern
+          if transport_type == :sse
+            url = transport_config.delete(:url) || transport_config.delete("url")
+            request_timeout = transport_config.delete(:request_timeout) ||
+                              transport_config.delete("request_timeout") ||
+                              MCP.config.request_timeout
+            # Everything else goes into options
+            options_hash = transport_config.dup
+            transport_config.clear
+            transport_config[:url] = url
+            transport_config[:request_timeout] = request_timeout
+            transport_config[:options] = options_hash
+          end
+
+          # Remove OAuth-specific params from transports that don't support them
+          # This allows other arbitrary params (like timeout) to pass through for testing
+          unless %i[streamable streamable_http sse].include?(transport_type)
+            transport_config.delete(:oauth_provider)
+            transport_config.delete(:oauth)
+          end
+
+          transport_klass = RubyLLM::MCP::Native::Transport.transports[transport_type]
+          transport_klass.new(coordinator: coordinator, **transport_config)
+        end
+      end
+    end
+  end
+end