ruby_llm_swarm-mcp 0.8.0

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

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      class ResponseHandler
+        attr_reader :coordinator
+
+        def initialize(coordinator)
+          @coordinator = coordinator
+        end
+
+        def execute(result)
+          operation = CancellableOperation.new(result.id)
+          coordinator.register_in_flight_request(result.id, operation)
+
+          begin
+            # Execute in a separate thread that can be terminated on cancellation
+            operation.execute do
+              if result.ping?
+                coordinator.ping_response(id: result.id)
+                true
+              elsif result.roots?
+                handle_roots_response(result)
+                true
+              elsif result.sampling?
+                handle_sampling_response(result)
+                true
+              elsif result.elicitation?
+                handle_elicitation_response(result)
+                true
+              else
+                handle_unknown_request(result)
+                RubyLLM::MCP.logger.error("MCP client was sent unknown method type and \
+                  could not respond: #{result.inspect}.")
+                false
+              end
+            end
+          rescue Errors::RequestCancelled => e
+            RubyLLM::MCP.logger.info("Request #{result.id} was cancelled: #{e.message}")
+            # Don't send response - cancellation means result is unused
+            true
+          ensure
+            coordinator.unregister_in_flight_request(result.id)
+          end
+        end
+
+        private
+
+        def handle_roots_response(result)
+          RubyLLM::MCP.logger.info("Roots request: #{result.inspect}")
+          roots_paths = coordinator.roots_paths
+          if roots_paths&.any?
+            coordinator.roots_list_response(id: result.id)
+          else
+            coordinator.error_response(
+              id: result.id,
+              message: "Roots are not enabled",
+              code: Native::JsonRpc::ErrorCodes::SERVER_ERROR
+            )
+          end
+        rescue StandardError => e
+          RubyLLM::MCP.logger.error("Error in roots request: #{e.message}\n#{e.backtrace.join("\n")}")
+          coordinator.error_response(
+            id: result.id,
+            message: "Internal error processing roots request",
+            code: Native::JsonRpc::ErrorCodes::INTERNAL_ERROR,
+            data: { detail: e.message }
+          )
+        end
+
+        def handle_sampling_response(result)
+          unless MCP.config.sampling.enabled?
+            RubyLLM::MCP.logger.info("Sampling is disabled, yet server requested sampling")
+            coordinator.error_response(
+              id: result.id,
+              message: "Sampling is disabled",
+              code: Native::JsonRpc::ErrorCodes::SERVER_ERROR
+            )
+            return
+          end
+
+          RubyLLM::MCP.logger.info("Sampling request: #{result.inspect}")
+          Sample.new(result, coordinator).execute
+        rescue StandardError => e
+          RubyLLM::MCP.logger.error("Error in sampling request: #{e.message}\n#{e.backtrace.join("\n")}")
+          coordinator.error_response(
+            id: result.id,
+            message: "Internal error processing sampling request",
+            code: Native::JsonRpc::ErrorCodes::INTERNAL_ERROR,
+            data: { detail: e.message }
+          )
+        end
+
+        def handle_elicitation_response(result)
+          RubyLLM::MCP.logger.info("Elicitation request: #{result.inspect}")
+          Elicitation.new(coordinator, result).execute
+        end
+
+        def handle_unknown_request(result)
+          coordinator.error_response(
+            id: result.id,
+            message: "Method not found: #{result.method}",
+            code: Native::JsonRpc::ErrorCodes::METHOD_NOT_FOUND
+          )
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module MCP
+    module Native
+      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::Native::Transports::SSE)
+        register_transport(:stdio, RubyLLM::MCP::Native::Transports::Stdio)
+        register_transport(:streamable, RubyLLM::MCP::Native::Transports::StreamableHTTP)
+        register_transport(:streamable_http, RubyLLM::MCP::Native::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_protocol = nil
+            @transport_protocol = build_transport
+          end
+
+          @transport_protocol ||= build_transport
+        end
+
+        private
+
+        def build_transport
+          unless RubyLLM::MCP::Native::Transport.transports.key?(transport_type)
+            supported_types = RubyLLM::MCP::Native::Transport.transports.keys.join(", ")
+            message = "Invalid transport type: :#{transport_type}. Supported types are #{supported_types}"
+            raise Errors::InvalidTransportType.new(message: message)
+          end
+
+          # Extract and merge options if present (from OAuth helper preparation)
+          transport_config = config.dup
+          if transport_config[:options]
+            options = transport_config.delete(:options)
+            transport_config.merge!(options)
+          end
+
+          # Handle SSE transport specially - it uses options hash pattern
+          if transport_type == :sse
+            url = transport_config.delete(:url) || transport_config.delete("url")
+            request_timeout = transport_config.delete(:request_timeout) ||
+                              transport_config.delete("request_timeout") ||
+                              MCP.config.request_timeout
+            # Everything else goes into options
+            options_hash = transport_config.dup
+            transport_config.clear
+            transport_config[:url] = url
+            transport_config[:request_timeout] = request_timeout
+            transport_config[:options] = options_hash
+          end
+
+          # Remove OAuth-specific params from transports that don't support them
+          # This allows other arbitrary params (like timeout) to pass through for testing
+          unless %i[streamable streamable_http sse].include?(transport_type)
+            transport_config.delete(:oauth_provider)
+            transport_config.delete(:oauth)
+          end
+
+          transport_klass = RubyLLM::MCP::Native::Transport.transports[transport_type]
+          transport_klass.new(coordinator: coordinator, **transport_config)
+        end
+      end
+    end
+  end
+end