ruby_llm 1.14.0 → 1.15.0

data/lib/ruby_llm/models.rb

@@ -356,7 +356,8 @@ module RubyLLM
         text_standard = {
           input_per_million: cost[:input],
           output_per_million: cost[:output],
-          cached_input_per_million: cost[:cache_read],
+          cache_read_input_per_million: cost[:cache_read],
+          cache_write_input_per_million: cost[:cache_write],
           reasoning_output_per_million: cost[:reasoning]
         }.compact
 

data/lib/ruby_llm/models_schema.json

@@ -87,7 +87,10 @@
                 "type": "object",
                 "properties": {
                   "input_per_million": {"type": "number", "minimum": 0},
+                  "cache_read_input_per_million": {"type": "number", "minimum": 0},
+                  "cache_write_input_per_million": {"type": "number", "minimum": 0},
                   "cached_input_per_million": {"type": "number", "minimum": 0},
+                  "cache_creation_input_per_million": {"type": "number", "minimum": 0},
                   "output_per_million": {"type": "number", "minimum": 0},
                   "reasoning_output_per_million": {"type": "number", "minimum": 0}
                 }

data/lib/ruby_llm/provider.rb

@@ -81,9 +81,10 @@ module RubyLLM
       parse_moderation_response(response, model:)
     end
 
-    def paint(prompt, model:, size:)
-      payload = render_image_payload(prompt, model:, size:)
-      response = @connection.post images_url, payload
+    def paint(prompt, model:, size:, with: nil, mask: nil, params: {}) # rubocop:disable Metrics/ParameterLists
+      validate_paint_inputs!(with:, mask:)
+      payload = render_image_payload(prompt, model:, size:, with:, mask:, params:)
+      response = @connection.post images_url(with:, mask:), payload
       parse_image_response(response, model:)
     end
 
@@ -225,6 +226,12 @@ module RubyLLM
 
     private
 
+    def validate_paint_inputs!(with:, mask:)
+      return if with.nil? && mask.nil?
+
+      raise UnsupportedAttachmentError, "#{name} does not support image references in paint"
+    end
+
     def build_audio_file_part(file_path)
       expanded_path = File.expand_path(file_path)
       mime_type = Marcel::MimeType.for(Pathname.new(expanded_path))

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

@@ -3,37 +3,10 @@
 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
-        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-[12]/)
-        end
-
         def supports_tool_choice?(_model_id)
           true
         end
@@ -41,111 +14,6 @@ module RubyLLM
         def supports_tool_parallel_control?(_model_id)
           true
         end
-
-        def supports_json_mode?(model_id)
-          !model_id.match?(/claude-[12]/)
-        end
-
-        def supports_structured_output?(model_id)
-          match = model_id.match(/claude-(?:sonnet|opus|haiku)-(\d+)-(\d+)/)
-          return false unless match
-
-          major = match[1].to_i
-          minor = match[2].to_i
-          major > 4 || (major == 4 && minor >= 5)
-        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']
-
-          unless model_id.match?(/claude-[12]/)
-            capabilities << 'function_calling'
-            capabilities << 'batch'
-          end
-
-          capabilities << 'structured_output' if supports_structured_output?(model_id)
-          capabilities << 'reasoning' if model_id.match?(/claude-3-7-sonnet|claude-(?:sonnet|opus|haiku)-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
-            }
-          }
-        end
       end
     end
   end

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

@@ -11,21 +11,15 @@ module RubyLLM
           'v1/models'
         end
 
-        def parse_list_models_response(response, slug, capabilities)
+        def parse_list_models_response(response, slug, _capabilities)
           Array(response.body['data']).map do |model_data|
             model_id = model_data['id']
 
             Model::Info.new(
               id: model_id,
-              name: model_data['display_name'],
+              name: model_data['display_name'] || model_id,
               provider: slug,
-              family: capabilities.model_family(model_id),
               created_at: Time.parse(model_data['created_at']),
-              context_window: capabilities.determine_context_window(model_id),
-              max_output_tokens: capabilities.determine_max_tokens(model_id),
-              modalities: capabilities.modalities_for(model_id),
-              capabilities: capabilities.capabilities_for(model_id),
-              pricing: capabilities.pricing_for(model_id),
               metadata: {}
             )
           end

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

@@ -45,10 +45,13 @@ module RubyLLM
         end
 
         def format_tool_result_block(msg)
+          content = msg.content
+          content = '(no output)' if content.nil? || (content.respond_to?(:empty?) && content.empty?)
+
           {
             type: 'tool_result',
             tool_use_id: msg.tool_call_id,
-            content: Media.format_content(msg.content)
+            content: Media.format_content(content)
           }
         end
 

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

@@ -56,7 +56,7 @@ module RubyLLM
             content: parse_text_content(content_blocks),
             thinking: Thinking.build(text: thinking_text, signature: thinking_signature),
             tool_calls: parse_tool_calls(content_blocks),
-            input_tokens: usage['inputTokens'],
+            input_tokens: input_tokens(usage),
             output_tokens: usage['outputTokens'],
             cached_tokens: usage['cacheReadInputTokens'],
             cache_creation_tokens: usage['cacheWriteInputTokens'],
@@ -66,6 +66,13 @@ module RubyLLM
           )
         end
 
+        def input_tokens(usage)
+          input_tokens = usage['inputTokens']
+          return unless input_tokens
+
+          [input_tokens.to_i - usage['cacheReadInputTokens'].to_i - usage['cacheWriteInputTokens'].to_i, 0].max
+        end
+
         def render_messages(messages)
           rendered = []
           tool_result_blocks = []
@@ -154,19 +161,23 @@ module RubyLLM
 
         def render_tool_result_content(content)
           return render_raw_tool_result_content(content.value) if content.is_a?(RubyLLM::Content::Raw)
+          return [{ json: content }] if content.is_a?(Hash) || content.is_a?(Array)
+          return render_content_tool_result_content(content) if content.is_a?(RubyLLM::Content)
 
-          if content.is_a?(Hash) || content.is_a?(Array)
-            [{ json: content }]
-          elsif content.is_a?(RubyLLM::Content)
-            blocks = []
-            blocks << { text: content.text } if content.text
-            content.attachments.each do |attachment|
-              blocks << { text: attachment.for_llm }
-            end
-            blocks
-          else
-            [{ text: content.to_s }]
-          end
+          [text_tool_result_block(content)]
+        end
+
+        def render_content_tool_result_content(content)
+          blocks = []
+          blocks << text_tool_result_block(content.text) unless content.text.to_s.empty?
+          content.attachments.each { |attachment| blocks << text_tool_result_block(attachment.for_llm) }
+          blocks.empty? ? [text_tool_result_block(nil)] : blocks
+        end
+
+        def text_tool_result_block(text)
+          text = text.to_s
+          text = '(no output)' if text.empty?
+          { text: text }
         end
 
         def render_raw_tool_result_content(raw_value)

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

@@ -158,7 +158,10 @@ module RubyLLM
         end
 
         def extract_input_tokens(metadata_usage, usage, message_usage)
-          metadata_usage['inputTokens'] || usage['inputTokens'] || message_usage['input_tokens']
+          bedrock_usage = metadata_usage['inputTokens'] ? metadata_usage : usage
+          return Bedrock::Chat.input_tokens(bedrock_usage) if bedrock_usage['inputTokens']
+
+          message_usage['input_tokens']
         end
 
         def extract_output_tokens(metadata_usage, usage)

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

@@ -3,44 +3,10 @@
 module RubyLLM
   module Providers
     class DeepSeek
-      # Determines capabilities and pricing for DeepSeek models
+      # Provider-level capability checks used outside the model registry.
       module Capabilities
         module_function
 
-        def context_window_for(model_id)
-          case model_id
-          when /deepseek-(?:chat|reasoner)/ then 64_000
-          else 32_768
-          end
-        end
-
-        def max_tokens_for(model_id)
-          case model_id
-          when /deepseek-(?:chat|reasoner)/ then 8_192
-          else 4_096
-          end
-        end
-
-        def input_price_for(model_id)
-          PRICES.dig(model_family(model_id), :input_miss) || default_input_price
-        end
-
-        def output_price_for(model_id)
-          PRICES.dig(model_family(model_id), :output) || default_output_price
-        end
-
-        def cache_hit_price_for(model_id)
-          PRICES.dig(model_family(model_id), :input_hit) || default_cache_hit_price
-        end
-
-        def supports_vision?(_model_id)
-          false
-        end
-
-        def supports_functions?(model_id)
-          model_id.match?(/deepseek-chat/)
-        end
-
         def supports_tool_choice?(_model_id)
           true
         end
@@ -48,90 +14,6 @@ module RubyLLM
         def supports_tool_parallel_control?(_model_id)
           false
         end
-
-        def supports_json_mode?(_model_id)
-          false
-        end
-
-        def format_display_name(model_id)
-          case model_id
-          when 'deepseek-chat' then 'DeepSeek V3'
-          when 'deepseek-reasoner' then 'DeepSeek R1'
-          else
-            model_id.split('-')
-                    .map(&:capitalize)
-                    .join(' ')
-          end
-        end
-
-        def model_type(_model_id)
-          'chat'
-        end
-
-        def model_family(model_id)
-          case model_id
-          when /deepseek-reasoner/ then :reasoner
-          else :chat
-          end
-        end
-
-        PRICES = {
-          chat: {
-            input_hit: 0.07,
-            input_miss: 0.27,
-            output: 1.10
-          },
-          reasoner: {
-            input_hit: 0.14,
-            input_miss: 0.55,
-            output: 2.19
-          }
-        }.freeze
-
-        def default_input_price
-          0.27
-        end
-
-        def default_output_price
-          1.10
-        end
-
-        def default_cache_hit_price
-          0.07
-        end
-
-        def modalities_for(_model_id)
-          {
-            input: ['text'],
-            output: ['text']
-          }
-        end
-
-        def capabilities_for(model_id)
-          capabilities = ['streaming']
-
-          capabilities << 'function_calling' if model_id.match?(/deepseek-chat/)
-
-          capabilities
-        end
-
-        def pricing_for(model_id)
-          family = model_family(model_id)
-          prices = PRICES.fetch(family, { input_miss: default_input_price, output: default_output_price })
-
-          standard_pricing = {
-            input_per_million: prices[:input_miss],
-            output_per_million: prices[:output]
-          }
-
-          standard_pricing[:cached_input_per_million] = prices[:input_hit] if prices[:input_hit]
-
-          {
-            text_tokens: {
-              standard: standard_pricing
-            }
-          }
-        end
       end
     end
   end