dify_llm 1.9.1 → 1.14.1

data/lib/ruby_llm/models.rb

@@ -5,6 +5,33 @@ module RubyLLM
   class Models
     include Enumerable
 
+    MODELS_DEV_PROVIDER_MAP = {
+      'openai' => 'openai',
+      'anthropic' => 'anthropic',
+      'google' => 'gemini',
+      'google-vertex' => 'vertexai',
+      'amazon-bedrock' => 'bedrock',
+      'deepseek' => 'deepseek',
+      'mistral' => 'mistral',
+      'openrouter' => 'openrouter',
+      'perplexity' => 'perplexity'
+    }.freeze
+    PROVIDER_PREFERENCE = %w[
+      openai
+      anthropic
+      gemini
+      vertexai
+      bedrock
+      openrouter
+      deepseek
+      mistral
+      perplexity
+      xai
+      azure
+      ollama
+      gpustack
+    ].freeze
+
     class << self
       def instance
         @instance ||= new
@@ -20,30 +47,60 @@ module RubyLLM
 
       def read_from_json(file = RubyLLM.config.model_registry_file)
         data = File.exist?(file) ? File.read(file) : '[]'
-        JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
+        models = JSON.parse(data, symbolize_names: true).map { |model| Model::Info.new(model) }
+        filter_models(models)
       rescue JSON::ParserError
         []
       end
 
       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)
+        existing_models = load_existing_models
+
+        provider_fetch = fetch_provider_models(remote_only: remote_only)
+        log_provider_fetch(provider_fetch)
+
+        models_dev_fetch = fetch_models_dev_models(existing_models)
+        log_models_dev_fetch(models_dev_fetch)
+
+        merged_models = merge_with_existing(existing_models, provider_fetch, models_dev_fetch)
         @instance = new(merged_models)
       end
 
-      def fetch_from_providers(remote_only: true)
+      def fetch_provider_models(remote_only: true) # rubocop:disable Metrics/PerceivedComplexity
         config = RubyLLM.config
+        provider_classes = remote_only ? Provider.remote_providers.values : Provider.providers.values
         configured_classes = if remote_only
                                Provider.configured_remote_providers(config)
                              else
                                Provider.configured_providers(config)
                              end
-        configured = configured_classes.map { |klass| klass.new(config) }
+        configured = configured_classes.select { |klass| provider_classes.include?(klass) }
+        result = {
+          models: [],
+          fetched_providers: [],
+          configured_names: configured.map(&:name),
+          failed: []
+        }
+
+        provider_classes.each do |provider_class|
+          next if remote_only && provider_class.local?
+          next unless provider_class.configured?(config)
+
+          begin
+            result[:models].concat(provider_class.new(config).list_models)
+            result[:fetched_providers] << provider_class.slug
+          rescue StandardError => e
+            result[:failed] << { name: provider_class.name, slug: provider_class.slug, error: e }
+          end
+        end
 
-        RubyLLM.logger.info "Fetching models from providers: #{configured.map(&:name).join(', ')}"
+        result[:fetched_providers].uniq!
+        result
+      end
 
-        configured.flat_map(&:list_models)
+      # Backwards-compatible wrapper used by specs.
+      def fetch_from_providers(remote_only: true)
+        fetch_provider_models(remote_only: remote_only)[:models]
       end
 
       def resolve(model_id, provider: nil, assume_exists: false, config: nil) # rubocop:disable Metrics/PerceivedComplexity
@@ -52,7 +109,7 @@ module RubyLLM
 
         if provider_class
           temp_instance = provider_class.new(config)
-          assume_exists = true if temp_instance.local?
+          assume_exists = true if temp_instance.local? || temp_instance.assume_models_exist?
         end
 
         if assume_exists
@@ -91,70 +148,267 @@ module RubyLLM
         instance.respond_to?(method, include_private) || super
       end
 
-      def fetch_from_parsera
-        RubyLLM.logger.info 'Fetching models from Parsera API...'
+      def fetch_models_dev_models(existing_models) # rubocop:disable Metrics/PerceivedComplexity
+        RubyLLM.logger.info 'Fetching models from models.dev API...'
 
         connection = Connection.basic do |f|
           f.request :json
           f.response :json, parser_options: { symbolize_names: true }
         end
-        response = connection.get 'https://api.parsera.org/v1/llm-specs'
-        models = response.body.map { |data| Model::Info.new(data) }
-        models.reject { |model| model.provider.nil? || model.id.nil? }
+        response = connection.get 'https://models.dev/api.json'
+        providers = response.body || {}
+
+        models = providers.flat_map do |provider_key, provider_data|
+          provider_slug = MODELS_DEV_PROVIDER_MAP[provider_key.to_s]
+          next [] unless provider_slug
+
+          (provider_data[:models] || {}).values.map do |model_data|
+            Model::Info.new(models_dev_model_to_info(model_data, provider_slug, provider_key.to_s))
+          end
+        end
+        { models: models.reject { |model| model.provider.nil? || model.id.nil? }, fetched: true }
+      rescue StandardError => e
+        RubyLLM.logger.warn("Failed to fetch models.dev (#{e.class}: #{e.message}). Keeping existing.")
+        {
+          models: existing_models.select { |model| model.metadata[:source] == 'models.dev' },
+          fetched: false
+        }
       end
 
-      def merge_models(provider_models, parsera_models)
-        parsera_by_key = index_by_key(parsera_models)
+      def load_existing_models
+        existing_models = instance&.all
+        existing_models = read_from_json if existing_models.nil? || existing_models.empty?
+        existing_models
+      end
+
+      def log_provider_fetch(provider_fetch)
+        RubyLLM.logger.info "Fetching models from providers: #{provider_fetch[:configured_names].join(', ')}"
+        provider_fetch[:failed].each do |failure|
+          RubyLLM.logger.warn(
+            "Failed to fetch #{failure[:name]} models (#{failure[:error].class}: #{failure[:error].message}). " \
+            'Keeping existing.'
+          )
+        end
+      end
+
+      def log_models_dev_fetch(models_dev_fetch)
+        return if models_dev_fetch[:fetched]
+
+        RubyLLM.logger.warn('Using cached models.dev data due to fetch failure.')
+      end
+
+      def merge_with_existing(existing_models, provider_fetch, models_dev_fetch)
+        existing_by_provider = existing_models.group_by(&:provider)
+        preserved_models = existing_by_provider
+                           .except(*provider_fetch[:fetched_providers])
+                           .values
+                           .flatten
+
+        provider_models = provider_fetch[:models] + preserved_models
+        models_dev_models = if models_dev_fetch[:fetched]
+                              models_dev_fetch[:models]
+                            else
+                              existing_models.select { |model| model.metadata[:source] == 'models.dev' }
+                            end
+
+        merge_models(provider_models, models_dev_models)
+      end
+
+      def merge_models(provider_models, models_dev_models)
+        models_dev_by_key = index_by_key(models_dev_models)
         provider_by_key = index_by_key(provider_models)
 
-        all_keys = parsera_by_key.keys | provider_by_key.keys
+        all_keys = models_dev_by_key.keys | provider_by_key.keys
 
         models = all_keys.map do |key|
-          parsera_model = find_parsera_model(key, parsera_by_key)
+          models_dev_model = find_models_dev_model(key, models_dev_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
+          if models_dev_model && provider_model
+            add_provider_metadata(models_dev_model, provider_model)
+          elsif models_dev_model
+            models_dev_model
           else
             provider_model
           end
         end
 
-        models.sort_by { |m| [m.provider, m.id] }
+        filter_models(models).sort_by { |m| [m.provider, m.id] }
+      end
+
+      def filter_models(models)
+        models.reject do |model|
+          model.provider.to_s == 'vertexai' && model.id.to_s.include?('/')
+        end
       end
 
-      def find_parsera_model(key, parsera_by_key)
+      def find_models_dev_model(key, models_dev_by_key)
         # Direct match
-        return parsera_by_key[key] if parsera_by_key[key]
+        return models_dev_by_key[key] if models_dev_by_key[key]
 
-        # VertexAI uses same models as Gemini
         provider, model_id = key.split(':', 2)
+        if provider == 'bedrock'
+          normalized_id = model_id.sub(/^[a-z]{2}\./, '')
+          context_override = nil
+          normalized_id = normalized_id.gsub(/:(\d+)k\b/) do
+            context_override = Regexp.last_match(1).to_i * 1000
+            ''
+          end
+          bedrock_model = models_dev_by_key["bedrock:#{normalized_id}"]
+          if bedrock_model
+            data = bedrock_model.to_h.merge(id: model_id)
+            data[:context_window] = context_override if context_override
+            return Model::Info.new(data)
+          end
+        end
+
+        # VertexAI uses same models as Gemini
         return unless provider == 'vertexai'
 
-        gemini_model = parsera_by_key["gemini:#{model_id}"]
+        gemini_model = models_dev_by_key["gemini:#{model_id}"]
         return unless gemini_model
 
-        # Return Gemini's Parsera data but with VertexAI as provider
+        # Return Gemini's models.dev 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
+        models.to_h do |model|
+          ["#{model.provider}:#{model.id}", model]
         end
       end
 
-      def add_provider_metadata(parsera_model, provider_model)
-        data = parsera_model.to_h
+      def add_provider_metadata(models_dev_model, provider_model) # rubocop:disable Metrics/PerceivedComplexity
+        data = models_dev_model.to_h
+        data[:name] = provider_model.name if blank_value?(data[:name])
+        data[:family] = provider_model.family if blank_value?(data[:family])
+        data[:created_at] = provider_model.created_at if blank_value?(data[:created_at])
+        data[:context_window] = provider_model.context_window if blank_value?(data[:context_window])
+        data[:max_output_tokens] = provider_model.max_output_tokens if blank_value?(data[:max_output_tokens])
+        data[:modalities] = provider_model.modalities.to_h if blank_value?(data[:modalities])
+        data[:pricing] = provider_model.pricing.to_h if blank_value?(data[:pricing])
         data[:metadata] = provider_model.metadata.merge(data[:metadata] || {})
+        data[:capabilities] = (models_dev_model.capabilities + provider_model.capabilities).uniq
+        normalize_embedding_modalities(data)
         Model::Info.new(data)
       end
+
+      def normalize_embedding_modalities(data)
+        return unless data[:id].to_s.include?('embedding')
+
+        modalities = data[:modalities].to_h
+        modalities[:input] = ['text'] if modalities[:input].nil? || modalities[:input].empty?
+        modalities[:output] = ['embeddings']
+        data[:modalities] = modalities
+      end
+
+      def blank_value?(value)
+        return true if value.nil?
+        return value.empty? if value.is_a?(String) || value.is_a?(Array)
+
+        if value.is_a?(Hash)
+          return true if value.empty?
+
+          return value.values.all? { |nested| blank_value?(nested) }
+        end
+
+        false
+      end
+
+      def models_dev_model_to_info(model_data, provider_slug, provider_key)
+        modalities = normalize_models_dev_modalities(model_data[:modalities])
+        capabilities = models_dev_capabilities(model_data, modalities)
+
+        created_date = [model_data[:release_date], model_data[:last_updated]]
+                       .find { |value| !value.to_s.strip.empty? }
+
+        data = {
+          id: model_data[:id],
+          name: model_data[:name] || model_data[:id],
+          provider: provider_slug,
+          family: model_data[:family],
+          created_at: created_date ? "#{created_date} 00:00:00 UTC" : nil,
+          context_window: model_data.dig(:limit, :context),
+          max_output_tokens: model_data.dig(:limit, :output),
+          knowledge_cutoff: normalize_models_dev_knowledge(model_data[:knowledge]),
+          modalities: modalities,
+          capabilities: capabilities,
+          pricing: models_dev_pricing(model_data[:cost]),
+          metadata: models_dev_metadata(model_data, provider_key)
+        }
+
+        normalize_embedding_modalities(data)
+        data
+      end
+
+      def models_dev_capabilities(model_data, modalities)
+        capabilities = []
+        capabilities << 'function_calling' if model_data[:tool_call]
+        capabilities << 'structured_output' if model_data[:structured_output]
+        capabilities << 'reasoning' if model_data[:reasoning]
+        capabilities << 'vision' if modalities[:input].intersect?(%w[image video pdf])
+        capabilities.uniq
+      end
+
+      def models_dev_pricing(cost)
+        return {} unless cost
+
+        text_standard = {
+          input_per_million: cost[:input],
+          output_per_million: cost[:output],
+          cached_input_per_million: cost[:cache_read],
+          reasoning_output_per_million: cost[:reasoning]
+        }.compact
+
+        audio_standard = {
+          input_per_million: cost[:input_audio],
+          output_per_million: cost[:output_audio]
+        }.compact
+
+        pricing = {}
+        pricing[:text_tokens] = { standard: text_standard } if text_standard.any?
+        pricing[:audio_tokens] = { standard: audio_standard } if audio_standard.any?
+        pricing
+      end
+
+      def models_dev_metadata(model_data, provider_key)
+        metadata = {
+          source: 'models.dev',
+          provider_id: provider_key,
+          open_weights: model_data[:open_weights],
+          attachment: model_data[:attachment],
+          temperature: model_data[:temperature],
+          last_updated: model_data[:last_updated],
+          status: model_data[:status],
+          interleaved: model_data[:interleaved],
+          cost: model_data[:cost],
+          limit: model_data[:limit],
+          knowledge: model_data[:knowledge]
+        }
+        metadata.compact
+      end
+
+      def normalize_models_dev_modalities(modalities)
+        normalized = { input: [], output: [] }
+        return normalized unless modalities
+
+        normalized[:input] = Array(modalities[:input]).compact
+        normalized[:output] = Array(modalities[:output]).compact
+        normalized
+      end
+
+      def normalize_models_dev_knowledge(value)
+        return if value.nil?
+        return value if value.is_a?(Date)
+
+        Date.parse(value.to_s)
+      rescue ArgumentError
+        nil
+      end
     end
 
     def initialize(models = nil)
-      @models = models || self.class.load_models
+      @models = self.class.filter_models(models || self.class.load_models)
     end
 
     def load_from_json!(file = RubyLLM.config.model_registry_file)
@@ -217,15 +471,44 @@ module RubyLLM
 
     def find_with_provider(model_id, provider)
       resolved_id = Aliases.resolve(model_id, provider)
-      all.find { |m| m.id == model_id && m.provider == provider.to_s } ||
-        all.find { |m| m.id == resolved_id && m.provider == provider.to_s } ||
+      resolved_id = resolve_bedrock_region_id(resolved_id) if provider.to_s == 'bedrock'
+      all.find { |m| m.id == resolved_id && m.provider == provider.to_s } ||
+        all.find { |m| m.id == model_id && m.provider == provider.to_s } ||
         raise(ModelNotFoundError, "Unknown model: #{model_id} for provider: #{provider}")
     end
 
+    def resolve_bedrock_region_id(model_id)
+      region = RubyLLM.config.bedrock_region.to_s
+      return model_id if region.empty?
+
+      candidate_id = Providers::Bedrock::Models.with_region_prefix(model_id, region)
+      return model_id if candidate_id == model_id
+
+      candidate = all.find { |m| m.provider == 'bedrock' && m.id == candidate_id }
+      return model_id unless candidate
+
+      inference_types = Array(candidate.metadata[:inference_types] || candidate.metadata['inference_types'])
+      Providers::Bedrock::Models.normalize_inference_profile_id(model_id, inference_types, region)
+    end
+
     def find_without_provider(model_id)
-      all.find { |m| m.id == model_id } ||
-        all.find { |m| m.id == Aliases.resolve(model_id) } ||
-        raise(ModelNotFoundError, "Unknown model: #{model_id}")
+      exact_matches = all.select { |m| m.id == model_id }
+      return preferred_match(exact_matches) if exact_matches.any?
+
+      resolved_id = Aliases.resolve(model_id)
+      alias_matches = all.select { |m| m.id == resolved_id }
+      return preferred_match(alias_matches) if alias_matches.any?
+
+      raise(ModelNotFoundError, "Unknown model: #{model_id}")
+    end
+
+    def preferred_match(candidates)
+      return candidates.first if candidates.size == 1
+
+      candidates.min_by do |model|
+        index = PROVIDER_PREFERENCE.index(model.provider)
+        index || PROVIDER_PREFERENCE.length
+      end
     end
   end
 end

data/lib/ruby_llm/models_schema.json

@@ -55,7 +55,7 @@
             "type": "array",
             "items": {
               "type": "string",
-              "enum": ["text", "image", "audio", "embeddings", "moderation"]
+              "enum": ["text", "image", "audio", "video", "embeddings", "moderation"]
             },
             "uniqueItems": true,
             "description": "Supported output modalities"
@@ -165,4 +165,4 @@
       }
     }
   }
-}
+}

data/lib/ruby_llm/provider.rb

@@ -37,17 +37,21 @@ module RubyLLM
       self.class.configuration_requirements
     end
 
-    def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, &) # rubocop:disable Metrics/ParameterLists
+    # rubocop:disable Metrics/ParameterLists
+    def complete(messages, tools:, temperature:, model:, params: {}, headers: {}, schema: nil, thinking: nil,
+                 tool_prefs: nil, &)
       normalized_temperature = maybe_normalize_temperature(temperature, model)
 
       payload = Utils.deep_merge(
         render_payload(
           messages,
           tools: tools,
+          tool_prefs: tool_prefs,
           temperature: normalized_temperature,
           model: model,
           stream: block_given?,
-          schema: schema
+          schema: schema,
+          thinking: thinking
         ),
         params
       )
@@ -58,6 +62,7 @@ module RubyLLM
         sync_response @connection, payload, headers
       end
     end
+    # rubocop:enable Metrics/ParameterLists
 
     def list_models
       response = @connection.get models_url
@@ -101,16 +106,24 @@ module RubyLLM
       self.class.remote?
     end
 
+    def assume_models_exist?
+      self.class.assume_models_exist?
+    end
+
     def parse_error(response)
       return if response.body.empty?
 
       body = try_parse_json(response.body)
       case body
       when Hash
+        error = body['error']
+        return error if error.is_a?(String)
+
         body.dig('error', 'message')
       when Array
         body.map do |part|
-          part.dig('error', 'message')
+          error = part['error']
+          error.is_a?(String) ? error : part.dig('error', 'message')
         end.join('. ')
       else
         body
@@ -144,13 +157,17 @@ module RubyLLM
       end
 
       def capabilities
-        raise NotImplementedError
+        nil
       end
 
       def configuration_requirements
         []
       end
 
+      def configuration_options
+        []
+      end
+
       def local?
         false
       end
@@ -159,12 +176,17 @@ module RubyLLM
         !local?
       end
 
+      def assume_models_exist?
+        false
+      end
+
       def configured?(config)
         configuration_requirements.all? { |req| config.send(req) }
       end
 
       def register(name, provider_class)
         providers[name.to_sym] = provider_class
+        RubyLLM::Configuration.register_provider_options(provider_class.configuration_options)
       end
 
       def resolve(name)

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

@@ -3,130 +3,16 @@
 module RubyLLM
   module Providers
     class Anthropic
-      # Determines capabilities and pricing for Anthropic models
+      # Provider-level capability checks used outside the model registry.
       module Capabilities
         module_function
 
-        def determine_context_window(_model_id)
-          200_000
+        def supports_tool_choice?(_model_id)
+          true
         end
 
-        def determine_max_tokens(model_id)
-          case model_id
-          when /claude-3-7-sonnet/, /claude-3-5/ then 8_192
-          else 4_096
-          end
-        end
-
-        def get_input_price(model_id)
-          PRICES.dig(model_family(model_id), :input) || default_input_price
-        end
-
-        def get_output_price(model_id)
-          PRICES.dig(model_family(model_id), :output) || default_output_price
-        end
-
-        def supports_vision?(model_id)
-          !model_id.match?(/claude-[12]/)
-        end
-
-        def supports_functions?(model_id)
-          model_id.match?(/claude-3/)
-        end
-
-        def supports_json_mode?(model_id)
-          model_id.match?(/claude-3/)
-        end
-
-        def supports_extended_thinking?(model_id)
-          model_id.match?(/claude-3-7-sonnet/)
-        end
-
-        def model_family(model_id)
-          case model_id
-          when /claude-3-7-sonnet/  then 'claude-3-7-sonnet'
-          when /claude-3-5-sonnet/  then 'claude-3-5-sonnet'
-          when /claude-3-5-haiku/   then 'claude-3-5-haiku'
-          when /claude-3-opus/      then 'claude-3-opus'
-          when /claude-3-sonnet/    then 'claude-3-sonnet'
-          when /claude-3-haiku/     then 'claude-3-haiku'
-          else 'claude-2'
-          end
-        end
-
-        def model_type(_)
-          'chat'
-        end
-
-        PRICES = {
-          'claude-3-7-sonnet': { input: 3.0, output: 15.0 },
-          'claude-3-5-sonnet': { input: 3.0, output: 15.0 },
-          'claude-3-5-haiku': { input: 0.80, output: 4.0 },
-          'claude-3-opus': { input: 15.0, output: 75.0 },
-          'claude-3-haiku': { input: 0.25, output: 1.25 },
-          'claude-2': { input: 3.0, output: 15.0 }
-        }.freeze
-
-        def default_input_price
-          3.0
-        end
-
-        def default_output_price
-          15.0
-        end
-
-        def modalities_for(model_id)
-          modalities = {
-            input: ['text'],
-            output: ['text']
-          }
-
-          unless model_id.match?(/claude-[12]/)
-            modalities[:input] << 'image'
-            modalities[:input] << 'pdf'
-          end
-
-          modalities
-        end
-
-        def capabilities_for(model_id)
-          capabilities = ['streaming']
-
-          if model_id.match?(/claude-3/)
-            capabilities << 'function_calling'
-            capabilities << 'batch'
-          end
-
-          capabilities << 'reasoning' if model_id.match?(/claude-3-7|-4/)
-          capabilities << 'citations' if model_id.match?(/claude-3\.5|claude-3-7/)
-          capabilities
-        end
-
-        def pricing_for(model_id)
-          family = model_family(model_id)
-          prices = PRICES.fetch(family.to_sym, { input: default_input_price, output: default_output_price })
-
-          standard_pricing = {
-            input_per_million: prices[:input],
-            output_per_million: prices[:output]
-          }
-
-          batch_pricing = {
-            input_per_million: prices[:input] * 0.5,
-            output_per_million: prices[:output] * 0.5
-          }
-
-          if model_id.match?(/claude-3-7/)
-            standard_pricing[:reasoning_output_per_million] = prices[:output] * 2.5
-            batch_pricing[:reasoning_output_per_million] = prices[:output] * 1.25
-          end
-
-          {
-            text_tokens: {
-              standard: standard_pricing,
-              batch: batch_pricing
-            }
-          }
+        def supports_tool_parallel_control?(_model_id)
+          true
         end
       end
     end