ruby_llm_swarm-mcp 0.8.0

data/lib/ruby_llm/mcp/result.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Notification
+      attr_reader :type, :params
+
+      def initialize(response)
+        @type = response["method"]
+        @params = response["params"]
+      end
+    end
+
+    class Result
+      attr_reader :response, :session_id, :id, :method, :result, :params, :error, :next_cursor
+
+      REQUEST_METHODS = {
+        ping: "ping",
+        roots: "roots/list",
+        sampling: "sampling/createMessage",
+        elicitation: "elicitation/create"
+      }.freeze
+
+      def initialize(response, session_id: nil)
+        @response = response
+        @session_id = session_id
+        @id = response["id"]
+        @method = response["method"]
+        @result = response["result"] || {}
+        @params = response["params"] || {}
+        @error = response["error"] || {}
+
+        @result_is_error = response.dig("result", "isError") || false
+        @next_cursor = response.dig("result", "nextCursor")
+
+        # Track whether result/error keys exist (for JSON-RPC detection)
+        @has_result = response.key?("result")
+        @has_error = response.key?("error")
+      end
+
+      REQUEST_METHODS.each do |method_name, method_value|
+        define_method "#{method_name}?" do
+          @method == method_value
+        end
+      end
+
+      alias value result
+
+      def notification
+        Notification.new(@response)
+      end
+
+      def to_error
+        Error.new(@error)
+      end
+
+      def execution_error?
+        @result_is_error
+      end
+
+      def raise_error!
+        error = to_error
+        message = "Response error: #{error}"
+        raise Errors::ResponseError.new(message: message, error: error)
+      end
+
+      def matching_id?(request_id)
+        @id&.to_s == request_id.to_s
+      end
+
+      def notification?
+        @id.nil? && !@method.nil?
+      end
+
+      def next_cursor?
+        !@next_cursor.nil?
+      end
+
+      def request?
+        !@id.nil? && !@method.nil?
+      end
+
+      def response?
+        !@id.nil? && @method.nil? && (@has_result || @has_error)
+      end
+
+      def success?
+        @has_result
+      end
+
+      def tool_success?
+        success? && !@result_is_error
+      end
+
+      def error?
+        !@error.empty?
+      end
+
+      def to_s
+        inspect
+      end
+
+      def inspect
+        "#<#{self.class.name}:0x#{object_id.to_s(16)} id: #{@id}, result: #{@result}, error: #{@error}, method: #{@method}, params: #{@params}>" # rubocop:disable Layout/LineLength
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/roots.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Roots
+      attr_reader :paths
+
+      def initialize(paths: [], adapter: nil)
+        @paths = paths
+        @adapter = adapter
+      end
+
+      def active?
+        @paths.any?
+      end
+
+      def add(path)
+        @paths << path
+        @adapter.roots_list_change_notification
+      end
+
+      def remove(path)
+        @paths.delete(path)
+        @adapter.roots_list_change_notification
+      end
+
+      def to_request
+        @paths.map do |path|
+          name = File.basename(path, ".*")
+
+          {
+            uri: "file://#{path}",
+            name: name
+          }
+        end
+      end
+
+      def to_h
+        {
+          paths: to_request
+        }
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/sample.rb

@@ -0,0 +1,152 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Sample
+      class Hint
+        attr_reader :model, :cost_priority, :speed_priority, :intelligence_priority
+
+        def initialize(model, model_preferences)
+          @model = model
+          @model_preferences = model_preferences
+
+          @hints = model_preferences&.fetch("hints", [])
+          @cost_priority = model_preferences&.fetch("costPriority", nil)
+          @speed_priority = model_preferences&.fetch("speedPriority", nil)
+          @intelligence_priority = model_preferences&.fetch("intelligencePriority", nil)
+        end
+
+        def hints
+          @hints.map { |hint| hint["name"] }
+        end
+
+        def to_h
+          {
+            model: model,
+            hints: hints,
+            cost_priority: @cost_priority,
+            speed_priority: @speed_priority,
+            intelligence_priority: @intelligence_priority
+          }
+        end
+      end
+
+      REJECTED_MESSAGE = "Sampling request was rejected"
+
+      attr_reader :model_preferences, :system_prompt, :max_tokens, :raw_messages
+
+      def initialize(result, coordinator)
+        params = result.params
+        @id = result.id
+        @coordinator = coordinator
+
+        @raw_messages = params["messages"] || []
+        @model_preferences = Hint.new(params["model"], params["modelPreferences"])
+        @system_prompt = params["systemPrompt"]
+        @max_tokens = params["maxTokens"]
+      end
+
+      def execute
+        return unless callback_guard_success?
+
+        model = preferred_model
+        return unless model
+
+        chat_message = chat(model)
+        @coordinator.sampling_create_message_response(
+          id: @id, message: chat_message, model: model
+        )
+      end
+
+      def message
+        @message ||= raw_messages.map { |message| message.fetch("content")&.fetch("text") }.join("\n")
+      end
+
+      def to_h
+        {
+          id: @id,
+          model_preferences: @model_preferences.to_h,
+          system_prompt: @system_prompt,
+          max_tokens: @max_tokens
+        }
+      end
+
+      alias to_json to_h
+
+      private
+
+      def callback_guard_success?
+        return true unless @coordinator.sampling_callback_enabled?
+
+        callback_result = @coordinator.sampling_callback&.call(self)
+        # If callback returns nil, it means no guard was configured - allow it
+        return true if callback_result.nil?
+
+        unless callback_result
+          @coordinator.error_response(id: @id, message: REJECTED_MESSAGE)
+          return false
+        end
+
+        true
+      rescue StandardError => e
+        RubyLLM::MCP.logger.error("Error in callback guard: #{e.message}, #{e.backtrace.join("\n")}")
+        @coordinator.error_response(id: @id, message: "Error executing sampling request")
+        false
+      end
+
+      def chat(model)
+        chat = RubyLLM::Chat.new(
+          model: model
+        )
+        if system_prompt
+          formated_system_message = create_message(system_message)
+          chat.add_message(formated_system_message)
+        end
+        raw_messages.each { |message| chat.add_message(create_message(message)) }
+
+        chat.complete
+      end
+
+      def preferred_model
+        @preferred_model ||= begin
+          model = RubyLLM::MCP.config.sampling.preferred_model
+          if model.respond_to?(:call)
+            model.call(model_preferences)
+          else
+            model
+          end
+        end
+      rescue StandardError => e
+        RubyLLM::MCP.logger.error("Error in preferred model: #{e.message}, #{e.backtrace.join("\n")}")
+        @coordinator.error_response(id: @id, message: "Failed to determine preferred model: #{e.message}")
+        false
+      end
+
+      def create_message(message)
+        role = message["role"]
+        content = create_content_for_message(message["content"])
+
+        RubyLLM::Message.new({ role: role, content: content })
+      end
+
+      def create_content_for_message(content)
+        case content["type"]
+        when "text"
+          MCP::Content.new(text: content["text"])
+        when "image", "audio"
+          attachment = MCP::Attachment.new(content["data"], content["mimeType"])
+          MCP::Content.new(text: nil, attachments: [attachment])
+        else
+          raise RubyLLM::MCP::Errors::InvalidFormatError.new(message: "Invalid content type: #{content['type']}")
+        end
+      end
+
+      def system_message
+        {
+          "role" => "system",
+          "content" => { "type" => "text", "text" => system_prompt }
+        }
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/server_capabilities.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class ServerCapabilities
+      attr_accessor :capabilities
+
+      def initialize(capabilities = {})
+        @capabilities = capabilities
+      end
+
+      def resources_list?
+        !@capabilities["resources"].nil?
+      end
+
+      def resources_list_changes?
+        @capabilities.dig("resources", "listChanged") || false
+      end
+
+      def resource_subscribe?
+        @capabilities.dig("resources", "subscribe") || false
+      end
+
+      def tools_list?
+        !@capabilities["tools"].nil?
+      end
+
+      def tools_list_changes?
+        @capabilities.dig("tools", "listChanged") || false
+      end
+
+      def prompt_list?
+        !@capabilities["prompts"].nil?
+      end
+
+      def prompt_list_changes?
+        @capabilities.dig("prompts", "listChanged") || false
+      end
+
+      def completion?
+        !@capabilities["completions"].nil?
+      end
+
+      def logging?
+        !@capabilities["logging"].nil?
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/tool.rb

@@ -0,0 +1,228 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Annotation
+      attr_reader :title, :read_only_hint, :destructive_hint, :idempotent_hint, :open_world_hint
+
+      def initialize(annotation)
+        @title = annotation["title"] || ""
+        @read_only_hint = annotation["readOnlyHint"] || false
+        @destructive_hint = annotation["destructiveHint"] || true
+        @idempotent_hint = annotation["idempotentHint"] || false
+        @open_world_hint = annotation["openWorldHint"] || true
+      end
+
+      def to_h
+        {
+          title: @title,
+          readOnlyHint: @read_only_hint,
+          destructiveHint: @destructive_hint,
+          idempotentHint: @idempotent_hint,
+          openWorldHint: @open_world_hint
+        }
+      end
+    end
+
+    class Tool < RubyLLM::Tool
+      attr_reader :name, :title, :description, :adapter, :annotations, :tool_response, :with_prefix
+
+      def initialize(adapter, tool_response, with_prefix: false)
+        super()
+        @adapter = adapter
+
+        @with_prefix = with_prefix
+        @name = format_name(tool_response["name"])
+        @mcp_name = tool_response["name"]
+        @description = tool_response["description"].to_s
+
+        @input_schema = tool_response["inputSchema"]
+        @output_schema = tool_response["outputSchema"]
+
+        @annotations = tool_response["annotations"] ? Annotation.new(tool_response["annotations"]) : nil
+
+        @normalized_input_schema = normalize_if_invalid(@input_schema)
+      end
+
+      def display_name
+        "#{@adapter.client.name}: #{@name}"
+      end
+
+      def params_schema
+        @normalized_input_schema
+      end
+
+      def execute(**params)
+        result = @adapter.execute_tool(
+          name: @mcp_name,
+          parameters: params
+        )
+
+        if result.error?
+          error = result.to_error
+          return { error: error.to_s }
+        end
+
+        text_values = result.value["content"].map { |content| content["text"] }.compact.join("\n")
+        if result.execution_error?
+          return { error: "Tool execution error: #{text_values}" }
+        end
+
+        if result.value.key?("structuredContent") && !@output_schema.nil?
+          is_valid = JSON::Validator.validate(@output_schema, result.value["structuredContent"])
+          unless is_valid
+            return { error: "Structued outputs was not invalid: #{result.value['structuredContent']}" }
+          end
+
+          return text_values
+        end
+
+        if text_values.empty?
+          create_content_for_message(result.value.dig("content", 0))
+        else
+          create_content_for_message({ "type" => "text", "text" => text_values })
+        end
+      end
+
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          params_schema: @@normalized_input_schema,
+          annotations: @annotations&.to_h
+        }
+      end
+
+      alias to_json to_h
+
+      private
+
+      def create_content_for_message(content)
+        case content["type"]
+        when "text"
+          MCP::Content.new(text: content["text"])
+        when "image", "audio"
+          attachment = MCP::Attachment.new(content["data"], content["mimeType"])
+          MCP::Content.new(text: nil, attachments: [attachment])
+        when "resource"
+          resource_data = {
+            "name" => name,
+            "description" => description,
+            "uri" => content.dig("resource", "uri"),
+            "mimeType" => content.dig("resource", "mimeType"),
+            "content_response" => {
+              "text" => content.dig("resource", "text"),
+              "blob" => content.dig("resource", "blob")
+            }
+          }
+
+          resource = Resource.new(adapter, resource_data)
+          resource.to_content
+        when "resource_link"
+          resource_data = {
+            "name" => content["name"],
+            "uri" => content["uri"],
+            "description" => content["description"],
+            "mimeType" => content["mimeType"]
+          }
+
+          resource = Resource.new(adapter, resource_data)
+          @adapter.register_resource(resource)
+          resource.to_content
+        end
+      end
+
+      def format_name(name)
+        if @with_prefix
+          "#{@adapter.client.name}_#{name}"
+        else
+          name
+        end
+      end
+
+      def normalize_schema(schema)
+        return schema if schema.nil?
+
+        case schema
+        when Hash
+          normalize_hash_schema(schema)
+        when Array
+          normalize_array_schema(schema)
+        else
+          schema
+        end
+      end
+
+      def normalize_hash_schema(schema)
+        normalized = schema.transform_values { |value| normalize_schema_value(value) }
+        ensure_object_properties(normalized)
+        normalized
+      end
+
+      def normalize_array_schema(schema)
+        schema.map { |item| normalize_schema_value(item) }
+      end
+
+      def normalize_schema_value(value)
+        case value
+        when Hash
+          normalize_schema(value)
+        when Array
+          normalize_array_schema(value)
+        else
+          value
+        end
+      end
+
+      def ensure_object_properties(schema)
+        if schema["type"] == "object" && !schema.key?("properties")
+          schema["properties"] = {}
+        end
+      end
+
+      def normalize_if_invalid(schema)
+        return schema if schema.nil?
+
+        if valid_schema?(schema)
+          schema
+        else
+          normalize_schema(schema)
+        end
+      end
+
+      def valid_schema?(schema)
+        return true if schema.nil?
+
+        case schema
+        when Hash
+          valid_hash_schema?(schema)
+        when Array
+          schema.all? { |item| valid_schema?(item) }
+        else
+          true
+        end
+      end
+
+      def valid_hash_schema?(schema)
+        # Check if this level has missing properties for object type
+        if schema["type"] == "object" && !schema.key?("properties")
+          return false
+        end
+
+        # Recursively check nested schemas
+        schema.each_value do |value|
+          return false unless valid_schema?(value)
+        end
+
+        begin
+          JSON::Validator.validate!(schema, {})
+          true
+        rescue JSON::Schema::SchemaError
+          false
+        rescue JSON::Schema::ValidationError
+          true
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/version.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    VERSION = "0.8.0"
+  end
+end

data/lib/ruby_llm/mcp.rb

@@ -0,0 +1,125 @@
+# frozen_string_literal: true
+
+# Standard Libraries
+require "cgi"
+require "erb"
+require "json"
+require "logger"
+require "open3"
+require "rbconfig"
+require "securerandom"
+require "socket"
+require "timeout"
+require "uri"
+require "yaml"
+
+# Gems
+require "httpx"
+require "json-schema"
+require "ruby_llm"
+require "zeitwerk"
+
+require_relative "chat"
+
+module RubyLLM
+  module MCP
+    module_function
+
+    def clients(config = RubyLLM::MCP.config.mcp_configuration)
+      if @clients.nil?
+        @clients = {}
+        config.map do |options|
+          @clients[options[:name]] ||= Client.new(**options)
+        end
+      end
+      @clients
+    end
+
+    def add_client(options)
+      clients[options[:name]] ||= Client.new(**options)
+    end
+
+    def remove_client(name)
+      client = clients.delete(name)
+      client&.stop
+      client
+    end
+
+    def client(...)
+      Client.new(...)
+    end
+
+    def establish_connection(&)
+      clients.each_value(&:start)
+      if block_given?
+        begin
+          yield clients
+        ensure
+          close_connection
+        end
+      else
+        clients
+      end
+    end
+
+    def close_connection
+      clients.each_value do |client|
+        client.stop if client.alive?
+      end
+    end
+
+    def tools(blacklist: [], whitelist: [])
+      tools = @clients.values.map(&:tools)
+                      .flatten
+                      .reject { |tool| blacklist.include?(tool.name) }
+
+      tools = tools.select { |tool| whitelist.include?(tool.name) } if whitelist.any?
+      tools.uniq(&:name)
+    end
+
+    def mcp_configurations
+      config.mcp_configuration.each_with_object({}) do |config, acc|
+        acc[config[:name]] = config
+      end
+    end
+
+    def configure
+      yield config
+    end
+
+    def config
+      @config ||= Configuration.new
+    end
+
+    alias configuration config
+    module_function :configuration
+
+    def logger
+      config.logger
+    end
+  end
+end
+
+loader = Zeitwerk::Loader.for_gem_extension(RubyLLM)
+
+loader.ignore("#{__dir__}/mcp/railtie.rb")
+
+loader.inflector.inflect("mcp" => "MCP")
+loader.inflector.inflect("sse" => "SSE")
+loader.inflector.inflect("openai" => "OpenAI")
+loader.inflector.inflect("streamable_http" => "StreamableHTTP")
+loader.inflector.inflect("http_client" => "HTTPClient")
+loader.inflector.inflect("http_server" => "HttpServer")
+
+loader.inflector.inflect("ruby_llm_adapter" => "RubyLLMAdapter")
+loader.inflector.inflect("mcp_sdk_adapter" => "MCPSdkAdapter")
+loader.inflector.inflect("mcp_transports" => "MCPTransports")
+
+loader.inflector.inflect("oauth_provider" => "OAuthProvider")
+loader.inflector.inflect("browser_oauth_provider" => "BrowserOAuthProvider")
+
+loader.setup
+
+if defined?(Rails::Railtie)
+  require_relative "mcp/railtie"
+end