ruby_llm_swarm-mcp 0.8.0

data/lib/ruby_llm/mcp/client.rb

@@ -0,0 +1,401 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module RubyLLM
+  module MCP
+    class Client
+      extend Forwardable
+
+      attr_reader :name, :config, :transport_type, :request_timeout, :log_level, :on, :roots, :adapter,
+                  :on_logging_level
+      attr_accessor :linked_resources
+
+      def initialize(name:, transport_type:, sdk: nil, adapter: nil, start: true, # rubocop:disable Metrics/ParameterLists
+                     request_timeout: MCP.config.request_timeout, config: {})
+        @name = name
+        @transport_type = transport_type.to_sym
+        @adapter_type = adapter || sdk || MCP.config.default_adapter
+
+        # Validate early
+        MCP.config.adapter_config.validate!(
+          adapter: @adapter_type,
+          transport: @transport_type
+        )
+
+        @with_prefix = config.delete(:with_prefix) || false
+        @config = config.merge(request_timeout: request_timeout)
+        @request_timeout = request_timeout
+
+        # Store OAuth config for later use
+        @oauth_config = config[:oauth] || config["oauth"]
+        @oauth_provider = nil
+        @oauth_storage = nil
+
+        @on = {}
+        @tools = {}
+        @resources = {}
+        @resource_templates = {}
+        @prompts = {}
+
+        @log_level = nil
+
+        @linked_resources = []
+
+        # Build adapter based on configuration
+        @adapter = build_adapter
+
+        setup_roots if @adapter.supports?(:roots)
+        setup_sampling if @adapter.supports?(:sampling)
+        setup_event_handlers
+
+        @adapter.start if start
+      end
+
+      def_delegators :@adapter, :alive?, :capabilities, :ping, :client_capabilities,
+                     :register_in_flight_request, :unregister_in_flight_request,
+                     :cancel_in_flight_request
+
+      def start
+        @adapter.start
+      end
+
+      def stop
+        @adapter.stop
+      end
+
+      def restart!
+        @adapter.restart!
+      end
+
+      # Get or create OAuth provider for this client
+      # @param type [Symbol] OAuth provider type (:standard or :browser, defaults to :standard)
+      # @param options [Hash] additional options passed to provider
+      # @return [OAuthProvider, BrowserOAuthProvider] OAuth provider instance
+      def oauth(type: :standard, **options)
+        # Return existing provider if already created
+        return @oauth_provider if @oauth_provider
+
+        # Get provider from transport if it already exists
+        transport_oauth = transport_oauth_provider
+        return transport_oauth if transport_oauth
+
+        # Create new provider lazily
+        server_url = @config[:url] || @config["url"]
+        unless server_url
+          raise Errors::ConfigurationError.new(
+            message: "Cannot create OAuth provider without server URL in config"
+          )
+        end
+
+        oauth_options = {
+          server_url: server_url,
+          scope: @oauth_config&.dig(:scope) || @oauth_config&.dig("scope"),
+          storage: oauth_storage,
+          **options
+        }
+
+        @oauth_provider = Auth.create_oauth(
+          server_url,
+          type: type,
+          **oauth_options
+        )
+      end
+
+      def tools(refresh: false)
+        require_feature!(:tools)
+        return [] unless capabilities.tools_list?
+
+        fetch(:tools, refresh) do
+          tools = @adapter.tool_list
+          build_map(tools, MCP::Tool, with_prefix: @with_prefix)
+        end
+
+        @tools.values
+      end
+
+      def tool(name, refresh: false)
+        tools(refresh: refresh)
+
+        @tools[name]
+      end
+
+      def reset_tools!
+        @tools = {}
+      end
+
+      def resources(refresh: false)
+        require_feature!(:resources)
+        return [] unless capabilities.resources_list?
+
+        fetch(:resources, refresh) do
+          resources = @adapter.resource_list
+          resources = build_map(resources, MCP::Resource)
+          include_linked_resources(resources)
+        end
+
+        @resources.values
+      end
+
+      def resource(name, refresh: false)
+        resources(refresh: refresh)
+
+        @resources[name]
+      end
+
+      def reset_resources!
+        @resources = {}
+      end
+
+      def resource_templates(refresh: false)
+        require_feature!(:resource_templates)
+        return [] unless capabilities.resources_list?
+
+        fetch(:resource_templates, refresh) do
+          resource_templates = @adapter.resource_template_list
+          build_map(resource_templates, MCP::ResourceTemplate)
+        end
+
+        @resource_templates.values
+      end
+
+      def resource_template(name, refresh: false)
+        resource_templates(refresh: refresh)
+
+        @resource_templates[name]
+      end
+
+      def reset_resource_templates!
+        @resource_templates = {}
+      end
+
+      def prompts(refresh: false)
+        require_feature!(:prompts)
+        return [] unless capabilities.prompt_list?
+
+        fetch(:prompts, refresh) do
+          prompts = @adapter.prompt_list
+          build_map(prompts, MCP::Prompt)
+        end
+
+        @prompts.values
+      end
+
+      def prompt(name, refresh: false)
+        prompts(refresh: refresh)
+
+        @prompts[name]
+      end
+
+      def reset_prompts!
+        @prompts = {}
+      end
+
+      def tracking_progress?
+        @on.key?(:progress) && !@on[:progress].nil?
+      end
+
+      def on_progress(&block)
+        require_feature!(:progress_tracking)
+        if alive?
+          @adapter.set_progress_tracking(enabled: true)
+        end
+
+        @on[:progress] = block
+        self
+      end
+
+      def human_in_the_loop?
+        @on.key?(:human_in_the_loop) && !@on[:human_in_the_loop].nil?
+      end
+
+      def on_human_in_the_loop(&block)
+        require_feature!(:human_in_the_loop)
+        @on[:human_in_the_loop] = block
+        self
+      end
+
+      def logging_handler_enabled?
+        @on.key?(:logging) && !@on[:logging].nil?
+      end
+
+      def logging_enabled?
+        !@log_level.nil?
+      end
+
+      def on_logging(level: Logging::WARNING, &block)
+        require_feature!(:logging)
+        @on_logging_level = level
+        if alive?
+          @adapter.set_logging(level: level)
+        end
+
+        @on[:logging] = block
+        self
+      end
+
+      def sampling_callback_enabled?
+        @on.key?(:sampling) && !@on[:sampling].nil?
+      end
+
+      def on_sampling(&block)
+        require_feature!(:sampling)
+        @on[:sampling] = block
+        self
+      end
+
+      def elicitation_enabled?
+        @on.key?(:elicitation) && !@on[:elicitation].nil?
+      end
+
+      def on_elicitation(&block)
+        require_feature!(:elicitation)
+        @on[:elicitation] = block
+        self
+      end
+
+      def to_h
+        {
+          name: @name,
+          transport_type: @transport_type,
+          request_timeout: @request_timeout,
+          start: @start,
+          config: @config,
+          on: @on,
+          tools: @tools,
+          resources: @resources,
+          resource_templates: @resource_templates,
+          prompts: @prompts,
+          log_level: @log_level
+        }
+      end
+
+      alias as_json to_h
+
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} #{to_h.map { |k, v| "#{k}: #{v}" }.join(', ')}>"
+      end
+
+      private
+
+      # Get OAuth provider from adapter's transport if available
+      # @return [OAuthProvider, BrowserOAuthProvider, nil] OAuth provider or nil
+      def transport_oauth_provider
+        return nil unless @adapter
+
+        # For RubyLLMAdapter
+        if @adapter.respond_to?(:native_client)
+          transport = @adapter.native_client.transport
+          transport_protocol = transport.transport_protocol
+          return transport_protocol.oauth_provider if transport_protocol.respond_to?(:oauth_provider)
+        end
+
+        # For MCPSdkAdapter with wrapped transports
+        if @adapter.respond_to?(:mcp_client) && @adapter.instance_variable_get(:@mcp_client)
+          mcp_client = @adapter.instance_variable_get(:@mcp_client)
+          if mcp_client&.transport.respond_to?(:native_transport)
+            return mcp_client.transport.native_transport.oauth_provider
+          end
+        end
+
+        nil
+      end
+
+      def build_adapter
+        case @adapter_type
+        when :ruby_llm
+          RubyLLM::MCP::Adapters::RubyLLMAdapter.new(self,
+                                                     transport_type: @transport_type,
+                                                     config: @config)
+        when :mcp_sdk
+          RubyLLM::MCP::Adapters::MCPSdkAdapter.new(self,
+                                                    transport_type: @transport_type,
+                                                    config: @config)
+        else
+          raise ArgumentError, "Unknown adapter type: #{@adapter_type}"
+        end
+      end
+
+      def require_feature!(feature)
+        unless @adapter.supports?(feature)
+          raise Errors::UnsupportedFeature.new(
+            message: <<~MSG.strip
+              Feature '#{feature}' is not supported by the #{@adapter_type} adapter.
+
+              This feature requires the :ruby_llm adapter.
+              Change your configuration to use adapter: :ruby_llm
+            MSG
+          )
+        end
+      end
+
+      def fetch(cache_key, refresh)
+        instance_variable_set("@#{cache_key}", {}) if refresh
+        if instance_variable_get("@#{cache_key}").empty?
+          instance_variable_set("@#{cache_key}", yield)
+        end
+        instance_variable_get("@#{cache_key}")
+      end
+
+      def build_map(raw_data, klass, with_prefix: false)
+        raw_data.each_with_object({}) do |item, acc|
+          instance = if with_prefix
+                       klass.new(@adapter, item, with_prefix: @with_prefix)
+                     else
+                       klass.new(@adapter, item)
+                     end
+          acc[instance.name] = instance
+        end
+      end
+
+      def include_linked_resources(resources)
+        @linked_resources.each do |resource|
+          resources[resource.name] = resource
+        end
+
+        resources
+      end
+
+      def setup_roots
+        @roots = Roots.new(paths: MCP.config.roots, adapter: @adapter)
+      end
+
+      def setup_sampling
+        @on[:sampling] = MCP.config.sampling.guard
+      end
+
+      def setup_event_handlers
+        # Only setup handlers that are supported
+        if @adapter.supports?(:progress_tracking)
+          @on[:progress] = MCP.config.on_progress
+          if @on[:progress] && alive?
+            @adapter.set_progress_tracking(enabled: true)
+          end
+        end
+
+        if @adapter.supports?(:human_in_the_loop)
+          @on[:human_in_the_loop] = MCP.config.on_human_in_the_loop
+        end
+
+        if @adapter.supports?(:logging)
+          @on[:logging] = MCP.config.on_logging
+          @on_logging_level = MCP.config.on_logging_level
+        end
+
+        if @adapter.supports?(:elicitation)
+          @on[:elicitation] = MCP.config.on_elicitation
+        end
+      end
+
+      # Get or create OAuth storage shared with transport
+      def oauth_storage
+        # Try to get storage from transport's OAuth provider
+        transport_oauth = transport_oauth_provider
+        return transport_oauth.storage if transport_oauth
+
+        # Create new storage shared with client
+        @oauth_storage ||= Auth::MemoryStorage.new
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/completion.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Completion
+      attr_reader :argument, :values, :total, :has_more
+
+      def initialize(argument:, values:, total:, has_more:)
+        @argument = argument
+        @values = values
+        @total = total
+        @has_more = has_more
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/configuration.rb

@@ -0,0 +1,310 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Configuration
+      class AdapterConfig
+        VALID_ADAPTERS = %i[ruby_llm mcp_sdk].freeze
+        VALID_TRANSPORTS = %i[stdio sse streamable streamable_http http].freeze
+
+        attr_accessor :default_adapter
+
+        def initialize
+          @default_adapter = :ruby_llm
+        end
+
+        def validate!(adapter:, transport:)
+          validate_adapter!(adapter)
+          validate_transport!(transport)
+          validate_adapter_transport_combination!(adapter, transport)
+        end
+
+        def adapter_for(config)
+          config[:sdk] || config[:adapter] || @default_adapter
+        end
+
+        private
+
+        def validate_adapter!(adapter)
+          unless VALID_ADAPTERS.include?(adapter)
+            raise Errors::AdapterConfigurationError.new(
+              message: "Invalid adapter '#{adapter}'. Valid options: #{VALID_ADAPTERS.join(', ')}"
+            )
+          end
+        end
+
+        def validate_transport!(transport)
+          unless VALID_TRANSPORTS.include?(transport)
+            raise Errors::AdapterConfigurationError.new(
+              message: "Invalid transport '#{transport}'. Valid options: #{VALID_TRANSPORTS.join(', ')}"
+            )
+          end
+        end
+
+        def validate_adapter_transport_combination!(adapter, transport)
+          # SSE is supported by both ruby_llm and mcp_sdk adapters
+          # No validation needed at this time
+        end
+      end
+
+      class Sampling
+        attr_accessor :enabled
+        attr_writer :preferred_model
+
+        def initialize
+          set_defaults
+        end
+
+        def reset!
+          set_defaults
+        end
+
+        def guard(&block)
+          @guard = block if block_given?
+          @guard
+        end
+
+        def preferred_model(&block)
+          @preferred_model = block if block_given?
+          @preferred_model
+        end
+
+        def enabled?
+          @enabled
+        end
+
+        private
+
+        def set_defaults
+          @enabled = false
+          @preferred_model = nil
+          @guard = nil
+        end
+      end
+
+      class OAuth
+        attr_accessor :client_name,
+                      :client_uri,
+                      :software_id,
+                      :software_version,
+                      :logo_uri,
+                      :contacts,
+                      :tos_uri,
+                      :policy_uri,
+                      :jwks_uri,
+                      :jwks,
+                      :browser_success_page,
+                      :browser_error_page
+
+        def initialize
+          @client_name = "RubyLLM MCP Client"
+          @client_uri = nil
+          @software_id = "ruby_llm-mcp"
+          @software_version = RubyLLM::MCP::VERSION
+          @logo_uri = nil
+          @contacts = nil
+          @tos_uri = nil
+          @policy_uri = nil
+          @jwks_uri = nil
+          @jwks = nil
+          @browser_success_page = nil
+          @browser_error_page = nil
+        end
+      end
+
+      class ConfigFile
+        attr_reader :file_path
+
+        def initialize(file_path)
+          @file_path = file_path
+        end
+
+        def parse
+          @parse ||= if @file_path && File.exist?(@file_path)
+                       config = parse_config_file
+                       load_mcps_config(config)
+                     else
+                       []
+                     end
+        end
+
+        private
+
+        def parse_config_file
+          output = ERB.new(File.read(@file_path)).result
+
+          if [".yaml", ".yml"].include?(File.extname(@file_path))
+            YAML.safe_load(output, symbolize_names: true)
+          else
+            JSON.parse(output, symbolize_names: true)
+          end
+        end
+
+        def load_mcps_config(config)
+          return [] unless config.key?(:mcp_servers)
+
+          config[:mcp_servers].map do |name, configuration|
+            {
+              name: name,
+              transport_type: configuration.delete(:transport_type),
+              start: false,
+              config: configuration
+            }
+          end
+        end
+      end
+
+      attr_accessor :request_timeout,
+                    :log_file,
+                    :log_level,
+                    :roots,
+                    :sampling,
+                    :max_connections,
+                    :pool_timeout,
+                    :protocol_version,
+                    :config_path,
+                    :launch_control,
+                    :on_logging_level,
+                    :adapter_config,
+                    :oauth
+
+      attr_writer :logger, :mcp_configuration
+
+      REQUEST_TIMEOUT_DEFAULT = 8000
+
+      def initialize
+        @sampling = Sampling.new
+        @adapter_config = AdapterConfig.new
+        @oauth = OAuth.new
+        set_defaults
+      end
+
+      def reset!
+        set_defaults
+      end
+
+      def logger
+        @logger ||= Logger.new(
+          log_file,
+          progname: "RubyLLM::MCP",
+          level: log_level
+        )
+      end
+
+      # Convenience method for setting default adapter
+      def default_adapter=(adapter)
+        @adapter_config.default_adapter = adapter
+      end
+
+      def default_adapter
+        @adapter_config.default_adapter
+      end
+
+      # Validate MCP configuration before use
+      def mcp_configuration
+        configs = @mcp_configuration + load_mcps_config
+        validate_configurations!(configs)
+        configs
+      end
+
+      def on_progress(&block)
+        @on_progress = block if block_given?
+        @on_progress
+      end
+
+      def on_human_in_the_loop(&block)
+        @on_human_in_the_loop = block if block_given?
+        @on_human_in_the_loop
+      end
+
+      def on_logging(&block)
+        @on_logging = block if block_given?
+        @on_logging
+      end
+
+      def on_elicitation(&block)
+        @on_elicitation = block if block_given?
+        @on_elicitation
+      end
+
+      def inspect
+        redacted = lambda do |name, value|
+          if name.match?(/_id|_key|_secret|_token$/)
+            value.nil? ? "nil" : "[FILTERED]"
+          else
+            value
+          end
+        end
+
+        inspection = instance_variables.map do |ivar|
+          name = ivar.to_s.delete_prefix("@")
+          value = redacted[name, instance_variable_get(ivar)]
+          "#{name}: #{value}"
+        end.join(", ")
+
+        "#<#{self.class}:0x#{object_id.to_s(16)} #{inspection}>"
+      end
+
+      private
+
+      def validate_configurations!(configs)
+        configs.each do |config|
+          adapter = @adapter_config.adapter_for(config)
+          transport = config[:transport_type]
+          # Convert string to symbol if needed
+          transport = transport.to_sym if transport.is_a?(String)
+
+          @adapter_config.validate!(
+            adapter: adapter,
+            transport: transport
+          )
+        end
+      end
+
+      def load_mcps_config
+        @config_file ||= ConfigFile.new(config_path)
+        @config_file.parse
+      end
+
+      def set_defaults
+        # Connection configuration
+        @request_timeout = REQUEST_TIMEOUT_DEFAULT
+
+        # Connection Pool
+        @max_connections = Float::INFINITY
+        @pool_timeout = 5
+
+        # Logging configuration
+        @log_file = $stdout
+        @log_level = ENV["RUBYLLM_MCP_DEBUG"] ? Logger::DEBUG : Logger::INFO
+        @logger = nil
+
+        # MCPs configuration
+        @mcps_config_path = nil
+        @mcp_configuration = []
+
+        # Rails specific configuration
+        @launch_control = :automatic
+
+        # Roots configuration
+        @roots = []
+
+        # Protocol configuration
+        @protocol_version = Native::Protocol.latest_version
+
+        # OAuth configuration
+        @oauth = OAuth.new
+
+        # Sampling configuration
+        @sampling.reset!
+
+        # Event handlers
+        @on_progress = nil
+        @on_human_in_the_loop = nil
+        @on_elicitation = nil
+        @on_logging_level = nil
+        @on_logging = nil
+      end
+    end
+  end
+end