ruby_llm 1.13.2 → 1.16.0

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

@@ -16,7 +16,7 @@ module RubyLLM
 
           content = []
 
-          content << Media.format_text(msg.content) unless msg.content.nil? || msg.content.empty?
+          append_formatted_content(content, msg.content) unless msg.content.nil? || msg.content.empty?
 
           msg.tool_calls.each_value do |tool_call|
             content << format_tool_use_block(tool_call)
@@ -44,11 +44,23 @@ module RubyLLM
           }
         end
 
+        def append_formatted_content(content_blocks, content)
+          formatted_content = Media.format_content(content)
+          if formatted_content.is_a?(Array)
+            content_blocks.concat(formatted_content)
+          else
+            content_blocks << formatted_content
+          end
+        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
 
@@ -69,12 +81,29 @@ module RubyLLM
 
         def extract_tool_calls(data)
           if json_delta?(data)
-            { nil => ToolCall.new(id: nil, name: nil, arguments: data.dig('delta', 'partial_json')) }
+            extract_tool_call_delta(data)
+          elsif content_block_start?(data)
+            extract_tool_call_start(data)
           else
             parse_tool_calls(data['content_block'])
           end
         end
 
+        def extract_tool_call_delta(data)
+          { data['index'] => ToolCall.new(id: nil, name: nil, arguments: data.dig('delta', 'partial_json')) }
+        end
+
+        def extract_tool_call_start(data)
+          tool_calls = parse_tool_calls(data['content_block'])
+          return tool_calls if tool_calls.nil? || data['index'].nil?
+
+          { data['index'] => tool_calls.values.first }
+        end
+
+        def content_block_start?(data)
+          data['type'] == 'content_block_start'
+        end
+
         def parse_tool_calls(content_blocks)
           return nil if content_blocks.nil?
 

data/lib/ruby_llm/providers/anthropic.rb

@@ -27,6 +27,10 @@ module RubyLLM
           Anthropic::Capabilities
         end
 
+        def configuration_options
+          %i[anthropic_api_key anthropic_api_base]
+        end
+
         def configuration_requirements
           %i[anthropic_api_key]
         end

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

@@ -24,7 +24,7 @@ module RubyLLM
             when :text
               parts << OpenAI::Media.format_text_file(attachment)
             else
-              raise UnsupportedAttachmentError, attachment.type
+              raise UnsupportedAttachmentError, attachment.mime_type
             end
           end
 

data/lib/ruby_llm/providers/azure.rb

@@ -44,6 +44,10 @@ module RubyLLM
       end
 
       class << self
+        def configuration_options
+          %i[azure_api_base azure_api_key azure_ai_auth_token]
+        end
+
         def configuration_requirements
           %i[azure_api_base]
         end

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

@@ -1,6 +1,7 @@
 # frozen_string_literal: true
 
 require 'digest'
+require 'json'
 require 'openssl'
 
 module RubyLLM

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

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'json'
+
 module RubyLLM
   module Providers
     class Bedrock
@@ -56,7 +58,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 +68,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 +163,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/media.rb

@@ -38,15 +38,17 @@ module RubyLLM
           case attachment.type
           when :image
             render_image_attachment(attachment)
-          when :pdf
+          when :pdf, :document
             render_document_attachment(attachment, used_document_names:)
           when :text
-            { text: attachment.for_llm }
+            render_text_attachment(attachment)
           else
             raise UnsupportedAttachmentError, attachment.mime_type
           end
         end
 
+        SUPPORTED_DOCUMENT_FORMATS = %w[pdf csv doc docx xls xlsx html txt md].freeze
+
         def render_image_attachment(attachment)
           {
             image: {
@@ -58,11 +60,19 @@ module RubyLLM
           }
         end
 
+        def render_text_attachment(attachment)
+          { text: attachment.for_llm }
+        end
+
         def render_document_attachment(attachment, used_document_names:)
+          format = document_format(attachment)
+
+          raise UnsupportedAttachmentError, attachment.mime_type unless supported_document_format?(attachment)
+
           document_name = unique_document_name(sanitize_document_name(attachment.filename), used_document_names)
           {
             document: {
-              format: attachment.format,
+              format: format,
               name: document_name,
               source: {
                 bytes: attachment.encoded
@@ -71,6 +81,14 @@ module RubyLLM
           }
         end
 
+        def supported_document_format?(attachment)
+          SUPPORTED_DOCUMENT_FORMATS.include?(document_format(attachment))
+        end
+
+        def document_format(attachment)
+          attachment.extension || attachment.format
+        end
+
         def sanitize_document_name(filename)
           base = File.basename(filename.to_s, '.*')
           safe = base.gsub(/[^a-zA-Z0-9_-]/, '_')

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

@@ -10,7 +10,7 @@ module RubyLLM
         REGION_PREFIXES = %w[global us eu ap sa ca me af il].freeze
 
         def models_api_base
-          "https://bedrock.#{bedrock_region}.amazonaws.com"
+          @config.bedrock_api_base || "https://bedrock.#{bedrock_region}.amazonaws.com"
         end
 
         def models_url

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

@@ -1,5 +1,9 @@
 # frozen_string_literal: true
 
+require 'base64'
+require 'faraday'
+require 'json'
+
 module RubyLLM
   module Providers
     class Bedrock
@@ -158,7 +162,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)
@@ -221,6 +228,7 @@ module RubyLLM
 
           reasoning_text = reasoning_content['reasoningText'] || {}
           return reasoning_text['text'] if reasoning_text['text']
+          return reasoning_content['text'] if reasoning_content['text']
           return event.dig('delta', 'thinking') if event.dig('delta', 'type') == 'thinking_delta'
 
           nil
@@ -241,6 +249,7 @@ module RubyLLM
           reasoning_content = delta['reasoningContent'] || {}
           reasoning_text = reasoning_content['reasoningText'] || {}
           return reasoning_text['signature'] if reasoning_text['signature']
+          return reasoning_content['signature'] if reasoning_content['signature']
           return event.dig('delta', 'signature') if event.dig('delta', 'type') == 'signature_delta'
 
           nil

data/lib/ruby_llm/providers/bedrock.rb

@@ -11,7 +11,7 @@ module RubyLLM
       include Bedrock::Streaming
 
       def api_base
-        "https://bedrock-runtime.#{bedrock_region}.amazonaws.com"
+        @config.bedrock_api_base || "https://bedrock-runtime.#{bedrock_region}.amazonaws.com"
       end
 
       def headers
@@ -53,6 +53,10 @@ module RubyLLM
       end
 
       class << self
+        def configuration_options
+          %i[bedrock_api_key bedrock_secret_key bedrock_region bedrock_session_token bedrock_api_base]
+        end
+
         def configuration_requirements
           %i[bedrock_api_key bedrock_secret_key bedrock_region]
         end

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

@@ -3,43 +3,22 @@
 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
+        DEFAULT_CONTEXT_WINDOW = 1_000_000
+        DEFAULT_MAX_OUTPUT_TOKENS = 384_000
+        DEFAULT_PRICES = {
+          input: 0.14,
+          output: 0.28,
+          cache_read: 0.0028
+        }.freeze
+        PRO_PRICES = {
+          input: 0.435,
+          output: 0.87,
+          cache_read: 0.003625
+        }.freeze
 
         def supports_tool_choice?(_model_id)
           true
@@ -49,86 +28,32 @@ module RubyLLM
           false
         end
 
-        def supports_json_mode?(_model_id)
-          false
+        def context_window_for(_model_id)
+          DEFAULT_CONTEXT_WINDOW
         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
+        def max_tokens_for(_model_id)
+          DEFAULT_MAX_OUTPUT_TOKENS
         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/)
-
+        def critical_capabilities_for(model_id)
+          v4_model = model_id.start_with?('deepseek-v4-')
+          capabilities = ['function_calling']
+          capabilities << 'structured_output' if v4_model
+          capabilities << 'reasoning' if model_id == 'deepseek-reasoner' || v4_model
           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]
+          prices = model_id == 'deepseek-v4-pro' ? PRO_PRICES : DEFAULT_PRICES
 
           {
             text_tokens: {
-              standard: standard_pricing
+              standard: {
+                input_per_million: prices[:input],
+                output_per_million: prices[:output],
+                cache_read_input_per_million: prices[:cache_read]
+              }
             }
           }
         end

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

@@ -10,6 +10,15 @@ module RubyLLM
         def format_role(role)
           role.to_s
         end
+
+        def format_content(content)
+          OpenAI::Media.format_content(
+            content,
+            document_attachments: :none,
+            image_attachments: false,
+            audio_attachments: false
+          )
+        end
       end
     end
   end

data/lib/ruby_llm/providers/deepseek.rb

@@ -21,6 +21,10 @@ module RubyLLM
           DeepSeek::Capabilities
         end
 
+        def configuration_options
+          %i[deepseek_api_key deepseek_api_base]
+        end
+
         def configuration_requirements
           %i[deepseek_api_key]
         end