ruby_llm-mcp 0.6.4 → 0.7.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bec47480f606a8d28f8a79032e392e331dcdcef565cd708e6dcc855f0a31445
-  data.tar.gz: ac65a564ce2bd4d39e4e4fdcff02da19cbd7573186924e938fadb2d9c2f523db
+  metadata.gz: b40509c28a60e1ae01ed83d47503d76f30d5f3bf9852ef4c30ca033d6ea149bc
+  data.tar.gz: f3393dc6423c6bcda143cb6b22e7042434ca1d7d385cc2adf97ba925efff6912
 SHA512:
-  metadata.gz: 7e9394538e772a3169fe424854cbf57aee643953be4e44f805c82f0f81c61189a06d755e8a14b4e530183e414e9a4b3000912a577d3eca95da236c124b9a54dc
-  data.tar.gz: a6eb704e2aaac9386e54cb178dd136bc19510a2159adc63125d50f5a96c9473de9416e33755059f9578ab609d34fe3fbe8c8d7f8e970900380b93770793376a3
+  metadata.gz: 86e6dd3009df055ad4fa6d088b6b1d9fb87cc8c6244b1436e4ef96ef1cbd822c321c779bd518557544a6c457d19270bf1a57c874cb6d80543141ecac7c370754
+  data.tar.gz: 5a76f9b2aaf2d3db38d97c9d66341458e25f3cdd89fdaf1768095a1bba20257154e128c9b60245f1f09f3e6f09b967daacd70748008c4edf90c3e836546bd6d6

data/lib/generators/ruby_llm/mcp/templates/initializer.rb

@@ -11,9 +11,6 @@ RubyLLM::MCP.configure do |config|
   # Pool timeout in seconds
   config.pool_timeout = 5
 
-  # Enable complex parameter support for various providers
-  config.support_complex_parameters!
-
   # Path to MCPs configuration file
   config.config_path = Rails.root.join("config", "mcps.yml")
 
@@ -31,7 +28,7 @@ RubyLLM::MCP.configure do |config|
   # Set preferred model for sampling
   # config.sampling.preferred_model do
   #   # Return the preferred model name
-  #   "claude-3-5-sonnet-20240620"
+  #   "claude-sonnet-4"
   # end
 
   # Set a guard for sampling

data/lib/ruby_llm/mcp/configuration.rb

@@ -111,6 +111,7 @@ module RubyLLM
       end
 
       def support_complex_parameters!
+        warn "[DEPRECATION] config.support_complex_parameters! is no longer needed and will be removed in version 0.8.0"
         return if @has_support_complex_parameters
 
         @has_support_complex_parameters = true

data/lib/ruby_llm/mcp/content.rb

@@ -7,13 +7,21 @@ module RubyLLM
 
       def initialize(text: nil, attachments: nil) # rubocop:disable Lint/MissingSuper
         @text = text
-        @attachments = attachments || []
+        @attachments = []
+
+        # Handle MCP::Attachment objects directly without processing
+        if attachments.is_a?(Array) && attachments.all? { |a| a.is_a?(MCP::Attachment) }
+          @attachments = attachments
+        elsif attachments
+          # Let parent class process other types of attachments
+          process_attachments(attachments)
+        end
       end
 
       # This is a workaround to allow the content object to be passed as the tool call
       # to return audio or image attachments.
       def to_s
-        attachments.empty? ? text : self
+        text.to_s
       end
     end
   end

data/lib/ruby_llm/mcp/resource.rb

@@ -51,7 +51,7 @@ module RubyLLM
       end
 
       def include(chat, **args)
-        message = Message.new(
+        message = RubyLLM::Message.new(
           role: "user",
           content: to_content(**args)
         )

data/lib/ruby_llm/mcp/tool.rb

@@ -25,7 +25,7 @@ module RubyLLM
     end
 
     class Tool < RubyLLM::Tool
-      attr_reader :name, :title, :description, :parameters, :coordinator, :tool_response, :with_prefix
+      attr_reader :name, :title, :description, :coordinator, :tool_response, :with_prefix
 
       def initialize(coordinator, tool_response, with_prefix: false)
         super()
@@ -35,18 +35,23 @@ module RubyLLM
         @name = format_name(tool_response["name"])
         @mcp_name = tool_response["name"]
         @description = tool_response["description"].to_s
-        @parameters = create_parameters(tool_response["inputSchema"])
 
         @input_schema = tool_response["inputSchema"]
         @output_schema = tool_response["outputSchema"]
 
         @annotations = tool_response["annotations"] ? Annotation.new(tool_response["annotations"]) : nil
+
+        @normalized_input_schema = normalize_if_invalid(@input_schema)
       end
 
       def display_name
         "#{@coordinator.name}: #{@name}"
       end
 
+      def params_schema
+        @normalized_input_schema
+      end
+
       def execute(**params)
         result = @coordinator.execute_tool(
           name: @mcp_name,
@@ -83,7 +88,7 @@ module RubyLLM
         {
           name: @name,
           description: @description,
-          parameters: @parameters.to_h,
+          params_schema: @@normalized_input_schema,
           annotations: @annotations&.to_h
         }
       end
@@ -92,76 +97,6 @@ module RubyLLM
 
       private
 
-      def create_parameters(schema)
-        params = {}
-        return params if schema["properties"].nil?
-
-        schema["properties"].each_key do |key|
-          param_data = schema.dig("properties", key)
-          param_data = expand_shorthand_type_to_anyof(param_data)
-
-          param = if param_data.key?("oneOf") || param_data.key?("anyOf") || param_data.key?("allOf")
-                    process_union_parameter(key, param_data)
-                  else
-                    process_parameter(key, param_data)
-                  end
-
-          params[key] = param
-        end
-
-        params
-      end
-
-      def process_union_parameter(key, param_data)
-        union_type = param_data.keys.first
-        param = RubyLLM::MCP::Parameter.new(
-          key,
-          type: :union,
-          title: param_data["title"],
-          desc: param_data["description"],
-          union_type: union_type
-        )
-
-        param.properties = param_data[union_type].map do |value|
-          expanded_value = expand_shorthand_type_to_anyof(value)
-          if expanded_value.key?("anyOf")
-            process_union_parameter(key, expanded_value)
-          else
-            process_parameter(key, value, lifted_type: param_data["type"])
-          end
-        end.compact
-
-        param
-      end
-
-      def process_parameter(key, param_data, lifted_type: nil)
-        param = RubyLLM::MCP::Parameter.new(
-          key,
-          type: param_data["type"] || lifted_type || "string",
-          title: param_data["title"],
-          desc: param_data["description"],
-          required: param_data["required"],
-          default: param_data["default"]
-        )
-
-        if param.type == :array
-          items = param_data["items"]
-          param.items = items
-          if items.key?("properties")
-            param.properties = create_parameters(items)
-          end
-          if items.key?("enum")
-            param.enum = items["enum"]
-          end
-        elsif param.type == :object
-          if param_data.key?("properties")
-            param.properties = create_parameters(param_data)
-          end
-        end
-
-        param
-      end
-
       def create_content_for_message(content)
         case content["type"]
         when "text"
@@ -205,19 +140,88 @@ module RubyLLM
         end
       end
 
-      # Expands shorthand type arrays into explicit anyOf unions
-      # Converts { "type": ["string", "number"] } into { "anyOf": [{"type": "string"}, {"type": "number"}] }
-      # This keeps $ref references clean and provides a consistent structure for union types
-      #
-      # @param param_data [Hash] The parameter data that may contain a shorthand type array
-      # @return [Hash] The expanded parameter data with anyOf, or the original if not a shorthand
-      def expand_shorthand_type_to_anyof(param_data)
-        type = param_data["type"]
-        return param_data unless type.is_a?(Array)
+      def normalize_schema(schema)
+        return schema if schema.nil?
 
-        {
-          "anyOf" => type.map { |t| { "type" => t } }
-        }.merge(param_data.except("type"))
+        case schema
+        when Hash
+          normalize_hash_schema(schema)
+        when Array
+          normalize_array_schema(schema)
+        else
+          schema
+        end
+      end
+
+      def normalize_hash_schema(schema)
+        normalized = schema.transform_values { |value| normalize_schema_value(value) }
+        ensure_object_properties(normalized)
+        normalized
+      end
+
+      def normalize_array_schema(schema)
+        schema.map { |item| normalize_schema_value(item) }
+      end
+
+      def normalize_schema_value(value)
+        case value
+        when Hash
+          normalize_schema(value)
+        when Array
+          normalize_array_schema(value)
+        else
+          value
+        end
+      end
+
+      def ensure_object_properties(schema)
+        if schema["type"] == "object" && !schema.key?("properties")
+          schema["properties"] = {}
+        end
+      end
+
+      def normalize_if_invalid(schema)
+        return schema if schema.nil?
+
+        if valid_schema?(schema)
+          schema
+        else
+          normalize_schema(schema)
+        end
+      end
+
+      def valid_schema?(schema)
+        return true if schema.nil?
+
+        case schema
+        when Hash
+          valid_hash_schema?(schema)
+        when Array
+          schema.all? { |item| valid_schema?(item) }
+        else
+          true
+        end
+      end
+
+      def valid_hash_schema?(schema)
+        # Check if this level has missing properties for object type
+        if schema["type"] == "object" && !schema.key?("properties")
+          return false
+        end
+
+        # Recursively check nested schemas
+        schema.each_value do |value|
+          return false unless valid_schema?(value)
+        end
+
+        begin
+          JSON::Validator.validate!(schema, {})
+          true
+        rescue JSON::Schema::SchemaError
+          false
+        rescue JSON::Schema::ValidationError
+          true
+        end
       end
     end
   end

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

@@ -78,51 +78,23 @@ module RubyLLM
           @running = true
         end
 
-        def close # rubocop:disable Metrics/MethodLength
+        def close
           @running = false
 
-          begin
-            @stdin&.close
-          rescue StandardError
-            nil
-          end
-
-          begin
-            @wait_thread&.join(1)
-          rescue StandardError
+          [@stdin, @stdout, @stderr].each do |stream|
+            stream&.close
+          rescue IOError, Errno::EBADF
             nil
           end
 
-          begin
-            @stdout&.close
-          rescue StandardError
-            nil
-          end
-
-          begin
-            @stderr&.close
+          [@wait_thread, @reader_thread, @stderr_thread].each do |thread|
+            thread&.join(1)
           rescue StandardError
             nil
           end
 
-          begin
-            @reader_thread&.join(1)
-          rescue StandardError
-            nil
-          end
-
-          begin
-            @stderr_thread&.join(1)
-          rescue StandardError
-            nil
-          end
-
-          @stdin = nil
-          @stdout = nil
-          @stderr = nil
-          @wait_thread = nil
-          @reader_thread = nil
-          @stderr_thread = nil
+          @stdin = @stdout = @stderr = nil
+          @wait_thread = @reader_thread = @stderr_thread = nil
         end
 
         def set_protocol_version(version)
@@ -151,58 +123,88 @@ module RubyLLM
 
         def start_reader_thread
           @reader_thread = Thread.new do
-            while @running
-              begin
-                if @stdout.closed? || @wait_thread.nil? || !@wait_thread.alive?
-                  sleep 1
-                  restart_process if @running
-                  next
-                end
-
-                line = @stdout.gets
-                next unless line && !line.strip.empty?
-
-                process_response(line.strip)
-              rescue IOError, Errno::EPIPE => e
-                RubyLLM::MCP.logger.error "Reader error: #{e.message}. Restarting in 1 second..."
-                sleep 1
-                restart_process if @running
-              rescue StandardError => e
-                RubyLLM::MCP.logger.error "Error in reader thread: #{e.message}, #{e.backtrace.join("\n")}"
-                sleep 1
-              end
-            end
+            read_stdout_loop
           end
 
           @reader_thread.abort_on_exception = true
         end
 
+        def read_stdout_loop
+          while @running
+            begin
+              handle_stdout_read
+            rescue IOError, Errno::EPIPE => e
+              handle_stream_error(e, "Reader")
+              break unless @running
+            rescue StandardError => e
+              RubyLLM::MCP.logger.error "Error in reader thread: #{e.message}, #{e.backtrace.join("\n")}"
+              sleep 1
+            end
+          end
+        end
+
+        def handle_stdout_read
+          if @stdout.closed? || @wait_thread.nil? || !@wait_thread.alive?
+            if @running
+              sleep 1
+              restart_process
+            end
+            return
+          end
+
+          line = @stdout.gets
+          return unless line && !line.strip.empty?
+
+          process_response(line.strip)
+        end
+
+        def handle_stream_error(error, stream_name)
+          # Check @running to distinguish graceful shutdown from unexpected errors.
+          # During shutdown, streams are closed intentionally and shouldn't trigger restarts.
+          if @running
+            RubyLLM::MCP.logger.error "#{stream_name} error: #{error.message}. Restarting in 1 second..."
+            sleep 1
+            restart_process
+          else
+            # Graceful shutdown in progress
+            RubyLLM::MCP.logger.debug "#{stream_name} thread exiting during shutdown"
+          end
+        end
+
         def start_stderr_thread
           @stderr_thread = Thread.new do
-            while @running
-              begin
-                if @stderr.closed? || @wait_thread.nil? || !@wait_thread.alive?
-                  sleep 1
-                  next
-                end
-
-                line = @stderr.gets
-                next unless line && !line.strip.empty?
-
-                RubyLLM::MCP.logger.info(line.strip)
-              rescue IOError, Errno::EPIPE => e
-                RubyLLM::MCP.logger.error "Stderr reader error: #{e.message}"
-                sleep 1
-              rescue StandardError => e
-                RubyLLM::MCP.logger.error "Error in stderr thread: #{e.message}"
-                sleep 1
-              end
-            end
+            read_stderr_loop
           end
 
           @stderr_thread.abort_on_exception = true
         end
 
+        def read_stderr_loop
+          while @running
+            begin
+              handle_stderr_read
+            rescue IOError, Errno::EPIPE => e
+              handle_stream_error(e, "Stderr reader")
+              break unless @running
+            rescue StandardError => e
+              RubyLLM::MCP.logger.error "Error in stderr thread: #{e.message}"
+              sleep 1
+            end
+          end
+        end
+
+        def handle_stderr_read
+          if @stderr.closed? || @wait_thread.nil? || !@wait_thread.alive?
+            sleep 1
+            return
+          end
+
+          line = @stderr.gets
+          return unless line && !line.strip.empty?
+
+          RubyLLM::MCP.logger.info(line.strip)
+        end
+
         def process_response(line)
           response = JSON.parse(line)
           request_id = response["id"]&.to_s

data/lib/ruby_llm/mcp/version.rb

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

data/lib/ruby_llm/mcp.rb

@@ -62,9 +62,9 @@ module RubyLLM
     end
 
     def support_complex_parameters!
-      require_relative "mcp/providers/openai/complex_parameter_support"
-      require_relative "mcp/providers/anthropic/complex_parameter_support"
-      require_relative "mcp/providers/gemini/complex_parameter_support"
+      warn "[DEPRECATION] RubyLLM::MCP.support_complex_parameters! is no longer needed " \
+           "and will be removed in version 0.8.0"
+      # No-op: Complex parameters are now supported by default
     end
 
     def configure

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm-mcp
 version: !ruby/object:Gem::Version
-  version: 0.6.4
+  version: 0.7.1
 platform: ruby
 authors:
 - Patrick Vice
@@ -43,14 +43,14 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.9'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.3'
+        version: '1.9'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -97,13 +97,9 @@ files:
 - lib/ruby_llm/mcp/notifications/cancelled.rb
 - lib/ruby_llm/mcp/notifications/initialize.rb
 - lib/ruby_llm/mcp/notifications/roots_list_change.rb
-- lib/ruby_llm/mcp/parameter.rb
 - lib/ruby_llm/mcp/progress.rb
 - lib/ruby_llm/mcp/prompt.rb
 - lib/ruby_llm/mcp/protocol.rb
-- lib/ruby_llm/mcp/providers/anthropic/complex_parameter_support.rb
-- lib/ruby_llm/mcp/providers/gemini/complex_parameter_support.rb
-- lib/ruby_llm/mcp/providers/openai/complex_parameter_support.rb
 - lib/ruby_llm/mcp/railtie.rb
 - lib/ruby_llm/mcp/requests/completion_prompt.rb
 - lib/ruby_llm/mcp/requests/completion_resource.rb
@@ -149,7 +145,6 @@ metadata:
   homepage_uri: https://www.rubyllm-mcp.com
   source_code_uri: https://github.com/patvice/ruby_llm-mcp
   changelog_uri: https://github.com/patvice/ruby_llm-mcp/commits/main
-  documentation_uri: https://www.rubyllm-mcp.com
   bug_tracker_uri: https://github.com/patvice/ruby_llm-mcp/issues
   rubygems_mfa_required: 'true'
   allowed_push_host: https://rubygems.org

data/lib/ruby_llm/mcp/parameter.rb

@@ -1,49 +0,0 @@
-# frozen_string_literal: true
-
-require "ruby_llm/tool"
-
-module RubyLLM
-  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
-        @properties = {}
-        @union_type = union_type
-        @default = default
-      end
-
-      def item_type
-        @items&.dig("type")&.to_sym
-      end
-
-      def as_json(*_args)
-        to_h
-      end
-
-      def to_h
-        {
-          name: @name,
-          type: @type,
-          description: @desc,
-          required: @required,
-          default: @default,
-          union_type: @union_type,
-          items: @items&.to_h,
-          properties: @properties&.values,
-          enum: @enum
-        }
-      end
-    end
-  end
-end

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

@@ -1,87 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Providers
-      module Anthropic
-        module ComplexParameterSupport
-          module_function
-
-          def clean_parameters(parameters)
-            parameters.transform_values do |param|
-              mcp_build_properties(param).compact
-            end
-          end
-
-          def required_parameters(parameters)
-            parameters.select { |_, param| param.required }.keys
-          end
-
-          def mcp_build_properties(param) # rubocop:disable Metrics/MethodLength
-            case param.type
-            when :array
-              if param.item_type == :object
-                {
-                  type: param.type,
-                  title: param.title,
-                  description: param.description,
-                  items: { type: param.item_type, properties: clean_parameters(param.properties) }
-                }.compact
-              else
-                {
-                  type: param.type,
-                  title: param.title,
-                  description: param.description,
-                  default: param.default,
-                  items: { type: param.item_type, enum: param.enum }.compact
-                }.compact
-              end
-            when :object
-              {
-                type: param.type,
-                title: param.title,
-                description: param.description,
-                properties: clean_parameters(param.properties),
-                required: required_parameters(param.properties)
-              }.compact
-            when :union
-              {
-                param.union_type => param.properties.map { |property| mcp_build_properties(property) }
-              }
-            else
-              {
-                type: param.type,
-                title: param.title,
-                description: param.description
-              }.compact
-            end
-          end
-        end
-      end
-    end
-  end
-end
-
-module RubyLLM::Providers::Anthropic::Tools
-  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
-
-    original_required_parameters(parameters)
-  end
-  module_function :required_parameters
-end

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

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Providers
-      module Gemini
-        module ComplexParameterSupport
-          module_function
-
-          # Format tool parameters for Gemini API
-          def format_parameters(parameters)
-            {
-              type: "OBJECT",
-              properties: parameters.transform_values { |param| mcp_build_properties(param) },
-              required: parameters.select { |_, p| p.required }.keys.map(&:to_s)
-            }
-          end
-
-          def mcp_build_properties(param) # rubocop:disable Metrics/MethodLength
-            properties = case param.type
-                         when :array
-                           if param.item_type == :object
-                             {
-                               type: param_type_for_gemini(param.type),
-                               title: param.title,
-                               description: param.description,
-                               items: {
-                                 type: param_type_for_gemini(param.item_type),
-                                 properties: param.properties.transform_values { |value| mcp_build_properties(value) }
-                               }
-                             }.compact
-                           else
-                             {
-                               type: param_type_for_gemini(param.type),
-                               title: param.title,
-                               description: param.description,
-                               default: param.default,
-                               items: { type: param_type_for_gemini(param.item_type), enum: param.enum }.compact
-                             }.compact
-                           end
-                         when :object
-                           {
-                             type: param_type_for_gemini(param.type),
-                             title: param.title,
-                             description: param.description,
-                             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| mcp_build_properties(properties) }
-                           }
-                         else
-                           {
-                             type: param_type_for_gemini(param.type),
-                             title: param.title,
-                             description: param.description
-                           }
-                         end
-
-            properties.compact
-          end
-
-          def param_type_for_gemini(type)
-            RubyLLM::Providers::Gemini::Tools.param_type_for_gemini(type)
-          end
-        end
-      end
-    end
-  end
-end
-
-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

@@ -1,72 +0,0 @@
-# frozen_string_literal: true
-
-module RubyLLM
-  module MCP
-    module Providers
-      module OpenAI
-        module ComplexParameterSupport
-          module_function
-
-          def param_schema(param) # rubocop:disable Metrics/MethodLength
-            properties = case param.type
-                         when :array
-                           if param.item_type == :object
-                             {
-                               type: param.type,
-                               title: param.title,
-                               description: param.description,
-                               items: {
-                                 type: param.item_type,
-                                 properties: param.properties.transform_values { |value| param_schema(value) }
-                               }
-                             }.compact
-                           else
-                             {
-                               type: param.type,
-                               title: param.title,
-                               description: param.description,
-                               default: param.default,
-                               items: { type: param.item_type, enum: param.enum }.compact
-                             }.compact
-                           end
-                         when :object
-                           {
-                             type: param.type,
-                             title: param.title,
-                             description: param.description,
-                             properties: param.properties.transform_values { |value| param_schema(value) },
-                             required: param.properties.select { |_, p| p.required }.keys
-                           }.compact
-                         when :union
-                           {
-                             param.union_type => param.properties.map { |property| param_schema(property) }
-                           }
-                         else
-                           {
-                             type: param.type,
-                             title: param.title,
-                             description: param.description
-                           }.compact
-                         end
-
-            properties.compact
-          end
-        end
-      end
-    end
-  end
-end
-
-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