ruby_llm 1.6.3 → 1.7.0

data/lib/ruby_llm/models.rb

@@ -22,16 +22,20 @@ module RubyLLM
         File.expand_path('models_schema.json', __dir__)
       end
 
-      def refresh!
-        provider_models = fetch_from_providers
+      def refresh!(remote_only: false)
+        provider_models = fetch_from_providers(remote_only: remote_only)
         parsera_models = fetch_from_parsera
         merged_models = merge_models(provider_models, parsera_models)
         @instance = new(merged_models)
       end
 
-      def fetch_from_providers
+      def fetch_from_providers(remote_only: true)
         config = RubyLLM.config
-        configured_classes = Provider.configured_remote_providers(config)
+        configured_classes = if remote_only
+                               Provider.configured_remote_providers(config)
+                             else
+                               Provider.configured_providers(config)
+                             end
         configured = configured_classes.map { |klass| klass.new(config) }
 
         RubyLLM.logger.info "Fetching models from providers: #{configured.map(&:name).join(', ')}"
@@ -54,14 +58,15 @@ module RubyLLM
           provider_class ||= raise(Error, "Unknown provider: #{provider.to_sym}")
           provider_instance = provider_class.new(config)
 
-          model = Model::Info.new(
-            id: model_id,
-            name: model_id.tr('-', ' ').capitalize,
-            provider: provider_instance.slug,
-            capabilities: %w[function_calling streaming],
-            modalities: { input: %w[text image], output: %w[text] },
-            metadata: { warning: 'Assuming model exists, capabilities may not be accurate' }
-          )
+          model = if provider_instance.local?
+                    begin
+                      Models.find(model_id, provider)
+                    rescue ModelNotFoundError
+                      nil
+                    end
+                  end
+
+          model ||= Model::Info.default(model_id, provider_instance.slug)
         else
           model = Models.find model_id, provider
           provider_class = Provider.providers[model.provider.to_sym] || raise(Error,
@@ -102,20 +107,36 @@ module RubyLLM
         all_keys = parsera_by_key.keys | provider_by_key.keys
 
         models = all_keys.map do |key|
-          if (parsera_model = parsera_by_key[key])
-            if (provider_model = provider_by_key[key])
-              add_provider_metadata(parsera_model, provider_model)
-            else
-              parsera_model
-            end
+          parsera_model = find_parsera_model(key, parsera_by_key)
+          provider_model = provider_by_key[key]
+
+          if parsera_model && provider_model
+            add_provider_metadata(parsera_model, provider_model)
+          elsif parsera_model
+            parsera_model
           else
-            provider_by_key[key]
+            provider_model
           end
         end
 
         models.sort_by { |m| [m.provider, m.id] }
       end
 
+      def find_parsera_model(key, parsera_by_key)
+        # Direct match
+        return parsera_by_key[key] if parsera_by_key[key]
+
+        # VertexAI uses same models as Gemini
+        provider, model_id = key.split(':', 2)
+        return unless provider == 'vertexai'
+
+        gemini_model = parsera_by_key["gemini:#{model_id}"]
+        return unless gemini_model
+
+        # Return Gemini's Parsera data but with VertexAI as provider
+        Model::Info.new(gemini_model.to_h.merge(provider: 'vertexai'))
+      end
+
       def index_by_key(models)
         models.each_with_object({}) do |model, hash|
           hash["#{model.provider}:#{model.id}"] = model
@@ -134,13 +155,21 @@ module RubyLLM
     end
 
     def load_models
+      read_from_json
+    end
+
+    def load_from_json!
+      @models = read_from_json
+    end
+
+    def read_from_json
       data = File.exist?(self.class.models_file) ? File.read(self.class.models_file) : '[]'
       JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
     rescue JSON::ParserError
       []
     end
 
-    def save_models
+    def save_to_json
       File.write(self.class.models_file, JSON.pretty_generate(all.map(&:to_h)))
     end
 
@@ -184,8 +213,8 @@ module RubyLLM
       self.class.new(all.select { |m| m.provider == provider.to_s })
     end
 
-    def refresh!
-      self.class.refresh!
+    def refresh!(remote_only: false)
+      self.class.refresh!(remote_only: remote_only)
     end
 
     private

data/lib/ruby_llm/provider.rb

@@ -41,7 +41,6 @@ module RubyLLM
       normalized_temperature = maybe_normalize_temperature(temperature, model)
 
       payload = Utils.deep_merge(
-        params,
         render_payload(
           messages,
           tools: tools,
@@ -49,7 +48,8 @@ module RubyLLM
           model: model,
           stream: block_given?,
           schema: schema
-        )
+        ),
+        params
       )
 
       if block_given?
@@ -201,7 +201,7 @@ module RubyLLM
       raise ConfigurationError, "Missing configuration for #{name}: #{missing.join(', ')}"
     end
 
-    def maybe_normalize_temperature(temperature, _model_id)
+    def maybe_normalize_temperature(temperature, _model)
       temperature
     end
 

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

@@ -37,10 +37,10 @@ module RubyLLM
 
         def build_base_payload(chat_messages, model, stream)
           {
-            model: model,
+            model: model.id,
             messages: chat_messages.map { |msg| format_message(msg) },
             stream: stream,
-            max_tokens: RubyLLM.models.find(model)&.max_tokens || 4096
+            max_tokens: model.max_tokens || 4096
           }
         end
 

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

@@ -82,7 +82,7 @@ module RubyLLM
         def format_text_file(text_file)
           {
             type: 'text',
-            text: Utils.format_text_file_for_llm(text_file)
+            text: text_file.for_llm
           }
         end
       end

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

@@ -46,7 +46,7 @@ module RubyLLM
           {
             type: 'tool_result',
             tool_use_id: msg.tool_call_id,
-            content: msg.content
+            content: Media.format_content(msg.content)
           }
         end
 

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

@@ -40,7 +40,7 @@ module RubyLLM
         end
 
         def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Lint/UnusedMethodArgument,Metrics/ParameterLists
-          @model_id = model
+          @model_id = model.id
 
           system_messages, chat_messages = Anthropic::Chat.separate_messages(messages)
           system_content = Anthropic::Chat.build_system_content(system_messages)
@@ -54,7 +54,7 @@ module RubyLLM
           {
             anthropic_version: 'bedrock-2023-05-31',
             messages: chat_messages.map { |msg| format_message(msg) },
-            max_tokens: RubyLLM.models.find(model)&.max_tokens || 4096
+            max_tokens: model.max_tokens || 4096
           }
         end
       end

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

@@ -72,7 +72,25 @@ module RubyLLM
           return model_id unless model_data['inferenceTypesSupported']&.include?('INFERENCE_PROFILE')
           return model_id if model_data['inferenceTypesSupported']&.include?('ON_DEMAND')
 
-          "us.#{model_id}"
+          desired_region_prefix = inference_profile_region_prefix
+
+          # Return unchanged if model already has the correct region prefix
+          return model_id if model_id.start_with?("#{desired_region_prefix}.")
+
+          # Remove any existing region prefix (e.g., "us.", "eu.", "ap.")
+          clean_model_id = model_id.sub(/^[a-z]{2}\./, '')
+
+          # Apply the desired region prefix
+          "#{desired_region_prefix}.#{clean_model_id}"
+        end
+
+        def inference_profile_region_prefix
+          # Extract region prefix from bedrock_region (e.g., "eu-west-3" -> "eu")
+          region = @config.bedrock_region.to_s
+          return 'us' if region.empty? # Default fallback
+
+          # Take first two characters as the region prefix
+          region[0, 2]
         end
       end
     end

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

@@ -12,7 +12,7 @@ module RubyLLM
         end
 
         def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists,Lint/UnusedMethodArgument
-          @model = model
+          @model = model.id
           payload = {
             contents: format_messages(messages),
             generationConfig: {}
@@ -62,7 +62,7 @@ module RubyLLM
                 name: msg.tool_call_id,
                 response: {
                   name: msg.tool_call_id,
-                  content: msg.content
+                  content: Media.format_content(msg.content)
                 }
               }
             }]
@@ -86,31 +86,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
 
@@ -137,6 +118,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/media.rb

@@ -39,7 +39,7 @@ module RubyLLM
 
         def format_text_file(text_file)
           {
-            text: Utils.format_text_file_for_llm(text_file)
+            text: text_file.for_llm
           }
         end
 

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

@@ -7,6 +7,17 @@ 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)
           role.to_s
         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: image.for_llm,
+              detail: 'auto'
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -16,10 +16,10 @@ module RubyLLM
           items.map do |model|
             Model::Info.new(
               id: model['name'],
+              name: model['name'],
               created_at: model['created_at'] ? Time.parse(model['created_at']) : nil,
-              display_name: "#{model['source']}/#{model['name']}",
               provider: slug,
-              type: determine_model_type(model),
+              family: 'gpustack',
               metadata: {
                 description: model['description'],
                 source: model['source'],
@@ -30,12 +30,10 @@ module RubyLLM
                 categories: model['categories']
               },
               context_window: model.dig('meta', 'n_ctx'),
-              max_tokens: model.dig('meta', 'n_ctx'),
-              supports_vision: model.dig('meta', 'support_vision') || false,
-              supports_functions: model.dig('meta', 'support_tool_calls') || false,
-              supports_json_mode: true,
-              input_price_per_million: 0.0,
-              output_price_per_million: 0.0
+              max_output_tokens: model.dig('meta', 'n_ctx'),
+              capabilities: build_capabilities(model),
+              modalities: build_modalities(model),
+              pricing: {}
             )
           end
         end
@@ -48,6 +46,44 @@ module RubyLLM
 
           'other'
         end
+
+        def build_capabilities(model) # rubocop:disable Metrics/PerceivedComplexity
+          capabilities = []
+
+          # Add streaming by default for LLM models
+          capabilities << 'streaming' if model['categories']&.include?('llm')
+
+          # Map GPUStack metadata to standard capabilities
+          capabilities << 'function_calling' if model.dig('meta', 'support_tool_calls')
+          capabilities << 'vision' if model.dig('meta', 'support_vision')
+          capabilities << 'reasoning' if model.dig('meta', 'support_reasoning')
+
+          # GPUStack models generally support structured output and json mode
+          capabilities << 'structured_output' if model['categories']&.include?('llm')
+          capabilities << 'json_mode' if model['categories']&.include?('llm')
+
+          capabilities
+        end
+
+        def build_modalities(model)
+          input_modalities = []
+          output_modalities = []
+
+          if model['categories']&.include?('llm')
+            input_modalities << 'text'
+            input_modalities << 'image' if model.dig('meta', 'support_vision')
+            input_modalities << 'audio' if model.dig('meta', 'support_audio')
+            output_modalities << 'text'
+          elsif model['categories']&.include?('embedding')
+            input_modalities << 'text'
+            output_modalities << 'embeddings'
+          end
+
+          {
+            input: input_modalities,
+            output: output_modalities
+          }
+        end
       end
     end
   end

data/lib/ruby_llm/providers/gpustack.rb

@@ -6,6 +6,7 @@ module RubyLLM
     class GPUStack < OpenAI
       include GPUStack::Chat
       include GPUStack::Models
+      include GPUStack::Media
 
       def api_base
         @config.gpustack_api_base

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

@@ -3,7 +3,7 @@
 module RubyLLM
   module Providers
     class Ollama
-      # Handles formatting of media content (images, audio) for OpenAI APIs
+      # Handles formatting of media content (images, audio) for Ollama APIs
       module Media
         extend OpenAI::Media
 
@@ -20,10 +20,6 @@ module RubyLLM
             case attachment.type
             when :image
               parts << Ollama::Media.format_image(attachment)
-            when :pdf
-              parts << format_pdf(attachment)
-            when :audio
-              parts << format_audio(attachment)
             when :text
               parts << format_text_file(attachment)
             else
@@ -38,7 +34,7 @@ module RubyLLM
           {
             type: 'image_url',
             image_url: {
-              url: "data:#{image.mime_type};base64,#{image.encoded}",
+              url: image.for_llm,
               detail: 'auto'
             }
           }

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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    class Ollama
+      # Models methods for the Ollama API integration
+      module Models
+        def models_url
+          'models'
+        end
+
+        def parse_list_models_response(response, slug, _capabilities)
+          data = response.body['data'] || []
+          data.map do |model|
+            Model::Info.new(
+              id: model['id'],
+              name: model['id'],
+              provider: slug,
+              family: 'ollama',
+              created_at: model['created'] ? Time.at(model['created']) : nil,
+              modalities: {
+                input: %w[text image],
+                output: %w[text]
+              },
+              capabilities: %w[streaming function_calling structured_output vision],
+              pricing: {},
+              metadata: {
+                owned_by: model['owned_by']
+              }
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/lib/ruby_llm/providers/ollama.rb

@@ -6,6 +6,7 @@ module RubyLLM
     class Ollama < OpenAI
       include Ollama::Chat
       include Ollama::Media
+      include Ollama::Models
 
       def api_base
         @config.ollama_api_base

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

@@ -13,7 +13,7 @@ module RubyLLM
 
         def render_payload(messages, tools:, temperature:, model:, stream: false, schema: nil) # rubocop:disable Metrics/ParameterLists
           payload = {
-            model: model,
+            model: model.id,
             messages: format_messages(messages),
             stream: stream
           }

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

@@ -36,7 +36,7 @@ module RubyLLM
           {
             type: 'image_url',
             image_url: {
-              url: image.url? ? image.source : "data:#{image.mime_type};base64,#{image.encoded}"
+              url: image.url? ? image.source : image.for_llm
             }
           }
         end
@@ -46,7 +46,7 @@ module RubyLLM
             type: 'file',
             file: {
               filename: pdf.filename,
-              file_data: "data:#{pdf.mime_type};base64,#{pdf.encoded}"
+              file_data: pdf.for_llm
             }
           }
         end
@@ -54,7 +54,7 @@ module RubyLLM
         def format_text_file(text_file)
           {
             type: 'text',
-            text: Utils.format_text_file_for_llm(text_file)
+            text: text_file.for_llm
           }
         end
 
@@ -63,7 +63,7 @@ module RubyLLM
             type: 'input_audio',
             input_audio: {
               data: audio.encoded,
-              format: audio.mime_type.split('/').last
+              format: audio.format
             }
           }
         end

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

@@ -44,6 +44,16 @@ module RubyLLM
           end
         end
 
+        def parse_tool_call_arguments(tool_call)
+          arguments = tool_call.dig('function', 'arguments')
+
+          if arguments.nil? || arguments.empty?
+            {}
+          else
+            JSON.parse(arguments)
+          end
+        end
+
         def parse_tool_calls(tool_calls, parse_arguments: true)
           return nil unless tool_calls&.any?
 
@@ -54,12 +64,7 @@ module RubyLLM
                 id: tc['id'],
                 name: tc.dig('function', 'name'),
                 arguments: if parse_arguments
-                             if tc.dig('function', 'arguments').empty?
-                               {}
-                             else
-                               JSON.parse(tc.dig('function',
-                                                 'arguments'))
-                             end
+                             parse_tool_call_arguments(tc)
                            else
                              tc.dig('function', 'arguments')
                            end

data/lib/ruby_llm/providers/openai.rb

@@ -24,8 +24,8 @@ module RubyLLM
         }.compact
       end
 
-      def maybe_normalize_temperature(temperature, model_id)
-        OpenAI::Capabilities.normalize_temperature(temperature, model_id)
+      def maybe_normalize_temperature(temperature, model)
+        OpenAI::Capabilities.normalize_temperature(temperature, model.id)
       end
 
       class << self