ruby_llm_swarm-mcp 0.8.0 → 0.8.1

data/lib/ruby_llm/mcp/auth/transport_oauth_helper.rb

@@ -1,107 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Auth
-      # Helper module for preparing OAuth providers for transports
-      # This keeps OAuth logic out of the Native module while making it reusable
-      module TransportOauthHelper
-        module_function
-
-        # Check if OAuth configuration is present
-        # @param config [Hash] transport configuration hash
-        # @return [Boolean] true if OAuth config is present
-        def oauth_config_present?(config)
-          oauth_config = config[:oauth] || config["oauth"]
-          return false if oauth_config.nil?
-
-          # If it's an OAuth provider instance, it's present
-          return true if oauth_config.respond_to?(:access_token)
-
-          # If it's a hash, check if it's not empty
-          !oauth_config.empty?
-        end
-
-        # Create OAuth provider from configuration
-        # Accepts either a provider instance or a configuration hash
-        # @param config [Hash] transport configuration hash (will be modified)
-        # @return [OAuthProvider, BrowserOAuthProvider, nil] OAuth provider or nil
-        def create_oauth_provider(config)
-          oauth_config = config.delete(:oauth) || config.delete("oauth")
-          return nil unless oauth_config
-
-          # If provider key exists with an instance, use it
-          if oauth_config.is_a?(Hash) && (oauth_config[:provider] || oauth_config["provider"])
-            return oauth_config[:provider] || oauth_config["provider"]
-          end
-
-          # If oauth_config itself is a provider instance, use it directly
-          if oauth_config.respond_to?(:access_token) && oauth_config.respond_to?(:start_authorization_flow)
-            return oauth_config
-          end
-
-          # Otherwise create new provider from config hash
-          server_url = determine_server_url(config)
-          return nil unless server_url
-
-          redirect_uri = oauth_config[:redirect_uri] || oauth_config["redirect_uri"] || "http://localhost:8080/callback"
-          scope = oauth_config[:scope] || oauth_config["scope"]
-          storage = oauth_config[:storage] || oauth_config["storage"]
-          grant_type = oauth_config[:grant_type] || oauth_config["grant_type"] || :authorization_code
-
-          RubyLLM::MCP::Auth::OAuthProvider.new(
-            server_url: server_url,
-            redirect_uri: redirect_uri,
-            scope: scope,
-            logger: MCP.logger,
-            storage: storage,
-            grant_type: grant_type
-          )
-        end
-
-        # Determine server URL from transport config
-        # @param config [Hash] transport configuration hash
-        # @return [String, nil] server URL or nil
-        def determine_server_url(config)
-          config[:url] || config["url"]
-        end
-
-        # Prepare HTTP transport configuration with OAuth provider
-        # @param config [Hash] transport configuration hash (will be modified)
-        # @param oauth_provider [OAuthProvider, nil] OAuth provider instance
-        # @return [Hash] prepared configuration
-        def prepare_http_transport_config(config, oauth_provider)
-          options = {
-            version: config.delete(:version) || config.delete("version"),
-            headers: config.delete(:headers) || config.delete("headers"),
-            oauth_provider: oauth_provider,
-            reconnection: config.delete(:reconnection) || config.delete("reconnection"),
-            reconnection_options: config.delete(:reconnection_options) || config.delete("reconnection_options"),
-            rate_limit: config.delete(:rate_limit) || config.delete("rate_limit"),
-            session_id: config.delete(:session_id) || config.delete("session_id")
-          }.compact
-
-          config[:options] = options
-          config
-        end
-
-        # Prepare stdio transport configuration
-        # @param config [Hash] transport configuration hash (will be modified)
-        # @return [Hash] prepared configuration
-        def prepare_stdio_transport_config(config)
-          # Remove OAuth config from stdio transport (not supported)
-          config.delete(:oauth)
-          config.delete("oauth")
-
-          options = {
-            args: config.delete(:args) || config.delete("args"),
-            env: config.delete(:env) || config.delete("env")
-          }.compact
-
-          config[:options] = options unless options.empty?
-          config
-        end
-      end
-    end
-  end
-end

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

@@ -1,57 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Native
-      # Wraps server-initiated requests to support cancellation
-      # Executes the request in a separate thread that can be terminated on cancellation
-      class CancellableOperation
-        attr_reader :request_id, :thread
-
-        def initialize(request_id)
-          @request_id = request_id
-          @cancelled = false
-          @mutex = Mutex.new
-          @thread = nil
-          @result = nil
-          @error = nil
-        end
-
-        def cancelled?
-          @mutex.synchronize { @cancelled }
-        end
-
-        def cancel
-          @mutex.synchronize { @cancelled = true }
-          if @thread&.alive?
-            @thread.raise(Errors::RequestCancelled.new(
-                            message: "Request #{@request_id} was cancelled",
-                            request_id: @request_id
-                          ))
-          end
-        end
-
-        # Execute a block in a separate thread
-        # This allows the thread to be terminated if cancellation is requested
-        # Returns the result of the block or re-raises any error that occurred
-        def execute(&)
-          @thread = Thread.new do
-            Thread.current.abort_on_exception = false
-            begin
-              @result = yield
-            rescue Errors::RequestCancelled, StandardError => e
-              @error = e
-            end
-          end
-
-          @thread.join
-          raise @error if @error && !@error.is_a?(Errors::RequestCancelled)
-
-          @result
-        ensure
-          @thread = nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,387 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Native
-      # Native MCP protocol client implementation
-      # This is the core protocol implementation that handles all MCP operations
-      # It's self-contained and could potentially be extracted as a separate gem
-      class Client
-        attr_reader :name, :transport_type, :config, :capabilities, :protocol_version, :elicitation_callback,
-                    :sampling_callback
-
-        def initialize( # rubocop:disable Metrics/ParameterLists
-          name:,
-          transport_type:,
-          transport_config: {},
-          human_in_the_loop_callback: nil,
-          roots_callback: nil,
-          logging_enabled: false,
-          logging_level: nil,
-          elicitation_enabled: false,
-          elicitation_callback: nil,
-          progress_tracking_enabled: false,
-          sampling_callback: nil,
-          notification_callback: nil,
-          protocol_version: nil,
-          request_timeout: nil
-        )
-          @name = name
-          @transport_type = transport_type
-          @config = transport_config.merge(request_timeout: request_timeout || MCP.config.request_timeout)
-          @protocol_version = protocol_version || MCP.config.protocol_version || Native::Protocol.default_negotiated_version
-
-          # Callbacks
-          @human_in_the_loop_callback = human_in_the_loop_callback
-          @roots_callback = roots_callback
-          @logging_enabled = logging_enabled
-          @logging_level = logging_level
-          @elicitation_enabled = elicitation_enabled
-          @elicitation_callback = elicitation_callback
-          @progress_tracking_enabled = progress_tracking_enabled
-          @sampling_callback = sampling_callback
-          @notification_callback = notification_callback
-
-          @transport = nil
-          @capabilities = nil
-
-          # Track in-flight server-initiated requests for cancellation
-          @in_flight_requests = {}
-          @in_flight_mutex = Mutex.new
-        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
-          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 && !Native::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: #{Native::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 @logging_enabled && @logging_level
-            set_logging(level: @logging_level)
-          end
-        end
-
-        def stop
-          @transport&.close
-          @capabilities = nil
-          @transport = nil
-          @protocol_version = Native::Protocol.default_negotiated_version
-        end
-
-        def restart!
-          @initialize_response = nil
-          stop
-          start
-        end
-
-        def alive?
-          !!@transport&.alive?
-        end
-
-        def ping
-          body = Native::Messages::Requests.ping(tracking_progress: tracking_progress?)
-          if alive?
-            result = request(body)
-          else
-            transport.start
-
-            result = request(body)
-            @transport = nil
-          end
-
-          result.value == {}
-        rescue RubyLLM::MCP::Errors::TimeoutError, RubyLLM::MCP::Errors::TransportError
-          false
-        end
-
-        def process_notification(result)
-          notification = result.notification
-          @notification_callback&.call(notification)
-        end
-
-        def process_request(result)
-          Native::ResponseHandler.new(self).execute(result)
-        end
-
-        def initialize_request
-          body = Native::Messages::Requests.initialize(
-            protocol_version: protocol_version,
-            capabilities: client_capabilities
-          )
-          request(body)
-        end
-
-        def tool_list(cursor: nil)
-          body = Native::Messages::Requests.tool_list(cursor: cursor, tracking_progress: tracking_progress?)
-          result = request(body)
-          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(name:, parameters:)
-          if @human_in_the_loop_callback && !@human_in_the_loop_callback.call(name, parameters)
-            result = Result.new(
-              {
-                "result" => {
-                  "isError" => true,
-                  "content" => [{ "type" => "text", "text" => "Tool call was cancelled by the client" }]
-                }
-              }
-            )
-            return result
-          end
-
-          body = Native::Messages::Requests.tool_call(name: name, parameters: parameters,
-                                                      tracking_progress: tracking_progress?)
-          request(body)
-        end
-
-        def resource_list(cursor: nil)
-          body = Native::Messages::Requests.resource_list(cursor: cursor, tracking_progress: tracking_progress?)
-          result = request(body)
-          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(uri:)
-          body = Native::Messages::Requests.resource_read(uri: uri, tracking_progress: tracking_progress?)
-          request(body)
-        end
-
-        def resource_template_list(cursor: nil)
-          body = Native::Messages::Requests.resource_template_list(cursor: cursor,
-                                                                   tracking_progress: tracking_progress?)
-          result = request(body)
-          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(uri:)
-          body = Native::Messages::Requests.resources_subscribe(uri: uri, tracking_progress: tracking_progress?)
-          request(body, wait_for_response: false)
-        end
-
-        def prompt_list(cursor: nil)
-          body = Native::Messages::Requests.prompt_list(cursor: cursor, tracking_progress: tracking_progress?)
-          result = request(body)
-          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(name:, arguments:)
-          body = Native::Messages::Requests.prompt_call(name: name, arguments: arguments,
-                                                        tracking_progress: tracking_progress?)
-          request(body)
-        end
-
-        def completion_resource(uri:, argument:, value:, context: nil)
-          body = Native::Messages::Requests.completion_resource(uri: uri, argument: argument, value: value,
-                                                                context: context, tracking_progress: tracking_progress?)
-          request(body)
-        end
-
-        def completion_prompt(name:, argument:, value:, context: nil)
-          body = Native::Messages::Requests.completion_prompt(name: name, argument: argument, value: value,
-                                                              context: context, tracking_progress: tracking_progress?)
-          request(body)
-        end
-
-        def set_logging(level:)
-          body = Native::Messages::Requests.logging_set_level(level: level, tracking_progress: tracking_progress?)
-          request(body)
-        end
-
-        def set_progress_tracking(enabled:)
-          @progress_tracking_enabled = enabled
-        end
-
-        ## Notifications
-        #
-        def initialize_notification
-          body = Native::Messages::Notifications.initialized
-          request(body, wait_for_response: false)
-        end
-
-        def cancelled_notification(reason:, request_id:)
-          body = Native::Messages::Notifications.cancelled(request_id: request_id, reason: reason)
-          request(body, wait_for_response: false)
-        end
-
-        def roots_list_change_notification
-          body = Native::Messages::Notifications.roots_list_changed
-          request(body, wait_for_response: false)
-        end
-
-        ## Responses
-        #
-        def ping_response(id:)
-          body = Native::Messages::Responses.ping(id: id)
-          request(body, wait_for_response: false)
-        end
-
-        def roots_list_response(id:)
-          body = Native::Messages::Responses.roots_list(id: id, roots_paths: roots_paths)
-          request(body, wait_for_response: false)
-        end
-
-        def sampling_create_message_response(id:, model:, message:, **_options)
-          body = Native::Messages::Responses.sampling_create_message(id: id, model: model, message: message)
-          request(body, wait_for_response: false)
-        end
-
-        def error_response(id:, message:, code: Native::JsonRpc::ErrorCodes::SERVER_ERROR, data: nil)
-          body = Native::Messages::Responses.error(id: id, message: message, code: code, data: data)
-          request(body, wait_for_response: false)
-        end
-
-        def elicitation_response(id:, elicitation:)
-          body = Native::Messages::Responses.elicitation(id: id, action: elicitation[:action],
-                                                         content: elicitation[:content])
-          request(body, wait_for_response: false)
-        end
-
-        def client_capabilities
-          capabilities_hash = {}
-
-          if @roots_callback&.call&.any?
-            capabilities_hash[:roots] = {
-              listChanged: true
-            }
-          end
-
-          if MCP.config.sampling.enabled?
-            capabilities_hash[:sampling] = {}
-          end
-
-          if @elicitation_enabled
-            capabilities_hash[:elicitation] = {}
-          end
-
-          capabilities_hash
-        end
-
-        def roots_paths
-          @roots_callback&.call || []
-        end
-
-        def tracking_progress?
-          @progress_tracking_enabled
-        end
-
-        def sampling_callback_enabled?
-          !@sampling_callback.nil?
-        end
-
-        def transport
-          @transport ||= Native::Transport.new(@transport_type, self, config: @config)
-        end
-
-        # Register a server-initiated request that can be cancelled
-        # @param request_id [String] The ID of the request
-        # @param cancellable_operation [CancellableOperation, nil] The operation that can be cancelled
-        def register_in_flight_request(request_id, cancellable_operation = nil)
-          @in_flight_mutex.synchronize do
-            @in_flight_requests[request_id.to_s] = cancellable_operation
-          end
-        end
-
-        # Unregister a completed or cancelled request
-        # @param request_id [String] The ID of the request
-        def unregister_in_flight_request(request_id)
-          @in_flight_mutex.synchronize do
-            @in_flight_requests.delete(request_id.to_s)
-          end
-        end
-
-        # Cancel an in-flight server-initiated request
-        # @param request_id [String] The ID of the request to cancel
-        # @return [Boolean] true if the request was found and cancelled, false otherwise
-        def cancel_in_flight_request(request_id) # rubocop:disable Naming/PredicateMethod
-          operation = nil
-          @in_flight_mutex.synchronize do
-            operation = @in_flight_requests[request_id.to_s]
-          end
-
-          if operation.respond_to?(:cancel)
-            operation.cancel
-            true
-          else
-            RubyLLM::MCP.logger.warn("Request #{request_id} cannot be cancelled or was already completed")
-            false
-          end
-        end
-      end
-    end
-  end
-end