ruby_llm_swarm-mcp 0.8.0 → 0.8.1

data/lib/ruby_llm/mcp/responses/sampling_create_message.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Responses
+      class SamplingCreateMessage
+        def initialize(coordinator, id:, message:, model:)
+          @coordinator = coordinator
+          @id = id
+          @message = message
+          @model = model
+        end
+
+        def call
+          @coordinator.request(sampling_create_message_body, add_id: false, wait_for_response: false)
+        end
+
+        private
+
+        def sampling_create_message_body
+          {
+            jsonrpc: "2.0",
+            id: @id,
+            result: {
+              role: @message.role,
+              content: format_content(@message.content),
+              model: @model,
+              # TODO: We are going to assume it was a endTurn
+              # Look into getting RubyLLM to expose stopReason in message response
+              stopReason: "endTurn"
+            }
+          }
+        end
+
+        def format_content(content)
+          if content.is_a?(RubyLLM::Content)
+            if context.text.none? && content.attachments.any?
+              attachment = content.attachments.first
+              { type: attachment.type, data: attachment.content, mime_type: attachment.mime_type }
+            else
+              { type: "text", text: content.text }
+            end
+          else
+            { type: "text", text: content }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/mcp/result.rb

@@ -32,10 +32,6 @@ module RubyLLM
 
         @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|
@@ -69,7 +65,7 @@ module RubyLLM
       end
 
       def notification?
-        @id.nil? && !@method.nil?
+        @method&.include?("notifications") || false
       end
 
       def next_cursor?
@@ -77,15 +73,15 @@ module RubyLLM
       end
 
       def request?
-        !@id.nil? && !@method.nil?
+        !@method.nil? && !notification? && @result.none? && @error.none?
       end
 
       def response?
-        !@id.nil? && @method.nil? && (@has_result || @has_error)
+        !@id.nil? && (@result || @error.any?) && !@method
       end
 
       def success?
-        @has_result
+        !@result.empty?
       end
 
       def tool_success?

data/lib/ruby_llm/mcp/roots.rb

@@ -5,9 +5,9 @@ module RubyLLM
     class Roots
       attr_reader :paths
 
-      def initialize(paths: [], adapter: nil)
+      def initialize(paths: [], coordinator: nil)
         @paths = paths
-        @adapter = adapter
+        @coordinator = coordinator
       end
 
       def active?
@@ -16,12 +16,12 @@ module RubyLLM
 
       def add(path)
         @paths << path
-        @adapter.roots_list_change_notification
+        @coordinator.roots_list_change_notification
       end
 
       def remove(path)
         @paths.delete(path)
-        @adapter.roots_list_change_notification
+        @coordinator.roots_list_change_notification
       end
 
       def to_request

data/lib/ruby_llm/mcp/sample.rb

@@ -76,13 +76,9 @@ module RubyLLM
       private
 
       def callback_guard_success?
-        return true unless @coordinator.sampling_callback_enabled?
+        return true unless @coordinator.client.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
+        unless @coordinator.client.on[:sampling].call(self)
           @coordinator.error_response(id: @id, message: REJECTED_MESSAGE)
           return false
         end

data/lib/ruby_llm/mcp/tool.rb

@@ -25,11 +25,11 @@ module RubyLLM
     end
 
     class Tool < RubyLLM::Tool
-      attr_reader :name, :title, :description, :adapter, :annotations, :tool_response, :with_prefix
+      attr_reader :name, :title, :description, :annotations, :coordinator, :tool_response, :with_prefix
 
-      def initialize(adapter, tool_response, with_prefix: false)
+      def initialize(coordinator, tool_response, with_prefix: false)
         super()
-        @adapter = adapter
+        @coordinator = coordinator
 
         @with_prefix = with_prefix
         @name = format_name(tool_response["name"])
@@ -45,7 +45,7 @@ module RubyLLM
       end
 
       def display_name
-        "#{@adapter.client.name}: #{@name}"
+        "#{@coordinator.name}: #{@name}"
       end
 
       def params_schema
@@ -53,7 +53,7 @@ module RubyLLM
       end
 
       def execute(**params)
-        result = @adapter.execute_tool(
+        result = @coordinator.execute_tool(
           name: @mcp_name,
           parameters: params
         )
@@ -116,7 +116,7 @@ module RubyLLM
             }
           }
 
-          resource = Resource.new(adapter, resource_data)
+          resource = Resource.new(coordinator, resource_data)
           resource.to_content
         when "resource_link"
           resource_data = {
@@ -126,15 +126,15 @@ module RubyLLM
             "mimeType" => content["mimeType"]
           }
 
-          resource = Resource.new(adapter, resource_data)
-          @adapter.register_resource(resource)
+          resource = Resource.new(coordinator, resource_data)
+          @coordinator.register_resource(resource)
           resource.to_content
         end
       end
 
       def format_name(name)
         if @with_prefix
-          "#{@adapter.client.name}_#{name}"
+          "#{@coordinator.name}_#{name}"
         else
           name
         end

data/lib/ruby_llm/mcp/transport.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    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::Transports::SSE)
+      register_transport(:stdio, RubyLLM::MCP::Transports::Stdio)
+      register_transport(:streamable, RubyLLM::MCP::Transports::StreamableHTTP)
+      register_transport(:streamable_http, RubyLLM::MCP::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 = build_transport
+          coordinator.restart_transport
+        end
+
+        @transport_protocol ||= build_transport
+      end
+
+      private
+
+      def build_transport
+        unless RubyLLM::MCP::Transport.transports.key?(transport_type)
+          supported_types = RubyLLM::MCP::Transport.transports.keys.join(", ")
+          message = "Invalid transport type: :#{transport_type}. Supported types are #{supported_types}"
+          raise Errors::InvalidTransportType.new(message: message)
+        end
+
+        transport_config = prepare_transport_config
+        transport_klass = RubyLLM::MCP::Transport.transports[transport_type]
+        transport_klass.new(coordinator: coordinator, **transport_config)
+      end
+
+      def prepare_transport_config
+        transport_config = config.dup
+        oauth_provider = create_oauth_provider(transport_config) if oauth_config_present?(transport_config)
+
+        # Extract transport-specific parameters and consolidate into options
+        if %i[sse streamable streamable_http].include?(transport_type)
+          prepare_http_transport_config(transport_config, oauth_provider)
+        elsif transport_type == :stdio
+          prepare_stdio_transport_config(transport_config)
+        else
+          transport_config
+        end
+      end
+
+      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
+
+      def prepare_stdio_transport_config(config)
+        options = {
+          args: config.delete(:args) || config.delete("args"),
+          env: config.delete(:env) || config.delete("env")
+        }.compact
+
+        config[:options] = options unless options.empty?
+        config
+      end
+
+      # Check if OAuth configuration 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
+      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
+        # Determine server URL based on transport type
+        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
+      def determine_server_url(config)
+        config[:url] || config["url"]
+      end
+    end
+  end
+end