ruby_llm 1.9.1 → 1.9.2

data/lib/ruby_llm/models.rb

@@ -5,6 +5,18 @@ 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
+
     class << self
       def instance
         @instance ||= new
@@ -27,8 +39,8 @@ module RubyLLM
 
       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)
+        models_dev_models = fetch_from_models_dev
+        merged_models = merge_models(provider_models, models_dev_models)
         @instance = new(merged_models)
       end
 
@@ -91,32 +103,41 @@ module RubyLLM
         instance.respond_to?(method, include_private) || super
       end
 
-      def fetch_from_parsera
-        RubyLLM.logger.info 'Fetching models from Parsera API...'
+      def fetch_from_models_dev
+        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) }
+        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.reject { |model| model.provider.nil? || model.id.nil? }
       end
 
-      def merge_models(provider_models, parsera_models)
-        parsera_by_key = index_by_key(parsera_models)
+      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
@@ -125,18 +146,18 @@ module RubyLLM
         models.sort_by { |m| [m.provider, m.id] }
       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)
         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
 
@@ -146,11 +167,97 @@ module RubyLLM
         end
       end
 
-      def add_provider_metadata(parsera_model, provider_model)
-        data = parsera_model.to_h
+      def add_provider_metadata(models_dev_model, provider_model)
+        data = models_dev_model.to_h
         data[:metadata] = provider_model.metadata.merge(data[:metadata] || {})
+        data[:capabilities] = (models_dev_model.capabilities + provider_model.capabilities).uniq
         Model::Info.new(data)
       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)
+
+        {
+          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],
+          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)
+        }
+      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)
@@ -217,11 +324,26 @@ 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 } ||
         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) } ||

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/providers/bedrock/models.rb

@@ -69,28 +69,34 @@ module RubyLLM
         end
 
         def model_id_with_region(model_id, model_data)
-          return model_id unless model_data['inferenceTypesSupported']&.include?('INFERENCE_PROFILE')
-          return model_id if model_data['inferenceTypesSupported']&.include?('ON_DEMAND')
+          normalize_inference_profile_id(
+            model_id,
+            model_data['inferenceTypesSupported'],
+            @config.bedrock_region
+          )
+        end
 
-          desired_region_prefix = inference_profile_region_prefix
+        def region_prefix(region)
+          region = region.to_s
+          return 'us' if region.empty?
 
-          # Return unchanged if model already has the correct region prefix
-          return model_id if model_id.start_with?("#{desired_region_prefix}.")
+          region[0, 2]
+        end
 
-          # Remove any existing region prefix (e.g., "us.", "eu.", "ap.")
-          clean_model_id = model_id.sub(/^[a-z]{2}\./, '')
+        def with_region_prefix(model_id, region)
+          desired_prefix = region_prefix(region)
+          return model_id if model_id.start_with?("#{desired_prefix}.")
 
-          # Apply the desired region prefix
-          "#{desired_region_prefix}.#{clean_model_id}"
+          clean_model_id = model_id.sub(/^[a-z]{2}\./, '')
+          "#{desired_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
+        def normalize_inference_profile_id(model_id, inference_types, region)
+          types = Array(inference_types)
+          return model_id unless types.include?('INFERENCE_PROFILE')
+          return model_id if types.include?('ON_DEMAND')
 
-          # Take first two characters as the region prefix
-          region[0, 2]
+          with_region_prefix(model_id, region)
         end
       end
     end

data/lib/ruby_llm/streaming.rb

@@ -60,6 +60,8 @@ module RubyLLM
 
       if error_chunk?(chunk)
         handle_error_chunk(chunk, env)
+      elsif json_error_payload?(chunk)
+        handle_json_error_chunk(chunk, env)
       else
         yield handle_sse(chunk, parser, env, &)
       end
@@ -85,17 +87,24 @@ module RubyLLM
       chunk.start_with?('event: error')
     end
 
+    def json_error_payload?(chunk)
+      chunk.lstrip.start_with?('{') && chunk.include?('"error"')
+    end
+
+    def handle_json_error_chunk(chunk, env)
+      parsed_data = JSON.parse(chunk)
+      status, _message = parse_streaming_error(parsed_data.to_json)
+      error_response = build_stream_error_response(parsed_data, env, status)
+      ErrorMiddleware.parse_error(provider: self, response: error_response)
+    rescue JSON::ParserError => e
+      RubyLLM.logger.debug "Failed to parse JSON error chunk: #{e.message}"
+    end
+
     def handle_error_chunk(chunk, env)
       error_data = chunk.split("\n")[1].delete_prefix('data: ')
-      status, _message = parse_streaming_error(error_data)
       parsed_data = JSON.parse(error_data)
-
-      error_response = if faraday_1?
-                         Struct.new(:body, :status).new(parsed_data, status)
-                       else
-                         env.merge(body: parsed_data, status: status)
-                       end
-
+      status, _message = parse_streaming_error(parsed_data.to_json)
+      error_response = build_stream_error_response(parsed_data, env, status)
       ErrorMiddleware.parse_error(provider: self, response: error_response)
     rescue JSON::ParserError => e
       RubyLLM.logger.debug "Failed to parse error chunk: #{e.message}"
@@ -104,7 +113,8 @@ module RubyLLM
     def handle_failed_response(chunk, buffer, env)
       buffer << chunk
       error_data = JSON.parse(buffer)
-      error_response = env.merge(body: error_data)
+      status, _message = parse_streaming_error(error_data.to_json)
+      error_response = env.merge(body: error_data, status: status || env.status)
       ErrorMiddleware.parse_error(provider: self, response: error_response)
     rescue JSON::ParserError
       RubyLLM.logger.debug "Accumulating error chunk: #{chunk}"
@@ -116,27 +126,26 @@ module RubyLLM
         when :error
           handle_error_event(data, env)
         else
-          yield handle_data(data, &block) unless data == '[DONE]'
+          yield handle_data(data, env, &block) unless data == '[DONE]'
         end
       end
     end
 
-    def handle_data(data)
-      JSON.parse(data)
+    def handle_data(data, env)
+      parsed = JSON.parse(data)
+      return parsed unless parsed.is_a?(Hash) && parsed.key?('error')
+
+      status, _message = parse_streaming_error(parsed.to_json)
+      error_response = build_stream_error_response(parsed, env, status)
+      ErrorMiddleware.parse_error(provider: self, response: error_response)
     rescue JSON::ParserError => e
       RubyLLM.logger.debug "Failed to parse data chunk: #{e.message}"
     end
 
     def handle_error_event(data, env)
-      status, _message = parse_streaming_error(data)
       parsed_data = JSON.parse(data)
-
-      error_response = if faraday_1?
-                         Struct.new(:body, :status).new(parsed_data, status)
-                       else
-                         env.merge(body: parsed_data, status: status)
-                       end
-
+      status, _message = parse_streaming_error(parsed_data.to_json)
+      error_response = build_stream_error_response(parsed_data, env, status)
       ErrorMiddleware.parse_error(provider: self, response: error_response)
     rescue JSON::ParserError => e
       RubyLLM.logger.debug "Failed to parse error event: #{e.message}"
@@ -149,5 +158,15 @@ module RubyLLM
       RubyLLM.logger.debug "Failed to parse streaming error: #{e.message}"
       [500, "Failed to parse error: #{data}"]
     end
+
+    def build_stream_error_response(parsed_data, env, status)
+      error_status = status || env&.status || 500
+
+      if faraday_1?
+        Struct.new(:body, :status).new(parsed_data, error_status)
+      else
+        env.merge(body: parsed_data, status: error_status)
+      end
+    end
   end
 end

data/lib/ruby_llm/tool.rb

@@ -186,7 +186,7 @@ module RubyLLM
       def resolve_direct_schema(schema)
         return extract_schema(schema.to_json_schema) if schema.respond_to?(:to_json_schema)
         return RubyLLM::Utils.deep_dup(schema) if schema.is_a?(Hash)
-        if schema.is_a?(Class) && schema.instance_methods.include?(:to_json_schema)
+        if schema.is_a?(Class) && schema.method_defined?(:to_json_schema)
           return extract_schema(schema.new.to_json_schema)
         end
 

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '1.9.1'
+  VERSION = '1.9.2'
 end

data/lib/tasks/models.rake

@@ -156,7 +156,7 @@ def generate_models_markdown
 
     ## Model Data Sources
 
-    - **OpenAI, Anthropic, DeepSeek, Gemini, VertexAI**: Enriched by [🚀 Parsera](https://parsera.org/) *([free LLM metadata API](https://api.parsera.org/v1/llm-specs) - [go say thanks!](https://github.com/parsera-labs/api-llm-specs))*
+    - **OpenAI, Anthropic, DeepSeek, Gemini, VertexAI**: Enriched by [models.dev](https://models.dev/) *([LLM metadata API](https://models.dev/api.json))*
     - **OpenRouter**: Direct API
     - **Others**: Local capabilities files
 
@@ -354,7 +354,7 @@ def generate_aliases # rubocop:disable Metrics/PerceivedComplexity
 
   models['bedrock'].each do |bedrock_model|
     next unless bedrock_model.start_with?('anthropic.')
-    next unless bedrock_model =~ /anthropic\.(claude-[\d.]+-[a-z]+)/
+    next unless bedrock_model =~ /anthropic\.(claude-[a-z0-9.-]+)-\d{8}/
 
     base_name = Regexp.last_match(1)
     anthropic_name = base_name.tr('.', '-')

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ruby_llm
 version: !ruby/object:Gem::Version
-  version: 1.9.1
+  version: 1.9.2
 platform: ruby
 authors:
 - Carmine Paolino