Merge pull request #82 from patvice/original-ruby-parameters-bug

Support both base and MCP Parameters in ComplexParameterSupport via Delegation

Author: patvice

lib/ruby_llm/mcp/parameter.rb

@@ -7,6 +7,14 @@ module MCP
     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

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

@@ -9,15 +9,15 @@ module ComplexParameterSupport
 
           def clean_parameters(parameters)
             parameters.transform_values do |param|
-              build_properties(param).compact
+              mcp_build_properties(param).compact
             end
           end
 
           def required_parameters(parameters)
             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 @@ def build_properties(param) # rubocop:disable Metrics/MethodLength
               }.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 @@ def build_properties(param) # rubocop:disable Metrics/MethodLength
 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

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

@@ -11,12 +11,12 @@ module ComplexParameterSupport
           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 @@ def build_properties(param) # rubocop:disable Metrics/MethodLength
                                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 @@ def build_properties(param) # rubocop:disable Metrics/MethodLength
                              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 @@ def build_properties(param) # rubocop:disable Metrics/MethodLength
 
             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

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

@@ -57,4 +57,16 @@ def param_schema(param) # rubocop:disable Metrics/MethodLength
   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

lib/ruby_llm/mcp/transports/streamable_http.rb

@@ -496,6 +496,11 @@ def start_sse(options) # rubocop:disable Metrics/MethodLength
               # 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(

lib/ruby_llm/mcp/version.rb

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

spec/fixtures/typescript-mcp/src/tools/utilities.ts

@@ -107,33 +107,40 @@ export function setupUtilityTools(server: McpServer) {
           throw new Error("Only HTTP and HTTPS URLs are supported");
         }
 
-        // Fetch the website content with timeout
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
-
-        const headers = {
-          "User-Agent": "Mozilla/5.0 (compatible; MCP-Tool/1.0)",
-          ...customHeaders,
-        };
-
-        const headersArray = Object.entries(headers).map(([key, value]) => [
-          key,
-          value,
-        ]);
-
-        const response = await fetch(url.href, {
-          headers: Object.fromEntries(headersArray),
-          signal: controller.signal,
-        });
-
-        clearTimeout(timeoutId);
-
-        if (!response.ok) {
-          throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+        let html: string;
+
+        // Return hardcoded response for example.com to avoid SSL certificate issues
+        if (websiteUrl === "https://www.example.com/") {
+          html = '<!doctype html><html lang="en"><head><title>Example Domain</title><meta name="viewport" content="width=device-width, initial-scale=1"><style>body{background:#eee;width:60vw;margin:15vh auto;font-family:system-ui,sans-serif}h1{font-size:1.5em}div{opacity:0.8}a:link,a:visited{color:#348}</style><body><div><h1>Example Domain</h1><p>This domain is for use in documentation examples without needing permission. Avoid use in operations.<p><a href="https://iana.org/domains/example">Learn more</a></div></body></html>';
+        } else {
+          // Fetch the website content with timeout
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+
+          const headers = {
+            "User-Agent": "Mozilla/5.0 (compatible; MCP-Tool/1.0)",
+            ...customHeaders,
+          };
+
+          const headersArray = Object.entries(headers).map(([key, value]) => [
+            key,
+            value,
+          ]);
+
+          const response = await fetch(url.href, {
+            headers: Object.fromEntries(headersArray),
+            signal: controller.signal,
+          });
+
+          clearTimeout(timeoutId);
+
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+          }
+
+          html = await response.text();
         }
 
-        const html = await response.text();
-
         // Basic HTML content extraction (remove script, style, and HTML tags)
         const cleanText = html
           .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "") // Remove scripts