ruby_llm 1.2.0 → 1.3.0rc1

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

@@ -4,7 +4,7 @@ module RubyLLM
   module Providers
     module Gemini
       # Determines capabilities and pricing for Google Gemini models
-      module Capabilities # rubocop:disable Metrics/ModuleLength
+      module Capabilities
         module_function
 
         # Returns the context window size (input token limit) for the given model
@@ -144,7 +144,7 @@ module RubyLLM
         # Returns the model family identifier
         # @param model_id [String] the model identifier
         # @return [String] the model family identifier
-        def model_family(model_id) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        def model_family(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/ then 'gemini25_pro_exp'
           when /gemini-2\.0-flash-lite/ then 'gemini20_flash_lite'
@@ -164,7 +164,7 @@ module RubyLLM
         # 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) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        def pricing_family(model_id)
           case model_id
           when /gemini-2\.5-pro-exp-03-25/ then :pro_2_5 # rubocop:disable Naming/VariableNumber
           when /gemini-2\.0-flash-lite/ then :flash_lite_2 # rubocop:disable Naming/VariableNumber
@@ -261,6 +261,87 @@ module RubyLLM
         def default_output_price
           0.30 # Default to Flash pricing
         end
+
+        def modalities_for(model_id)
+          modalities = {
+            input: ['text'],
+            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/)
+
+          modalities
+        end
+
+        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
+
+        def pricing_for(model_id)
+          family = pricing_family(model_id)
+          prices = PRICES.fetch(family, { input: default_input_price, output: default_output_price })
+
+          standard_pricing = {
+            input_per_million: prices[:input],
+            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
+          }
+
+          if standard_pricing[:cached_input_per_million]
+            batch_pricing[:cached_input_per_million] = standard_pricing[:cached_input_per_million] * 0.5
+          end
+
+          pricing = {
+            text_tokens: {
+              standard: standard_pricing,
+              batch: batch_pricing
+            }
+          }
+
+          # Add embedding pricing if applicable
+          if model_id.match?(/embedding|gemini-embedding/)
+            pricing[:embeddings] = {
+              standard: { input_per_million: prices[:price] || 0.002 }
+            }
+          end
+
+          pricing
+        end
       end
     end
   end

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

@@ -5,32 +5,24 @@ module RubyLLM
     module Gemini
       # Chat methods for the Gemini API implementation
       module Chat
+        module_function
+
         def completion_url
           "models/#{@model}:generateContent"
         end
 
-        def complete(messages, tools:, temperature:, model:, &block) # rubocop:disable Metrics/MethodLength
-          @model = model
+        def render_payload(messages, tools:, temperature:, model:, stream: false) # rubocop:disable Lint/UnusedMethodArgument
+          @model = model # Store model for completion_url/stream_url
           payload = {
             contents: format_messages(messages),
             generationConfig: {
               temperature: temperature
             }
           }
-
           payload[:tools] = format_tools(tools) if tools.any?
-
-          # Store tools for use in generate_completion
-          @tools = tools
-
-          if block_given?
-            stream_response payload, &block
-          else
-            sync_response payload
-          end
+          payload
         end
 
-        # Format methods can be private
         private
 
         def format_messages(messages)
@@ -50,9 +42,8 @@ module RubyLLM
           end
         end
 
-        def format_parts(msg) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
+        def format_parts(msg)
           if msg.tool_call?
-            # Handle function calls
             [{
               functionCall: {
                 name: msg.tool_calls.values.first.name,
@@ -60,7 +51,6 @@ module RubyLLM
               }
             }]
           elsif msg.tool_result?
-            # Handle function responses
             [{
               functionResponse: {
                 name: msg.tool_call_id,
@@ -70,27 +60,8 @@ module RubyLLM
                 }
               }
             }]
-          elsif msg.content.is_a?(Array)
-            # Handle multi-part content (text, images, etc.)
-            msg.content.map { |part| format_part(part) }
-          else
-            # Simple text content
-            [{ text: msg.content.to_s }]
-          end
-        end
-
-        def format_part(part) # rubocop:disable Metrics/MethodLength
-          case part[:type]
-          when 'text'
-            { text: part[:text] }
-          when 'image'
-            Media.format_image(part)
-          when 'pdf'
-            Media.format_pdf(part)
-          when 'audio'
-            Media.format_audio(part)
           else
-            { text: part.to_s }
+            Media.format_content(msg.content)
           end
         end
 
@@ -108,7 +79,7 @@ module RubyLLM
           )
         end
 
-        def extract_content(data) # rubocop:disable Metrics/CyclomaticComplexity
+        def extract_content(data)
           candidate = data.dig('candidates', 0)
           return '' unless candidate
 

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

@@ -5,47 +5,31 @@ module RubyLLM
     module Gemini
       # Embeddings methods for the Gemini API integration
       module Embeddings
-        # Must be public for Provider module
-        def embed(text, model:) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          payload = {
-            content: {
-              parts: format_text_for_embedding(text)
-            }
-          }
+        module_function
 
-          url = "models/#{model}:embedContent"
-          response = post(url, payload)
+        def embedding_url(model:)
+          "models/#{model}:batchEmbedContents"
+        end
+
+        def render_embedding_payload(text, model:, dimensions:)
+          { requests: [text].flatten.map { |t| single_embedding_payload(t, model:, dimensions:) } }
+        end
 
-          if text.is_a?(Array)
-            # We need to make separate calls for each text with Gemini
-            embeddings = text.map do |t|
-              single_payload = { content: { parts: [{ text: t.to_s }] } }
-              single_response = post(url, single_payload)
-              single_response.body.dig('embedding', 'values')
-            end
+        def parse_embedding_response(response, model:)
+          vectors = response.body['embeddings']&.map { |e| e['values'] }
+          vectors in [vectors]
 
-            Embedding.new(
-              vectors: embeddings,
-              model: model,
-              input_tokens: response.body.dig('usageMetadata', 'promptTokenCount') || 0
-            )
-          else
-            Embedding.new(
-              vectors: response.body.dig('embedding', 'values'),
-              model: model,
-              input_tokens: response.body.dig('usageMetadata', 'promptTokenCount') || 0
-            )
-          end
+          Embedding.new(vectors:, model:, input_tokens: 0)
         end
 
         private
 
-        def format_text_for_embedding(text)
-          if text.is_a?(Array)
-            text.map { |t| { text: t.to_s } }
-          else
-            [{ text: text.to_s }]
-          end
+        def single_embedding_payload(text, model:, dimensions:)
+          {
+            model: "models/#{model}",
+            content: { parts: [{ text: text.to_s }] },
+            outputDimensionality: dimensions
+          }.compact
         end
       end
     end

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:) # rubocop:disable Metrics/MethodLength
+        def render_image_payload(prompt, model:, size:)
           RubyLLM.logger.debug "Ignoring size #{size}. Gemini does not support image size customization."
           @model = model
           {
@@ -24,7 +24,7 @@ module RubyLLM
           }
         end
 
-        def parse_image_response(response) # rubocop:disable Metrics/MethodLength
+        def parse_image_response(response)
           data = response.body
           image_data = data['predictions']&.first
 

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

@@ -4,131 +4,60 @@ module RubyLLM
   module Providers
     module Gemini
       # Media handling methods for the Gemini API integration
-      module Media # rubocop:disable Metrics/ModuleLength
+      module Media
         module_function
 
-        def format_image(part) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength,Metrics/PerceivedComplexity
-          source = part[:source]
+        def format_content(content)
+          return [format_text(content)] unless content.is_a?(Content)
 
-          if source.is_a?(String)
-            if source.start_with?('http')
-              # Handle URL
-              {
-                inline_data: {
-                  mime_type: mime_type_for_image(source),
-                  data: fetch_and_encode_image(source)
-                }
-              }
-            else
-              # Handle file path
-              {
-                inline_data: {
-                  mime_type: mime_type_for_image(source),
-                  data: encode_image_file(source)
-                }
-              }
-            end
-          elsif source.is_a?(Hash)
-            if source[:url]
-              # Handle URL in hash
-              {
-                inline_data: {
-                  mime_type: source[:media_type] || mime_type_for_image(source[:url]),
-                  data: fetch_and_encode_image(source[:url])
-                }
-              }
-            else
-              # Handle data in hash
-              {
-                inline_data: {
-                  mime_type: source[:media_type] || 'image/jpeg',
-                  data: source[:data]
-                }
-              }
+          parts = []
+          parts << format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment
+            when Attachments::Image
+              parts << format_image(attachment)
+            when Attachments::PDF
+              parts << format_pdf(attachment)
+            when Attachments::Audio
+              parts << format_audio(attachment)
             end
           end
-        end
 
-        def format_pdf(part) # rubocop:disable Metrics/MethodLength
-          source = part[:source]
-
-          if source.is_a?(String) && source.start_with?('http')
-            # Handle URL
-            {
-              inline_data: {
-                mime_type: 'application/pdf',
-                data: fetch_and_encode_pdf(source)
-              }
-            }
-          else
-            # Handle file path or data
-            {
-              inline_data: {
-                mime_type: 'application/pdf',
-                data: part[:content] ? Base64.strict_encode64(part[:content]) : encode_pdf_file(source)
-              }
-            }
-          end
+          parts
         end
 
-        def format_audio(part) # rubocop:disable Metrics/MethodLength
-          source = part[:source]
-
-          if source.is_a?(String) && source.start_with?('http')
-            # Handle URL
-            {
-              file_data: {
-                mime_type: mime_type_for_audio(source),
-                file_uri: source
-              }
+        def format_image(image)
+          {
+            inline_data: {
+              mime_type: image.mime_type,
+              data: image.encoded
             }
-          else
-            # Handle file path or data
-            content = part[:content] || File.read(source)
-            {
-              inline_data: {
-                mime_type: mime_type_for_audio(source),
-                data: Base64.strict_encode64(content)
-              }
-            }
-          end
+          }
         end
 
-        def mime_type_for_image(path)
-          ext = File.extname(path).downcase.delete('.')
-          case ext
-          when 'png' then 'image/png'
-          when 'gif' then 'image/gif'
-          when 'webp' then 'image/webp'
-          else 'image/jpeg'
-          end
-        end
-
-        def mime_type_for_audio(path)
-          ext = File.extname(path).downcase.delete('.')
-          case ext
-          when 'mp3' then 'audio/mpeg'
-          when 'ogg' then 'audio/ogg'
-          else 'audio/wav'
-          end
-        end
-
-        def fetch_and_encode_image(url)
-          response = Faraday.get(url)
-          Base64.strict_encode64(response.body)
-        end
-
-        def fetch_and_encode_pdf(url)
-          response = Faraday.get(url)
-          Base64.strict_encode64(response.body)
+        def format_pdf(pdf)
+          {
+            inline_data: {
+              mime_type: pdf.mime_type,
+              data: pdf.encoded
+            }
+          }
         end
 
-        def encode_image_file(path)
-          Base64.strict_encode64(File.read(path))
+        def format_audio(audio)
+          {
+            inline_data: {
+              mime_type: audio.mime_type,
+              data: audio.encoded
+            }
+          }
         end
 
-        def encode_pdf_file(path)
-          Base64.strict_encode64(File.read(path))
+        def format_text(text)
+          {
+            text: text
+          }
         end
       end
     end

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

@@ -5,39 +5,33 @@ module RubyLLM
     module Gemini
       # Models methods for the Gemini API integration
       module Models
-        # Methods needed by Provider - must be public
+        module_function
+
         def models_url
           'models'
         end
 
-        private
-
-        def parse_list_models_response(response, slug, capabilities) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-          (response.body['models'] || []).map do |model|
+        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['name'].gsub('models/', '')
+            model_id = model_data['name'].gsub('models/', '')
 
             ModelInfo.new(
               id: model_id,
-              created_at: nil,
-              display_name: model['displayName'],
+              name: model_data['displayName'],
               provider: slug,
-              type: capabilities.model_type(model_id),
               family: capabilities.model_family(model_id),
+              created_at: nil, # Gemini API doesn't provide creation date
+              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),
+              capabilities: capabilities.capabilities_for(model_id),
+              pricing: capabilities.pricing_for(model_id),
               metadata: {
-                version: model['version'],
-                description: model['description'],
-                input_token_limit: model['inputTokenLimit'],
-                output_token_limit: model['outputTokenLimit'],
-                supported_generation_methods: model['supportedGenerationMethods']
-              },
-              context_window: model['inputTokenLimit'] || capabilities.context_window_for(model_id),
-              max_tokens: model['outputTokenLimit'] || capabilities.max_tokens_for(model_id),
-              supports_vision: capabilities.supports_vision?(model_id),
-              supports_functions: capabilities.supports_functions?(model_id),
-              supports_json_mode: capabilities.supports_json_mode?(model_id),
-              input_price_per_million: capabilities.input_price_for(model_id),
-              output_price_per_million: capabilities.output_price_for(model_id)
+                version: model_data['version'],
+                description: model_data['description'],
+                supported_generation_methods: model_data['supportedGenerationMethods']
+              }
             )
           end
         end

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

@@ -15,7 +15,7 @@ module RubyLLM
         end
 
         # Extract tool calls from response data
-        def extract_tool_calls(data) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+        def extract_tool_calls(data)
           return nil unless data
 
           # Get the first candidate

data/lib/ruby_llm/providers/gemini.rb

@@ -15,13 +15,13 @@ module RubyLLM
 
       module_function
 
-      def api_base
+      def api_base(_config)
         'https://generativelanguage.googleapis.com/v1beta'
       end
 
-      def headers
+      def headers(config)
         {
-          'x-goog-api-key' => RubyLLM.config.gemini_api_key
+          'x-goog-api-key' => config.gemini_api_key
         }
       end
 

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

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Ollama
+      # Chat methods of the Ollama API integration
+      module Chat
+        module_function
+
+        def format_messages(messages)
+          messages.map do |msg|
+            {
+              role: format_role(msg.role),
+              content: Ollama::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)
+          # Ollama doesn't use the new OpenAI convention for system prompts
+          role.to_s
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Ollama
+      # Handles formatting of media content (images, audio) for OpenAI APIs
+      module Media
+        extend OpenAI::Media
+
+        module_function
+
+        def format_content(content)
+          return content unless content.is_a?(Content)
+
+          parts = []
+          parts << format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment
+            when Attachments::Image
+              parts << Ollama::Media.format_image(attachment)
+            when Attachments::PDF
+              parts << format_pdf(attachment)
+            when Attachments::Audio
+              parts << format_audio(attachment)
+            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

data/lib/ruby_llm/providers/ollama.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    # Ollama API integration.
+    module Ollama
+      extend OpenAI
+      extend Ollama::Chat
+      extend Ollama::Media
+
+      module_function
+
+      def api_base(config)
+        config.ollama_api_base
+      end
+
+      def headers(_config)
+        {}
+      end
+
+      def slug
+        'ollama'
+      end
+
+      def configuration_requirements
+        %i[ollama_api_base]
+      end
+
+      def local?
+        true
+      end
+    end
+  end
+end