ruby_llm_swarm-mcp 0.8.0

data/lib/ruby_llm/mcp/native/transports/support/http_client.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      module Transports
+        module Support
+          class HTTPClient
+            CONNECTION_KEY = :ruby_llm_mcp_client_connection
+
+            def self.connection
+              Thread.current[CONNECTION_KEY] ||= build_connection
+            end
+
+            def self.build_connection
+              HTTPX.with(
+                pool_options: {
+                  max_connections: RubyLLM::MCP.config.max_connections,
+                  pool_timeout: RubyLLM::MCP.config.pool_timeout
+                }
+              )
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/native/transports/support/rate_limit.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      module Transports
+        module Support
+          class RateLimit
+            def initialize(limit: 10, interval: 1000)
+              @limit = limit
+              @interval = interval
+              @timestamps = []
+              @mutex = Mutex.new
+            end
+
+            def exceeded?
+              now = current_time
+
+              @mutex.synchronize do
+                purge_old(now)
+                @timestamps.size >= @limit
+              end
+            end
+
+            def add
+              now = current_time
+
+              @mutex.synchronize do
+                purge_old(now)
+                @timestamps << now
+              end
+            end
+
+            private
+
+            def current_time
+              Process.clock_gettime(Process::CLOCK_MONOTONIC)
+            end
+
+            def purge_old(now)
+              cutoff = now - @interval
+              @timestamps.reject! { |t| t < cutoff }
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/native/transports/support/timeout.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      module Transports
+        module Support
+          module Timeout
+            def with_timeout(seconds, request_id: nil)
+              result = nil
+              exception = nil
+
+              worker = Thread.new do
+                result = yield
+              rescue StandardError => e
+                exception = e
+              end
+
+              if worker.join(seconds)
+                raise exception if exception
+
+                result
+              else
+                worker.kill # stop the thread (can still have some risk if shared resources)
+                raise RubyLLM::MCP::Errors::TimeoutError.new(
+                  message: "Request timed out after #{seconds} seconds",
+                  request_id: request_id
+                )
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/native.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+require_relative "native/messages"
+
+module RubyLLM
+  module MCP
+    # Native protocol implementation namespace
+    # This module contains the native Ruby MCP protocol implementation
+    module Native
+    end
+  end
+end

data/lib/ruby_llm/mcp/notification_handler.rb

@@ -0,0 +1,100 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class NotificationHandler
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+      end
+
+      def execute(notification)
+        case notification.type
+        when "notifications/tools/list_changed"
+          client.reset_tools!
+        when "notifications/resources/list_changed"
+          client.reset_resources!
+        when "notifications/resources/updated"
+          process_resource_updated(notification)
+        when "notifications/prompts/list_changed"
+          client.reset_prompts!
+        when "notifications/message"
+          process_logging_message(notification)
+        when "notifications/progress"
+          process_progress_message(notification)
+        when "notifications/cancelled"
+          process_cancelled_notification(notification)
+        else
+          process_unknown_notification(notification)
+        end
+      end
+
+      private
+
+      def process_resource_updated(notification)
+        uri = notification.params["uri"]
+        resource = client.resources.find { |r| r.uri == uri }
+        resource&.reset_content!
+      end
+
+      def process_logging_message(notification)
+        if client.logging_handler_enabled?
+          client.on[:logging].call(notification)
+        else
+          default_process_logging_message(notification)
+        end
+      end
+
+      def process_progress_message(notification)
+        if client.tracking_progress?
+          progress_obj = RubyLLM::MCP::Progress.new(self, client.on[:progress], notification.params)
+          progress_obj.execute_progress_handler
+        end
+      end
+
+      def default_process_logging_message(notification, logger: RubyLLM::MCP.logger)
+        level = notification.params["level"]
+        logger_message = notification.params["logger"]
+        message = notification.params["data"]
+
+        message = "#{logger_message}: #{message}"
+
+        case level
+        when "debug"
+          logger.debug(message["message"])
+        when "info", "notice"
+          logger.info(message["message"])
+        when "warning"
+          logger.warn(message["message"])
+        when "error", "critical"
+          logger.error(message["message"])
+        when "alert", "emergency"
+          logger.fatal(message["message"])
+        end
+      end
+
+      def process_cancelled_notification(notification)
+        request_id = notification.params["requestId"]
+        reason = notification.params["reason"] || "No reason provided"
+
+        RubyLLM::MCP.logger.info(
+          "Received cancellation for request #{request_id}: #{reason}"
+        )
+
+        success = client.cancel_in_flight_request(request_id)
+
+        unless success
+          RubyLLM::MCP.logger.debug(
+            "Request #{request_id} was not found or already completed"
+          )
+        end
+      end
+
+      def process_unknown_notification(notification)
+        message = "Unknown notification type: #{notification.type} params: #{notification.params.to_h}"
+        RubyLLM::MCP.logger.error(message)
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/progress.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Progress
+      attr_reader :progress_token, :progress, :total, :message, :client
+
+      def initialize(coordinator, progress_handler, progress_data)
+        @coordinator = coordinator
+        @client = coordinator.client
+        @progress_handler = progress_handler
+
+        @progress_token = progress_data["progressToken"]
+        @progress = progress_data["progress"]
+        @total = progress_data["total"]
+        @message = progress_data["message"]
+      end
+
+      def execute_progress_handler
+        @progress_handler.call(self)
+      end
+
+      def to_h
+        {
+          progress_token: @progress_token,
+          progress: @progress,
+          total: @total,
+          message: @message
+        }
+      end
+
+      alias to_json to_h
+    end
+  end
+end

data/lib/ruby_llm/mcp/prompt.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Prompt
+      class Argument
+        attr_reader :name, :description, :required
+
+        def initialize(name:, description:, required:)
+          @name = name
+          @description = description
+          @required = required
+        end
+
+        def to_h
+          {
+            name: @name,
+            description: @description,
+            required: @required
+          }
+        end
+      end
+
+      attr_reader :name, :description, :arguments, :adapter
+
+      def initialize(adapter, prompt)
+        @adapter = adapter
+        @name = prompt["name"]
+        @description = prompt["description"]
+        @arguments = parse_arguments(prompt["arguments"])
+      end
+
+      def fetch(arguments = {})
+        fetch_prompt_messages(arguments)
+      end
+
+      def include(chat, arguments: {})
+        validate_arguments!(arguments)
+        messages = fetch_prompt_messages(arguments)
+
+        messages.each { |message| chat.add_message(message) }
+        chat
+      end
+
+      def ask(chat, arguments: {}, &)
+        include(chat, arguments: arguments)
+
+        chat.complete(&)
+      end
+
+      alias say ask
+
+      def complete(argument, value, context: nil)
+        if @adapter.capabilities.completion?
+          result = @adapter.completion_prompt(name: @name, argument: argument, value: value, context: context)
+          if result.error?
+            return result.to_error
+          end
+
+          response = result.value["completion"]
+
+          Completion.new(argument: argument, values: response["values"], total: response["total"],
+                         has_more: response["hasMore"])
+        else
+          message = "Completion is not available for this MCP server"
+          raise Errors::Capabilities::CompletionNotAvailable.new(message: message)
+        end
+      end
+
+      def to_h
+        {
+          name: @name,
+          description: @description,
+          arguments: @arguments.map(&:to_h)
+        }
+      end
+
+      alias to_json to_h
+
+      private
+
+      def fetch_prompt_messages(arguments)
+        result = @adapter.execute_prompt(
+          name: @name,
+          arguments: arguments
+        )
+
+        result.raise_error! if result.error?
+
+        result.value["messages"].map do |message|
+          content = create_content_for_message(message["content"])
+
+          RubyLLM::Message.new(
+            role: message["role"],
+            content: content
+          )
+        end
+      end
+
+      def validate_arguments!(incoming_arguments)
+        @arguments.each do |arg|
+          if arg.required && incoming_arguments.key?(arg.name)
+            raise Errors::PromptArgumentError, "Argument #{arg.name} is required"
+          end
+        end
+      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["content"], content["mime_type"])
+          MCP::Content.new(text: nil, attachments: [attachment])
+        when "resource"
+          resource = Resource.new(adapter, content["resource"])
+          resource.to_content
+        end
+      end
+
+      def parse_arguments(arguments)
+        if arguments.nil?
+          []
+        else
+          arguments.map do |arg|
+            Argument.new(name: arg["name"], description: arg["description"], required: arg["required"])
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/railtie.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+if defined?(Rails::Railtie)
+  module RubyLLM
+    module MCP
+      class Railtie < Rails::Railtie
+        generators do
+          require_relative "../../generators/ruby_llm/mcp/install/install_generator"
+          require_relative "../../generators/ruby_llm/mcp/oauth/install_generator"
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/resource.rb

@@ -0,0 +1,112 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    class Resource
+      attr_reader :uri, :name, :description, :mime_type, :adapter, :subscribed
+
+      def initialize(adapter, resource)
+        @adapter = adapter
+        @uri = resource["uri"]
+        @name = resource["name"]
+        @description = resource["description"]
+        @mime_type = resource["mimeType"]
+        if resource.key?("content_response")
+          @content_response = resource["content_response"]
+          @content = @content_response["text"] || @content_response["blob"]
+        end
+
+        @subscribed = false
+      end
+
+      def content
+        return @content unless @content.nil?
+
+        result = read_response
+        result.raise_error! if result.error?
+
+        @content_response = result.value.dig("contents", 0)
+        @content = @content_response["text"] || @content_response["blob"]
+      end
+
+      def content_loaded?
+        !@content.nil?
+      end
+
+      def subscribe!
+        if @adapter.capabilities.resource_subscribe?
+          @adapter.resources_subscribe(uri: @uri)
+          @subscribed = true
+        else
+          message = "Resource subscribe is not available for this MCP server"
+          raise Errors::Capabilities::ResourceSubscribeNotAvailable.new(message: message)
+        end
+      end
+
+      def reset_content!
+        @content = nil
+        @content_response = nil
+      end
+
+      def include(chat, **args)
+        message = RubyLLM::Message.new(
+          role: "user",
+          content: to_content(**args)
+        )
+
+        chat.add_message(message)
+      end
+
+      def to_content
+        content = self.content
+        case content_type
+        when "text"
+          MCP::Content.new(text: "#{name}: #{description}\n\n#{content}")
+        when "blob"
+          attachment = MCP::Attachment.new(content, mime_type)
+          MCP::Content.new(text: "#{name}: #{description}", attachments: [attachment])
+        end
+      end
+
+      def to_h
+        {
+          uri: @uri,
+          name: @name,
+          description: @description,
+          mime_type: @mime_type,
+          contented_loaded: content_loaded?,
+          content: @content
+        }
+      end
+
+      alias to_json to_h
+
+      private
+
+      def content_type
+        return "text" if @content_response.nil?
+
+        if @content_response.key?("blob") && !@content_response["blob"].nil?
+          "blob"
+        else
+          "text"
+        end
+      end
+
+      def read_response(uri: @uri)
+        parsed = URI.parse(uri)
+        case parsed.scheme
+        when "http", "https"
+          fetch_uri_content(uri)
+        else # file:// or git://
+          @adapter.resource_read(uri: uri)
+        end
+      end
+
+      def fetch_uri_content(uri)
+        response = HTTPX.get(uri)
+        { "result" => { "contents" => [{ "text" => response.body }] } }
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/resource_template.rb

@@ -0,0 +1,85 @@
+# frozen_string_literal: true
+
+require "httpx"
+
+module RubyLLM
+  module MCP
+    class ResourceTemplate
+      attr_reader :uri, :name, :description, :mime_type, :adapter, :template
+
+      def initialize(adapter, resource)
+        @adapter = adapter
+        @uri = resource["uriTemplate"]
+        @name = resource["name"]
+        @description = resource["description"]
+        @mime_type = resource["mimeType"]
+      end
+
+      def fetch_resource(arguments: {})
+        uri = apply_template(@uri, arguments)
+        result = read_response(uri)
+        content_response = result.value.dig("contents", 0)
+
+        Resource.new(adapter, {
+                       "uri" => uri,
+                       "name" => "#{@name} (#{uri})",
+                       "description" => @description,
+                       "mimeType" => @mime_type,
+                       "content_response" => content_response
+                     })
+      end
+
+      def to_content(arguments: {})
+        fetch_resource(arguments: arguments).to_content
+      end
+
+      def complete(argument, value, context: nil)
+        if @adapter.capabilities.completion?
+          result = @adapter.completion_resource(uri: @uri, argument: argument, value: value, context: context)
+          result.raise_error! if result.error?
+
+          response = result.value["completion"]
+
+          Completion.new(argument: argument, values: response["values"], total: response["total"],
+                         has_more: response["hasMore"])
+        else
+          message = "Completion is not available for this MCP server"
+          raise Errors::Capabilities::CompletionNotAvailable.new(message: message)
+        end
+      end
+
+      private
+
+      def content_type
+        if @content.key?("type")
+          @content["type"]
+        else
+          "text"
+        end
+      end
+
+      def read_response(uri)
+        parsed = URI.parse(uri)
+        case parsed.scheme
+        when "http", "https"
+          fetch_uri_content(uri)
+        else # file:// or git://
+          @adapter.resource_read(uri: uri)
+        end
+      end
+
+      def fetch_uri_content(uri)
+        response = HTTPX.get(uri)
+        { "result" => { "contents" => [{ "text" => response.body }] } }
+      end
+
+      def apply_template(uri, arguments)
+        uri.gsub(/\{(\w+)\}/) do
+          arguments[::Regexp.last_match(1).to_s] ||
+            arguments[::Regexp.last_match(1).to_sym] ||
+            "{#{::Regexp.last_match(1)}}"
+        end
+      end
+    end
+  end
+end