ruby_llm_community 0.0.6 → 1.0.0

data/lib/ruby_llm/providers/gemini/capabilities.rb

@@ -7,9 +7,6 @@ module RubyLLM
       module Capabilities
         module_function
 
-        # Returns the context window size (input token limit) for the given model
-        # @param model_id [String] the model identifier
-        # @return [Integer] the context window size in tokens
         def context_window_for(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/, /gemini-2\.0-flash/, /gemini-2\.0-flash-lite/, /gemini-1\.5-flash/, /gemini-1\.5-flash-8b/ # rubocop:disable Layout/LineLength
@@ -18,70 +15,49 @@ module RubyLLM
           when /gemini-embedding-exp/ then 8_192
           when /text-embedding-004/, /embedding-001/ then 2_048
           when /aqa/ then 7_168
-          when /imagen-3/ then nil # No token limit for image generation
-          else 32_768 # Sensible default for unknown models
+          when /imagen-3/ then nil
+          else 32_768
           end
         end
 
-        # Returns the maximum output tokens for the given model
-        # @param model_id [String] the model identifier
-        # @return [Integer] the maximum output tokens
         def max_tokens_for(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/ then 64_000
           when /gemini-2\.0-flash/, /gemini-2\.0-flash-lite/, /gemini-1\.5-flash/, /gemini-1\.5-flash-8b/, /gemini-1\.5-pro/ # rubocop:disable Layout/LineLength
             8_192
-          when /gemini-embedding-exp/ then nil # Elastic, supports 3072, 1536, or 768
-          when /text-embedding-004/, /embedding-001/ then 768 # Output dimension size for embeddings
-          when /aqa/ then 1_024
-          when /imagen-3/ then 4 # Output images
-          else 4_096 # Sensible default
+          when /gemini-embedding-exp/ then nil
+          when /text-embedding-004/, /embedding-001/ then 768
+          when /imagen-3/ then 4
+          else 4_096
           end
         end
 
-        # Returns the input price per million tokens for the given model
-        # @param model_id [String] the model identifier
-        # @return [Float] the price per million tokens in USD
         def input_price_for(model_id)
           base_price = PRICES.dig(pricing_family(model_id), :input) || default_input_price
           return base_price unless long_context_model?(model_id)
 
-          # Apply different pricing for prompts longer than 128k tokens
           context_window_for(model_id) > 128_000 ? base_price * 2 : base_price
         end
 
-        # Returns the output price per million tokens for the given model
-        # @param model_id [String] the model identifier
-        # @return [Float] the price per million tokens in USD
         def output_price_for(model_id)
           base_price = PRICES.dig(pricing_family(model_id), :output) || default_output_price
           return base_price unless long_context_model?(model_id)
 
-          # Apply different pricing for prompts longer than 128k tokens
           context_window_for(model_id) > 128_000 ? base_price * 2 : base_price
         end
 
-        # Determines if the model supports vision (image/video) inputs
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports vision inputs
         def supports_vision?(model_id)
           return false if model_id.match?(/text-embedding|embedding-001|aqa/)
 
           model_id.match?(/gemini|flash|pro|imagen/)
         end
 
-        # Determines if the model supports function calling
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports function calling
         def supports_functions?(model_id)
           return false if model_id.match?(/text-embedding|embedding-001|aqa|flash-lite|imagen|gemini-2\.0-flash-lite/)
 
           model_id.match?(/gemini|pro|flash/)
         end
 
-        # Determines if the model supports JSON mode
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports JSON mode
         def supports_json_mode?(model_id)
           if model_id.match?(/text-embedding|embedding-001|aqa|imagen|gemini-2\.0-flash-lite|gemini-2\.5-pro-exp-03-25/)
             return false
@@ -90,24 +66,18 @@ module RubyLLM
           model_id.match?(/gemini|pro|flash/)
         end
 
-        # Formats the model ID into a human-readable display name
-        # @param model_id [String] the model identifier
-        # @return [String] the formatted display name
         def format_display_name(model_id)
           model_id
             .delete_prefix('models/')
             .split('-')
             .map(&:capitalize)
             .join(' ')
-            .gsub(/(\d+\.\d+)/, ' \1') # Add space before version numbers
-            .gsub(/\s+/, ' ')          # Clean up multiple spaces
-            .gsub('Aqa', 'AQA')        # Special case for AQA
+            .gsub(/(\d+\.\d+)/, ' \1')
+            .gsub(/\s+/, ' ')
+            .gsub('Aqa', 'AQA')
             .strip
         end
 
-        # Determines if the model supports context caching
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports caching
         def supports_caching?(model_id)
           if model_id.match?(/flash-lite|gemini-2\.5-pro-exp-03-25|aqa|imagen|text-embedding|embedding-001/)
             return false
@@ -116,23 +86,14 @@ module RubyLLM
           model_id.match?(/gemini|pro|flash/)
         end
 
-        # Determines if the model supports tuning
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports tuning
         def supports_tuning?(model_id)
           model_id.match?(/gemini-1\.5-flash|gemini-1\.5-flash-8b/)
         end
 
-        # Determines if the model supports audio inputs
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports audio inputs
         def supports_audio?(model_id)
           model_id.match?(/gemini|pro|flash/)
         end
 
-        # Returns the type of model (chat, embedding, image)
-        # @param model_id [String] the model identifier
-        # @return [String] the model type
         def model_type(model_id)
           case model_id
           when /text-embedding|embedding|gemini-embedding/ then 'embedding'
@@ -141,9 +102,6 @@ module RubyLLM
           end
         end
 
-        # Returns the model family identifier
-        # @param model_id [String] the model identifier
-        # @return [String] the model family identifier
         def model_family(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/ then 'gemini25_pro_exp'
@@ -161,9 +119,6 @@ module RubyLLM
           end
         end
 
-        # Returns the pricing family identifier for the model
-        # @param model_id [String] the model identifier
-        # @return [Symbol] the pricing family identifier
         def pricing_family(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/ then :pro_2_5 # rubocop:disable Naming/VariableNumber
@@ -180,86 +135,75 @@ module RubyLLM
           end
         end
 
-        # Determines if the model supports long context
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports long context
         def long_context_model?(model_id)
           model_id.match?(/gemini-1\.5-(?:pro|flash)|gemini-1\.5-flash-8b/)
         end
 
-        # Returns the context length for the model
-        # @param model_id [String] the model identifier
-        # @return [Integer] the context length in tokens
         def context_length(model_id)
           context_window_for(model_id)
         end
 
-        # Pricing information for Gemini models (per 1M tokens in USD)
         PRICES = {
-          flash_2: { # Gemini 2.0 Flash # rubocop:disable Naming/VariableNumber
+          flash_2: { # rubocop:disable Naming/VariableNumber
             input: 0.10,
             output: 0.40,
             audio_input: 0.70,
             cache: 0.025,
             cache_storage: 1.00,
-            grounding_search: 35.00 # per 1K requests after 1.5K free
+            grounding_search: 35.00
           },
-          flash_lite_2: { # Gemini 2.0 Flash Lite # rubocop:disable Naming/VariableNumber
+          flash_lite_2: { # rubocop:disable Naming/VariableNumber
             input: 0.075,
             output: 0.30
           },
-          flash: { # Gemini 1.5 Flash
+          flash: {
             input: 0.075,
             output: 0.30,
             cache: 0.01875,
             cache_storage: 1.00,
-            grounding_search: 35.00 # per 1K requests up to 5K per day
+            grounding_search: 35.00
           },
-          flash_8b: { # Gemini 1.5 Flash 8B
+          flash_8b: {
             input: 0.0375,
             output: 0.15,
             cache: 0.01,
             cache_storage: 0.25,
-            grounding_search: 35.00 # per 1K requests up to 5K per day
+            grounding_search: 35.00
           },
-          pro: { # Gemini 1.5 Pro
+          pro: {
             input: 1.25,
             output: 5.0,
             cache: 0.3125,
             cache_storage: 4.50,
-            grounding_search: 35.00 # per 1K requests up to 5K per day
+            grounding_search: 35.00
           },
-          pro_2_5: { # Gemini 2.5 Pro Experimental # rubocop:disable Naming/VariableNumber
+          pro_2_5: { # rubocop:disable Naming/VariableNumber
             input: 0.12,
             output: 0.50
           },
-          gemini_embedding: { # Gemini Embedding Experimental
+          gemini_embedding: {
             input: 0.002,
             output: 0.004
           },
-          embedding: { # Text Embedding models
+          embedding: {
             input: 0.00,
             output: 0.00
           },
-          imagen: { # Imagen 3
-            price: 0.03 # per image
+          imagen: {
+            price: 0.03
           },
-          aqa: { # AQA model
+          aqa: {
             input: 0.00,
             output: 0.00
           }
         }.freeze
 
-        # Default input price for unknown models
-        # @return [Float] the default input price per million tokens
         def default_input_price
-          0.075 # Default to Flash pricing
+          0.075
         end
 
-        # Default output price for unknown models
-        # @return [Float] the default output price per million tokens
         def default_output_price
-          0.30 # Default to Flash pricing
+          0.30
         end
 
         def modalities_for(model_id)
@@ -268,19 +212,16 @@ module RubyLLM
             output: ['text']
           }
 
-          # Vision support
           if supports_vision?(model_id)
             modalities[:input] << 'image'
             modalities[:input] << 'pdf'
           end
 
-          # Audio support
           modalities[:input] << 'audio' if model_id.match?(/audio/)
-
-          # Embedding output
           modalities[:output] << 'embeddings' if model_id.match?(/embedding|gemini-embedding/)
 
-          # Image output for imagen models
+          modalities[:output] << 'image' if model_id.match?(/image-generation/)
+
           modalities[:output] = ['image'] if model_id.match?(/imagen/)
 
           modalities
@@ -289,21 +230,11 @@ module RubyLLM
         def capabilities_for(model_id)
           capabilities = ['streaming']
 
-          # Function calling
           capabilities << 'function_calling' if supports_functions?(model_id)
-
-          # JSON mode
           capabilities << 'structured_output' if supports_json_mode?(model_id)
-
-          # Batch processing
           capabilities << 'batch' if model_id.match?(/embedding|flash/)
-
-          # Caching
           capabilities << 'caching' if supports_caching?(model_id)
-
-          # Tuning
           capabilities << 'fine_tuning' if supports_tuning?(model_id)
-
           capabilities
         end
 
@@ -316,10 +247,8 @@ module RubyLLM
             output_per_million: prices[:output]
           }
 
-          # Add cached pricing if available
           standard_pricing[:cached_input_per_million] = prices[:input_hit] if prices[:input_hit]
 
-          # Batch pricing (typically 50% discount)
           batch_pricing = {
             input_per_million: (standard_pricing[:input_per_million] || 0) * 0.5,
             output_per_million: (standard_pricing[:output_per_million] || 0) * 0.5
@@ -336,7 +265,6 @@ module RubyLLM
             }
           }
 
-          # Add embedding pricing if applicable
           if model_id.match?(/embedding|gemini-embedding/)
             pricing[:embeddings] = {
               standard: { input_per_million: prices[:price] || 0.002 }

data/lib/ruby_llm/providers/gemini/chat.rb

@@ -12,14 +12,16 @@ module RubyLLM
         end
 
         def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil, cache_prompts: {}) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
-          @model = model # Store model for completion_url/stream_url
+          @model = model.id
           payload = {
             contents: format_messages(messages),
             generationConfig: {
-              temperature: temperature
+              responseModalities: capabilities.modalities_for(model.id)[:output]
             }
           }
 
+          payload[:generationConfig][:temperature] = temperature unless temperature.nil?
+
           if schema
             payload[:generationConfig][:responseMimeType] = 'application/json'
             payload[:generationConfig][:responseSchema] = convert_schema_to_gemini(schema)
@@ -43,7 +45,7 @@ module RubyLLM
         def format_role(role)
           case role
           when :assistant then 'model'
-          when :system, :tool then 'user' # Gemini doesn't have system, use user role, function responses use user role
+          when :system, :tool then 'user'
           else role.to_s
           end
         end
@@ -62,7 +64,7 @@ module RubyLLM
                 name: msg.tool_call_id,
                 response: {
                   name: msg.tool_call_id,
-                  content: msg.content
+                  content: Media.format_content(msg.content)
                 }
               }
             }]
@@ -87,31 +89,12 @@ module RubyLLM
           )
         end
 
-        def convert_schema_to_gemini(schema) # rubocop:disable Metrics/PerceivedComplexity
+        def convert_schema_to_gemini(schema)
           return nil unless schema
 
-          case schema[:type]
-          when 'object'
-            {
-              type: 'OBJECT',
-              properties: schema[:properties]&.transform_values { |prop| convert_schema_to_gemini(prop) } || {},
-              required: schema[:required] || []
-            }
-          when 'array'
-            {
-              type: 'ARRAY',
-              items: schema[:items] ? convert_schema_to_gemini(schema[:items]) : { type: 'STRING' }
-            }
-          when 'string'
-            result = { type: 'STRING' }
-            result[:enum] = schema[:enum] if schema[:enum]
-            result
-          when 'number', 'integer'
-            { type: 'NUMBER' }
-          when 'boolean'
-            { type: 'BOOLEAN' }
-          else
-            { type: 'STRING' }
+          build_base_schema(schema).tap do |result|
+            result[:description] = schema[:description] if schema[:description]
+            apply_type_specific_attributes(result, schema)
           end
         end
 
@@ -119,10 +102,8 @@ module RubyLLM
           candidate = data.dig('candidates', 0)
           return '' unless candidate
 
-          # Content will be empty for function calls
           return '' if function_call?(candidate)
 
-          # Extract text content
           parts = candidate.dig('content', 'parts')
           text_parts = parts&.select { |p| p['text'] }
           return '' unless text_parts&.any?
@@ -140,6 +121,53 @@ module RubyLLM
           thoughts = data.dig('usageMetadata', 'thoughtsTokenCount') || 0
           candidates + thoughts
         end
+
+        def build_base_schema(schema)
+          case schema[:type]
+          when 'object'
+            build_object_schema(schema)
+          when 'array'
+            { type: 'ARRAY', items: schema[:items] ? convert_schema_to_gemini(schema[:items]) : { type: 'STRING' } }
+          when 'number'
+            { type: 'NUMBER' }
+          when 'integer'
+            { type: 'INTEGER' }
+          when 'boolean'
+            { type: 'BOOLEAN' }
+          else
+            { type: 'STRING' }
+          end
+        end
+
+        def build_object_schema(schema)
+          {
+            type: 'OBJECT',
+            properties: (schema[:properties] || {}).transform_values { |prop| convert_schema_to_gemini(prop) },
+            required: schema[:required] || []
+          }.tap do |object|
+            object[:propertyOrdering] = schema[:propertyOrdering] if schema[:propertyOrdering]
+            object[:nullable] = schema[:nullable] if schema.key?(:nullable)
+          end
+        end
+
+        def apply_type_specific_attributes(result, schema)
+          case schema[:type]
+          when 'string'
+            copy_attributes(result, schema, :enum, :format, :nullable)
+          when 'number', 'integer'
+            copy_attributes(result, schema, :format, :minimum, :maximum, :enum, :nullable)
+          when 'array'
+            copy_attributes(result, schema, :minItems, :maxItems, :nullable)
+          when 'boolean'
+            copy_attributes(result, schema, :nullable)
+          end
+        end
+
+        def copy_attributes(target, source, *attributes)
+          attributes.each do |attr|
+            target[attr] = source[attr] if attr == :nullable ? source.key?(attr) : source[attr]
+          end
+        end
       end
     end
   end

data/lib/ruby_llm/providers/gemini/embeddings.rb

@@ -17,8 +17,6 @@ module RubyLLM
 
         def parse_embedding_response(response, model:, text:)
           vectors = response.body['embeddings']&.map { |e| e['values'] }
-          # If we only got one embedding AND the input was a single string (not an array),
-          # return it as a single vector
           vectors = vectors.first if vectors&.length == 1 && !text.is_a?(Array)
 
           Embedding.new(vectors:, model:, input_tokens: 0)

data/lib/ruby_llm/providers/gemini/images.rb

@@ -9,7 +9,7 @@ module RubyLLM
           "models/#{@model}:predict"
         end
 
-        def render_image_payload(prompt, model:, size:)
+        def render_image_payload(prompt, model:, size:, with:, params:) # rubocop:disable Lint/UnusedMethodArgument
           RubyLLM.logger.debug "Ignoring size #{size}. Gemini does not support image size customization."
           @model = model
           {
@@ -32,7 +32,6 @@ module RubyLLM
             raise Error, 'Unexpected response format from Gemini image generation API'
           end
 
-          # Extract mime type and base64 data
           mime_type = image_data['mimeType'] || 'image/png'
           base64_data = image_data['bytesBase64Encoded']
 

data/lib/ruby_llm/providers/gemini/media.rb

@@ -8,7 +8,6 @@ module RubyLLM
         module_function
 
         def format_content(content)
-          # Convert Hash/Array back to JSON string for API
           return [format_text(content.to_json)] if content.is_a?(Hash) || content.is_a?(Array)
           return [format_text(content)] unless content.is_a?(Content)
 

data/lib/ruby_llm/providers/gemini/models.rb

@@ -13,7 +13,6 @@ module RubyLLM
 
         def parse_list_models_response(response, slug, capabilities)
           Array(response.body['models']).map do |model_data|
-            # Extract model ID without "models/" prefix
             model_id = model_data['name'].gsub('models/', '')
 
             Model::Info.new(
@@ -21,7 +20,7 @@ module RubyLLM
               name: model_data['displayName'],
               provider: slug,
               family: capabilities.model_family(model_id),
-              created_at: nil, # Gemini API doesn't provide creation date
+              created_at: nil,
               context_window: model_data['inputTokenLimit'] || capabilities.context_window_for(model_id),
               max_output_tokens: model_data['outputTokenLimit'] || capabilities.max_tokens_for(model_id),
               modalities: capabilities.modalities_for(model_id),

data/lib/ruby_llm/providers/gemini/streaming.rb

@@ -35,7 +35,21 @@ module RubyLLM
           return nil unless parts
 
           text_parts = parts.select { |p| p['text'] }
-          text_parts.map { |p| p['text'] }.join if text_parts.any?
+          image_parts = parts.select { |p| p['inlineData'] }
+
+          content = RubyLLM::Content.new(text_parts.map { |p| p['text'] }.join)
+
+          image_parts.map do |p|
+            content.attach(
+              ImageAttachment.new(
+                data: p['inlineData']['data'],
+                mime_type: p['inlineData']['mimeType'],
+                model_id: data['modelVersion']
+              )
+            )
+          end
+
+          content
         end
 
         def extract_input_tokens(data)

data/lib/ruby_llm/providers/gemini/tools.rb

@@ -5,7 +5,6 @@ module RubyLLM
     class Gemini
       # Tools methods for the Gemini API implementation
       module Tools
-        # Format tools for Gemini API
         def format_tools(tools)
           return [] if tools.empty?
 
@@ -14,7 +13,6 @@ module RubyLLM
           }]
         end
 
-        # Extract tool calls from response data
         def extract_tool_calls(data)
           return nil unless data
 
@@ -43,7 +41,6 @@ module RubyLLM
 
         private
 
-        # Format a single tool for Gemini API
         def function_declaration_for(tool)
           {
             name: tool.name,
@@ -52,7 +49,6 @@ module RubyLLM
           }.compact
         end
 
-        # Format tool parameters for Gemini API
         def format_parameters(parameters)
           {
             type: 'OBJECT',
@@ -66,7 +62,6 @@ module RubyLLM
           }
         end
 
-        # Convert RubyLLM param types to Gemini API types
         def param_type_for_gemini(type)
           case type.to_s.downcase
           when 'integer', 'number', 'float' then 'NUMBER'

data/lib/ruby_llm/providers/gpustack/chat.rb

@@ -7,8 +7,18 @@ module RubyLLM
       module Chat
         module_function
 
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: GPUStack::Media.format_content(msg.content),
+              tool_calls: format_tool_calls(msg.tool_calls),
+              tool_call_id: msg.tool_call_id
+            }.compact
+          end
+        end
+
         def format_role(role)
-          # GPUStack doesn't use the new OpenAI convention for system prompts
           role.to_s
         end
       end

data/lib/ruby_llm/providers/gpustack/media.rb

@@ -0,0 +1,45 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class GPUStack
+      # Handles formatting of media content (images, audio) for GPUStack APIs
+      module Media
+        extend OpenAI::Media
+
+        module_function
+
+        def format_content(content)
+          return content.to_json if content.is_a?(Hash) || content.is_a?(Array)
+          return content unless content.is_a?(Content)
+
+          parts = []
+          parts << format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment.type
+            when :image
+              parts << GPUStack::Media.format_image(attachment)
+            when :text
+              parts << format_text_file(attachment)
+            else
+              raise UnsupportedAttachmentError, attachment.mime_type
+            end
+          end
+
+          parts
+        end
+
+        def format_image(image)
+          {
+            type: 'image_url',
+            image_url: {
+              url: "data:#{image.mime_type};base64,#{image.encoded}",
+              detail: 'auto'
+            }
+          }
+        end
+      end
+    end
+  end
+end