dify_llm 1.9.2 → 1.14.1

data/lib/ruby_llm/models.rb

@@ -16,6 +16,21 @@ module RubyLLM
       '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
@@ -32,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)
-        models_dev_models = fetch_from_models_dev
-        merged_models = merge_models(provider_models, models_dev_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: []
+        }
 
-        RubyLLM.logger.info "Fetching models from providers: #{configured.map(&:name).join(', ')}"
+        provider_classes.each do |provider_class|
+          next if remote_only && provider_class.local?
+          next unless provider_class.configured?(config)
 
-        configured.flat_map(&:list_models)
+          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
+
+        result[:fetched_providers].uniq!
+        result
+      end
+
+      # 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
@@ -64,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
@@ -103,7 +148,7 @@ module RubyLLM
         instance.respond_to?(method, include_private) || super
       end
 
-      def fetch_from_models_dev
+      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|
@@ -121,7 +166,52 @@ module RubyLLM
             Model::Info.new(models_dev_model_to_info(model_data, provider_slug, provider_key.to_s))
           end
         end
-        models.reject { |model| model.provider.nil? || model.id.nil? }
+        { 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 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)
@@ -143,15 +233,36 @@ module RubyLLM
           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_models_dev_model(key, models_dev_by_key)
         # Direct match
         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 = models_dev_by_key["gemini:#{model_id}"]
@@ -162,28 +273,61 @@ module RubyLLM
       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(models_dev_model, provider_model)
+      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: model_data[:release_date] || model_data[:last_updated],
+          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]),
@@ -192,6 +336,9 @@ module RubyLLM
           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)
@@ -261,7 +408,7 @@ module RubyLLM
     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)
@@ -325,8 +472,8 @@ module RubyLLM
     def find_with_provider(model_id, provider)
       resolved_id = Aliases.resolve(model_id, provider)
       resolved_id = resolve_bedrock_region_id(resolved_id) if provider.to_s == 'bedrock'
-      all.find { |m| m.id == model_id && m.provider == provider.to_s } ||
-        all.find { |m| m.id == resolved_id && m.provider == provider.to_s } ||
+      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
 
@@ -345,9 +492,23 @@ module RubyLLM
     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/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