ruby_llm-mcp 0.6.4 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5bec47480f606a8d28f8a79032e392e331dcdcef565cd708e6dcc855f0a31445
-  data.tar.gz: ac65a564ce2bd4d39e4e4fdcff02da19cbd7573186924e938fadb2d9c2f523db
+  metadata.gz: 9c8d0ab416033fcafeed6caa5146ab4c5599d0576eb3a17b2e0c04bb4bbb2234
+  data.tar.gz: 207026831043126a1e0dfac10fbbe9e8a396edbe8ab874c8af04d1230d57de5c
 SHA512:
-  metadata.gz: 7e9394538e772a3169fe424854cbf57aee643953be4e44f805c82f0f81c61189a06d755e8a14b4e530183e414e9a4b3000912a577d3eca95da236c124b9a54dc
-  data.tar.gz: a6eb704e2aaac9386e54cb178dd136bc19510a2159adc63125d50f5a96c9473de9416e33755059f9578ab609d34fe3fbe8c8d7f8e970900380b93770793376a3
+  metadata.gz: 4fbae5a8e05f3df2ee2ef81469a7ca8159b03cde998c5881e6e32ab0353cdb22a3b03a3cf63e3464f95e05f71ed87f861d793e944683c72c90660162fb6263e5
+  data.tar.gz: 9888713bcb543421c389954a36d235f024e271163096a82473c4bf1b1c2b16737602c0b608ff28d653cf1ab636909f0b9c6120e228b74ecdc794f2b0ebfc3dc4

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/version.rb

@@ -2,6 +2,6 @@
 
 module RubyLLM
   module MCP
-    VERSION = "0.6.4"
+    VERSION = "0.7.0"
   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.0
 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

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