ruby_llm-mcp 0.6.2 → 0.6.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f6b3a7fc52258ae0e1a8e5635b7c7347165b2c78da97ba1cfa1bc3633390eb39
-  data.tar.gz: d2220a770be8038c8fa794196742f8c35d390e4020b838a9d7279c449b5894b0
+  metadata.gz: 5bec47480f606a8d28f8a79032e392e331dcdcef565cd708e6dcc855f0a31445
+  data.tar.gz: ac65a564ce2bd4d39e4e4fdcff02da19cbd7573186924e938fadb2d9c2f523db
 SHA512:
-  metadata.gz: 4d6d145ab20653923ce4a557f6cc6d44b10f395a7c54dde228d69fe9f7e175e6d56ae6b6382ceae6dd32878305757271843e09a81ea07aaca2a1741a0f8f29a3
-  data.tar.gz: 50872333e5206d74d30dd612d8e09db65665957cca705e6f20cf3f72460896332e0c5ea271ab2fa88659421dc4d1a07b0fe217ed9b925d237993b59baf4f94a2
+  metadata.gz: 7e9394538e772a3169fe424854cbf57aee643953be4e44f805c82f0f81c61189a06d755e8a14b4e530183e414e9a4b3000912a577d3eca95da236c124b9a54dc
+  data.tar.gz: a6eb704e2aaac9386e54cb178dd136bc19510a2159adc63125d50f5a96c9473de9416e33755059f9578ab609d34fe3fbe8c8d7f8e970900380b93770793376a3

data/lib/ruby_llm/mcp/parameter.rb

@@ -7,6 +7,14 @@ module RubyLLM
     class Parameter < RubyLLM::Parameter
       attr_accessor :items, :properties, :enum, :union_type, :default, :title
 
+      class << self
+        def all_mcp_parameters?(parameters)
+          parameters.is_a?(Hash) &&
+            parameters.any? &&
+            parameters.values.all? { |p| p.is_a?(RubyLLM::MCP::Parameter) }
+        end
+      end
+
       def initialize(name, type: "string", title: nil, desc: nil, required: true, default: nil, union_type: nil) # rubocop:disable Metrics/ParameterLists
         super(name, type: type.to_sym, desc: desc, required: required)
         @title = title

data/lib/ruby_llm/mcp/providers/anthropic/complex_parameter_support.rb

@@ -9,7 +9,7 @@ module RubyLLM
 
           def clean_parameters(parameters)
             parameters.transform_values do |param|
-              build_properties(param).compact
+              mcp_build_properties(param).compact
             end
           end
 
@@ -17,7 +17,7 @@ module RubyLLM
             parameters.select { |_, param| param.required }.keys
           end
 
-          def build_properties(param) # rubocop:disable Metrics/MethodLength
+          def mcp_build_properties(param) # rubocop:disable Metrics/MethodLength
             case param.type
             when :array
               if param.item_type == :object
@@ -46,7 +46,7 @@ module RubyLLM
               }.compact
             when :union
               {
-                param.union_type => param.properties.map { |property| build_properties(property) }
+                param.union_type => param.properties.map { |property| mcp_build_properties(property) }
               }
             else
               {
@@ -63,11 +63,25 @@ module RubyLLM
 end
 
 module RubyLLM::Providers::Anthropic::Tools
-  def self.clean_parameters(parameters)
-    RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport.clean_parameters(parameters)
+  alias original_clean_parameters clean_parameters
+  alias original_required_parameters required_parameters
+  module_function :original_clean_parameters, :original_required_parameters
+
+  def clean_parameters(parameters)
+    if RubyLLM::MCP::Parameter.all_mcp_parameters?(parameters)
+      return RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport.clean_parameters(parameters)
+    end
+
+    original_clean_parameters(parameters)
   end
+  module_function :clean_parameters
+
+  def required_parameters(parameters)
+    if RubyLLM::MCP::Parameter.all_mcp_parameters?(parameters)
+      return RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport.required_parameters(parameters)
+    end
 
-  def self.required_parameters(parameters)
-    RubyLLM::MCP::Providers::Anthropic::ComplexParameterSupport.required_parameters(parameters)
+    original_required_parameters(parameters)
   end
+  module_function :required_parameters
 end

data/lib/ruby_llm/mcp/providers/gemini/complex_parameter_support.rb

@@ -11,12 +11,12 @@ module RubyLLM
           def format_parameters(parameters)
             {
               type: "OBJECT",
-              properties: parameters.transform_values { |param| build_properties(param) },
+              properties: parameters.transform_values { |param| mcp_build_properties(param) },
               required: parameters.select { |_, p| p.required }.keys.map(&:to_s)
             }
           end
 
-          def build_properties(param) # rubocop:disable Metrics/MethodLength
+          def mcp_build_properties(param) # rubocop:disable Metrics/MethodLength
             properties = case param.type
                          when :array
                            if param.item_type == :object
@@ -26,7 +26,7 @@ module RubyLLM
                                description: param.description,
                                items: {
                                  type: param_type_for_gemini(param.item_type),
-                                 properties: param.properties.transform_values { |value| build_properties(value) }
+                                 properties: param.properties.transform_values { |value| mcp_build_properties(value) }
                                }
                              }.compact
                            else
@@ -43,12 +43,12 @@ module RubyLLM
                              type: param_type_for_gemini(param.type),
                              title: param.title,
                              description: param.description,
-                             properties: param.properties.transform_values { |value| build_properties(value) },
+                             properties: param.properties.transform_values { |value| mcp_build_properties(value) },
                              required: param.properties.select { |_, p| p.required }.keys
                            }.compact
                          when :union
                            {
-                             param.union_type => param.properties.map { |properties| build_properties(properties) }
+                             param.union_type => param.properties.map { |properties| mcp_build_properties(properties) }
                            }
                          else
                            {
@@ -60,10 +60,27 @@ module RubyLLM
 
             properties.compact
           end
+
+          def param_type_for_gemini(type)
+            RubyLLM::Providers::Gemini::Tools.param_type_for_gemini(type)
+          end
         end
       end
     end
   end
 end
 
-RubyLLM::Providers::Gemini.extend(RubyLLM::MCP::Providers::Gemini::ComplexParameterSupport)
+module RubyLLM::Providers::Gemini::Tools
+  alias original_format_parameters format_parameters
+  module_function :original_format_parameters
+  module_function :param_type_for_gemini
+
+  def format_parameters(parameters)
+    if RubyLLM::MCP::Parameter.all_mcp_parameters?(parameters)
+      return RubyLLM::MCP::Providers::Gemini::ComplexParameterSupport.format_parameters(parameters)
+    end
+
+    original_format_parameters(parameters)
+  end
+  module_function :format_parameters
+end

data/lib/ruby_llm/mcp/providers/openai/complex_parameter_support.rb

@@ -57,4 +57,16 @@ module RubyLLM
   end
 end
 
-RubyLLM::Providers::OpenAI.extend(RubyLLM::MCP::Providers::OpenAI::ComplexParameterSupport)
+module RubyLLM::Providers::OpenAI::Tools
+  alias original_param_schema param_schema
+  module_function :original_param_schema
+
+  def param_schema(param)
+    if param.is_a?(RubyLLM::MCP::Parameter)
+      return RubyLLM::MCP::Providers::OpenAI::ComplexParameterSupport.param_schema(param)
+    end
+
+    original_param_schema(param)
+  end
+  module_function :param_schema
+end

data/lib/ruby_llm/mcp/transports/sse.rb

@@ -30,7 +30,6 @@ module RubyLLM
                                      "Accept" => "text/event-stream",
                                      "Content-Type" => "application/json",
                                      "Cache-Control" => "no-cache",
-                                     "Connection" => "keep-alive",
                                      "X-CLIENT-ID" => @client_id
                                    })
 
@@ -167,41 +166,82 @@ module RubyLLM
         end
 
         def stream_events_from_server
-          sse_client = HTTPX.plugin(:stream)
-          sse_client = sse_client.with(
-            headers: @headers
-          )
+          sse_client = create_sse_client
+          response = sse_client.get(@event_url, stream: true)
+          validate_sse_response!(response)
+          process_event_stream(response)
+        end
 
-          if @version == :http1
-            sse_client = sse_client.with(
-              ssl: { alpn_protocols: ["http/1.1"] }
-            )
-          end
+        def create_sse_client
+          sse_client = HTTPX.plugin(:stream).with(headers: @headers)
+          return sse_client unless @version == :http1
 
-          response = sse_client.get(@event_url, stream: true)
+          sse_client.with(ssl: { alpn_protocols: ["http/1.1"] })
+        end
+
+        def validate_sse_response!(response)
+          return unless response.status >= 400
+
+          error_body = read_error_body(response)
+          error_message = "HTTP #{response.status} error from SSE endpoint: #{error_body}"
+          RubyLLM::MCP.logger.error error_message
+
+          handle_client_error!(error_message, response.status) if response.status < 500
+
+          raise StandardError, error_message
+        end
+
+        def handle_client_error!(error_message, status_code)
+          @running = false
+          raise Errors::TransportError.new(
+            message: error_message,
+            code: status_code
+          )
+        end
 
+        def process_event_stream(response)
           event_buffer = []
           response.each_line do |event_line|
-            unless @running
-              response.body.close
-              next
-            end
+            break unless handle_event_line?(event_line, event_buffer, response)
+          end
+        end
 
-            # Strip the line and check if it's empty (indicates end of event)
-            line = event_line.strip
+        def handle_event_line?(event_line, event_buffer, response)
+          unless @running
+            response.body.close
+            return false
+          end
 
-            if line.empty?
-              # End of event - process the accumulated buffer
-              if event_buffer.any?
-                events = parse_event(event_buffer.join("\n"))
-                events.each { |event| process_event(event) }
-                event_buffer.clear
-              end
-            else
-              # Accumulate the line for the current event
-              event_buffer << line
+          line = event_line.strip
+
+          if line.empty?
+            process_buffered_event(event_buffer)
+          else
+            event_buffer << line
+          end
+
+          true
+        end
+
+        def process_buffered_event(event_buffer)
+          return unless event_buffer.any?
+
+          events = parse_event(event_buffer.join("\n"))
+          events.each { |event| process_event(event) }
+          event_buffer.clear
+        end
+
+        def read_error_body(response)
+          # Try to read the error body from the response
+          body = ""
+          begin
+            response.each do |chunk|
+              body << chunk
             end
+          rescue StandardError
+            # If we can't read the body, just use what we have
           end
+          body.strip.empty? ? "No error details provided" : body.strip
         end
 
         def handle_connection_error(message, error)

data/lib/ruby_llm/mcp/transports/streamable_http.rb

@@ -496,6 +496,11 @@ module RubyLLM
               # Server doesn't support SSE - this is acceptable
               RubyLLM::MCP.logger.info "Server does not support SSE streaming"
               nil
+            when 409
+              # Conflict - SSE connection already exists for this session
+              # This is expected when reusing sessions and is acceptable
+              RubyLLM::MCP.logger.debug "SSE stream already exists for this session"
+              nil
             else
               reason_phrase = response.respond_to?(:reason_phrase) ? response.reason_phrase : nil
               raise Errors::TransportError.new(

data/lib/ruby_llm/mcp/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module MCP
-    VERSION = "0.6.2"
+    VERSION = "0.6.4"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-mcp
 version: !ruby/object:Gem::Version
-  version: 0.6.2
+  version: 0.6.4
 platform: ruby
 authors:
 - Patrick Vice