Merge pull request #24 from josh-m-sharpe/description_fix

include description in all complex types

Author: patvice

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

@@ -23,21 +23,24 @@ def build_properties(param)
               if param.item_type == :object
                 {
                   type: param.type,
+                  description: param.description,
                   items: { type: param.item_type, properties: clean_parameters(param.properties) }
-                }
+                }.compact
               else
                 {
                   type: param.type,
+                  description: param.description,
                   default: param.default,
                   items: { type: param.item_type, enum: param.enum }.compact
                 }.compact
               end
             when :object
               {
                 type: param.type,
+                description: param.description,
                 properties: clean_parameters(param.properties),
                 required: required_parameters(param.properties)
-              }
+              }.compact
             when :union
               {
                 param.union_type => param.properties.map { |property| build_properties(property) }

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

@@ -16,30 +16,33 @@ def format_parameters(parameters)
             }
           end
 
-          def build_properties(param)
+          def 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),
+                               description: param.description,
                                items: {
                                  type: param_type_for_gemini(param.item_type),
                                  properties: param.properties.transform_values { |value| build_properties(value) }
                                }
-                             }
+                             }.compact
                            else
                              {
                                type: param_type_for_gemini(param.type),
+                               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),
+                             description: param.description,
                              properties: param.properties.transform_values { |value| build_properties(value) },
                              required: param.properties.select { |_, p| p.required }.keys
-                           }
+                           }.compact
                          when :union
                            {
                              param.union_type => param.properties.map { |properties| build_properties(properties) }

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

@@ -7,30 +7,33 @@ module OpenAI
         module ComplexParameterSupport
           module_function
 
-          def param_schema(param)
+          def param_schema(param) # rubocop:disable Metrics/MethodLength
             properties = case param.type
                          when :array
                            if param.item_type == :object
                              {
                                type: param.type,
+                               description: param.description,
                                items: {
                                  type: param.item_type,
                                  properties: param.properties.transform_values { |value| param_schema(value) }
                                }
-                             }
+                             }.compact
                            else
                              {
                                type: param.type,
+                               description: param.description,
                                default: param.default,
                                items: { type: param.item_type, enum: param.enum }.compact
                              }.compact
                            end
                          when :object
                            {
                              type: param.type,
+                             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) }