ruby_llm 1.2.0 → 1.3.0rc1

data/lib/ruby_llm/providers/anthropic.rb

@@ -15,13 +15,13 @@ module RubyLLM
 
       module_function
 
-      def api_base
+      def api_base(_config)
         'https://api.anthropic.com'
       end
 
-      def headers
+      def headers(config)
         {
-          'x-api-key' => RubyLLM.config.anthropic_api_key,
+          'x-api-key' => config.anthropic_api_key,
           'anthropic-version' => '2023-06-01'
         }
       end

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

@@ -149,8 +149,6 @@ module RubyLLM
           0.2
         end
 
-        private
-
         # Converts a model ID to a human-readable format
         # @param id [String] the model identifier
         # @return [String] the humanized model name
@@ -162,6 +160,67 @@ module RubyLLM
             .map(&:capitalize)
             .join(' ')
         end
+
+        def modalities_for(model_id)
+          modalities = {
+            input: ['text'],
+            output: ['text']
+          }
+
+          # Vision support for Claude models
+          if model_id.match?(/anthropic\.claude/) && supports_vision?(model_id)
+            modalities[:input] << 'image'
+            modalities[:input] << 'pdf'
+          end
+
+          modalities
+        end
+
+        def capabilities_for(model_id)
+          capabilities = []
+
+          # Streaming
+          capabilities << 'streaming' if model_id.match?(/anthropic\.claude/)
+
+          # Function calling & structured output
+          capabilities << 'function_calling' if supports_functions?(model_id)
+
+          capabilities << 'structured_output' if supports_json_mode?(model_id)
+
+          # Extended thinking for 3.7 models
+          capabilities << 'reasoning' if model_id.match?(/claude-3-7/)
+
+          # Batch capabilities for newer Claude models
+          if model_id.match?(/claude-3\.5|claude-3-7/)
+            capabilities << 'batch'
+            capabilities << 'citations'
+          end
+
+          capabilities
+        end
+
+        def pricing_for(model_id)
+          family = model_family(model_id)
+          prices = PRICES.fetch(family, { input: default_input_price, output: default_output_price })
+
+          standard_pricing = {
+            input_per_million: prices[:input],
+            output_per_million: prices[:output]
+          }
+
+          # Batch pricing - typically 50% of standard
+          batch_pricing = {
+            input_per_million: prices[:input] * 0.5,
+            output_per_million: prices[:output] * 0.5
+          }
+
+          {
+            text_tokens: {
+              standard: standard_pricing,
+              batch: batch_pricing
+            }
+          }
+        end
       end
     end
   end

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

@@ -5,58 +5,22 @@ module RubyLLM
     module Bedrock
       # Chat methods for the AWS Bedrock API implementation
       module Chat
-        private
-
-        def completion_url
-          "model/#{@model_id}/invoke"
-        end
-
-        def render_payload(messages, tools:, temperature:, model:, stream: false) # rubocop:disable Lint/UnusedMethodArgument
-          # Hold model_id in instance variable for use in completion_url and stream_url
-          @model_id = model
+        module_function
 
-          system_messages, chat_messages = separate_messages(messages)
-          system_content = build_system_content(system_messages)
-
-          build_base_payload(chat_messages, temperature, model).tap do |payload|
-            add_optional_fields(payload, system_content:, tools:)
+        def sync_response(connection, payload)
+          signature = sign_request("#{connection.connection.url_prefix}#{completion_url}", config: connection.config,
+                                                                                           payload:)
+          response = connection.post completion_url, payload do |req|
+            req.headers.merge! build_headers(signature.headers, streaming: block_given?)
           end
-        end
-
-        def separate_messages(messages)
-          messages.partition { |msg| msg.role == :system }
-        end
-
-        def build_system_content(system_messages)
-          if system_messages.length > 1
-            RubyLLM.logger.warn(
-              "Amazon Bedrock's Claude implementation only supports a single system message. " \
-              'Multiple system messages will be combined into one.'
-            )
-          end
-
-          system_messages.map { |msg| format_message(msg)[:content] }.join("\n\n")
-        end
-
-        def build_base_payload(chat_messages, temperature, model)
-          {
-            anthropic_version: 'bedrock-2023-05-31',
-            messages: chat_messages.map { |msg| format_message(msg) },
-            temperature: temperature,
-            max_tokens: RubyLLM.models.find(model).max_tokens
-          }
-        end
-
-        def add_optional_fields(payload, system_content:, tools:)
-          payload[:tools] = tools.values.map { |t| function_for(t) } if tools.any?
-          payload[:system] = system_content unless system_content.empty?
+          Anthropic::Chat.parse_completion_response response
         end
 
         def format_message(msg)
           if msg.tool_call?
-            format_tool_call(msg)
+            Anthropic::Tools.format_tool_call(msg)
           elsif msg.tool_result?
-            format_tool_result(msg)
+            Anthropic::Tools.format_tool_result(msg)
           else
             format_basic_message(msg)
           end
@@ -64,43 +28,36 @@ module RubyLLM
 
         def format_basic_message(msg)
           {
-            role: convert_role(msg.role),
-            content: Anthropic::Media.format_content(msg.content)
+            role: Anthropic::Chat.convert_role(msg.role),
+            content: Media.format_content(msg.content)
           }
         end
 
-        def convert_role(role)
-          case role
-          when :tool, :user then 'user'
-          when :system then 'system'
-          else 'assistant'
-          end
-        end
+        private
 
-        def parse_completion_response(response)
-          data = response.body
-          content_blocks = data['content'] || []
+        def completion_url
+          "model/#{@model_id}/invoke"
+        end
 
-          text_content = extract_text_content(content_blocks)
-          tool_use = find_tool_use(content_blocks)
+        def render_payload(messages, tools:, temperature:, model:, stream: false) # rubocop:disable Lint/UnusedMethodArgument
+          # Hold model_id in instance variable for use in completion_url and stream_url
+          @model_id = model
 
-          build_message(data, text_content, tool_use)
-        end
+          system_messages, chat_messages = Anthropic::Chat.separate_messages(messages)
+          system_content = Anthropic::Chat.build_system_content(system_messages)
 
-        def extract_text_content(blocks)
-          text_blocks = blocks.select { |c| c['type'] == 'text' }
-          text_blocks.map { |c| c['text'] }.join
+          build_base_payload(chat_messages, temperature, model).tap do |payload|
+            Anthropic::Chat.add_optional_fields(payload, system_content:, tools:)
+          end
         end
 
-        def build_message(data, content, tool_use)
-          Message.new(
-            role: :assistant,
-            content: content,
-            tool_calls: parse_tool_calls(tool_use),
-            input_tokens: data.dig('usage', 'input_tokens'),
-            output_tokens: data.dig('usage', 'output_tokens'),
-            model_id: data['model']
-          )
+        def build_base_payload(chat_messages, temperature, model)
+          {
+            anthropic_version: 'bedrock-2023-05-31',
+            messages: chat_messages.map { |msg| format_message(msg) },
+            temperature: temperature,
+            max_tokens: RubyLLM.models.find(model)&.max_tokens || 4096
+          }
         end
       end
     end

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Providers
+    module Bedrock
+      # Media handling methods for the Bedrock API integration
+      module Media
+        extend Anthropic::Media
+
+        module_function
+
+        def format_content(content)
+          return [Anthropic::Media.format_text(content)] unless content.is_a?(Content)
+
+          parts = []
+          parts << Anthropic::Media.format_text(content.text) if content.text
+
+          content.attachments.each do |attachment|
+            case attachment
+            when Attachments::Image
+              parts << format_image(attachment)
+            when Attachments::PDF
+              parts << format_pdf(attachment)
+            else
+              raise "Unsupported attachment type: #{attachment.class}"
+            end
+          end
+
+          parts
+        end
+
+        def format_image(image)
+          {
+            type: 'image',
+            source: {
+              type: 'base64',
+              media_type: image.mime_type,
+              data: image.encoded
+            }
+          }
+        end
+
+        def format_pdf(pdf)
+          {
+            type: 'document',
+            source: {
+              type: 'base64',
+              media_type: pdf.mime_type,
+              data: pdf.encoded
+            }
+          }
+        end
+      end
+    end
+  end
+end

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

@@ -5,15 +5,14 @@ module RubyLLM
     module Bedrock
       # Models methods for the AWS Bedrock API implementation
       module Models
-        def list_models
-          @connection = nil # reset connection since base url is different
-          @api_base = "https://bedrock.#{RubyLLM.config.bedrock_region}.amazonaws.com"
-          full_models_url = "#{@api_base}/#{models_url}"
-          signature = sign_request(full_models_url, method: :get)
-          response = connection.get(models_url) do |req|
+        def list_models(connection:)
+          config = connection.config
+          mgmt_api_base = "https://bedrock.#{config.bedrock_region}.amazonaws.com"
+          full_models_url = "#{mgmt_api_base}/#{models_url}"
+          signature = sign_request(full_models_url, config: config, method: :get)
+          response = connection.get(full_models_url) do |req|
             req.headers.merge! signature.headers
           end
-          @connection = nil # reset connection since base url is different
 
           parse_list_models_response(response, slug, capabilities)
         end
@@ -25,65 +24,58 @@ module RubyLLM
         end
 
         def parse_list_models_response(response, slug, capabilities)
-          data = response.body['modelSummaries'] || []
-          data.filter { |model| model['modelId'].include?('claude') }
-              .map { |model| create_model_info(model, slug, capabilities) }
-        end
+          models = Array(response.body['modelSummaries'])
 
-        def create_model_info(model, slug, capabilities)
-          model_id = model['modelId']
-          ModelInfo.new(
-            **base_model_attributes(model_id, model, slug),
-            **capability_attributes(model_id, capabilities),
-            **pricing_attributes(model_id, capabilities),
-            metadata: build_metadata(model)
-          )
-        end
+          # Filter to include only models we care about
+          models.select { |m| m['modelId'].include?('claude') }.map do |model_data|
+            model_id = model_data['modelId']
 
-        def base_model_attributes(model_id, model, slug)
-          {
-            id: model_id_with_prefix(model_id, model),
-            created_at: nil,
-            display_name: model['modelName'] || capabilities.format_display_name(model_id),
-            provider: slug
-          }
+            ModelInfo.new(
+              id: model_id_with_region(model_id, model_data),
+              name: model_data['modelName'] || capabilities.format_display_name(model_id),
+              provider: slug,
+              family: capabilities.model_family(model_id),
+              created_at: nil,
+              context_window: capabilities.context_window_for(model_id),
+              max_output_tokens: capabilities.max_tokens_for(model_id),
+              modalities: capabilities.modalities_for(model_id),
+              capabilities: capabilities.capabilities_for(model_id),
+              pricing: capabilities.pricing_for(model_id),
+              metadata: {
+                provider_name: model_data['providerName'],
+                inference_types: model_data['inferenceTypesSupported'] || [],
+                streaming_supported: model_data['responseStreamingSupported'] || false,
+                input_modalities: model_data['inputModalities'] || [],
+                output_modalities: model_data['outputModalities'] || []
+              }
+            )
+          end
         end
 
-        def model_id_with_prefix(model_id, model)
-          return model_id unless model['inferenceTypesSupported']&.include?('INFERENCE_PROFILE')
-          return model_id if model['inferenceTypesSupported']&.include?('ON_DEMAND')
-
-          "us.#{model_id}"
-        end
+        # Simple test-friendly method that only sets the ID
+        def create_model_info(model_data, slug, _capabilities)
+          model_id = model_data['modelId']
 
-        def capability_attributes(model_id, capabilities)
-          {
-            context_window: capabilities.context_window_for(model_id),
-            max_tokens: capabilities.max_tokens_for(model_id),
-            type: capabilities.model_type(model_id),
-            family: capabilities.model_family(model_id).to_s,
-            supports_vision: capabilities.supports_vision?(model_id),
-            supports_functions: capabilities.supports_functions?(model_id),
-            supports_json_mode: capabilities.supports_json_mode?(model_id)
-          }
+          ModelInfo.new(
+            id: model_id_with_region(model_id, model_data),
+            name: model_data['modelName'] || model_id,
+            provider: slug,
+            family: 'claude',
+            created_at: nil,
+            context_window: 200_000,
+            max_output_tokens: 4096,
+            modalities: { input: ['text'], output: ['text'] },
+            capabilities: [],
+            pricing: {},
+            metadata: {}
+          )
         end
 
-        def pricing_attributes(model_id, capabilities)
-          {
-            input_price_per_million: capabilities.input_price_for(model_id),
-            output_price_per_million: capabilities.output_price_for(model_id)
-          }
-        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')
 
-        def build_metadata(model)
-          {
-            provider_name: model['providerName'],
-            customizations_supported: model['customizationsSupported'] || [],
-            inference_configurations: model['inferenceTypesSupported'] || [],
-            response_streaming_supported: model['responseStreamingSupported'] || false,
-            input_modalities: model['inputModalities'] || [],
-            output_modalities: model['outputModalities'] || []
-          }
+          "us.#{model_id}"
         end
       end
     end

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

@@ -29,6 +29,22 @@ module RubyLLM
             "model/#{@model_id}/invoke-with-response-stream"
           end
 
+          def stream_response(connection, payload, &block)
+            signature = sign_request("#{connection.connection.url_prefix}#{stream_url}", config: connection.config,
+                                                                                         payload:)
+            accumulator = StreamAccumulator.new
+
+            connection.post stream_url, payload do |req|
+              req.headers.merge! build_headers(signature.headers, streaming: block_given?)
+              req.options.on_data = handle_stream do |chunk|
+                accumulator.add chunk
+                block.call chunk
+              end
+            end
+
+            accumulator.to_message
+          end
+
           def handle_stream(&block)
             buffer = String.new
             proc do |chunk, _bytes, env|

data/lib/ruby_llm/providers/bedrock.rb

@@ -13,27 +13,16 @@ module RubyLLM
       extend Bedrock::Streaming
       extend Bedrock::Models
       extend Bedrock::Signing
-
-      # This provider currently only supports Anthropic models, so the tools/media implementation is shared
-      extend Anthropic::Media
+      extend Bedrock::Media
       extend Anthropic::Tools
 
       module_function
 
-      def api_base
-        @api_base ||= "https://bedrock-runtime.#{RubyLLM.config.bedrock_region}.amazonaws.com"
-      end
-
-      def post(url, payload)
-        signature = sign_request("#{connection.url_prefix}#{url}", payload:)
-        connection.post url, payload do |req|
-          req.headers.merge! build_headers(signature.headers, streaming: block_given?)
-
-          yield req if block_given?
-        end
+      def api_base(config)
+        "https://bedrock-runtime.#{config.bedrock_region}.amazonaws.com"
       end
 
-      def parse_error(response) # rubocop:disable Metrics/MethodLength
+      def parse_error(response)
         return if response.body.empty?
 
         body = try_parse_json(response.body)
@@ -49,25 +38,25 @@ module RubyLLM
         end
       end
 
-      def sign_request(url, method: :post, payload: nil)
-        signer = create_signer
-        request = build_request(url, method:, payload:)
+      def sign_request(url, config:, method: :post, payload: nil)
+        signer = create_signer(config)
+        request = build_request(url, config:, method:, payload:)
         signer.sign_request(request)
       end
 
-      def create_signer
+      def create_signer(config)
         Signing::Signer.new({
-                              access_key_id: RubyLLM.config.bedrock_api_key,
-                              secret_access_key: RubyLLM.config.bedrock_secret_key,
-                              session_token: RubyLLM.config.bedrock_session_token,
-                              region: RubyLLM.config.bedrock_region,
+                              access_key_id: config.bedrock_api_key,
+                              secret_access_key: config.bedrock_secret_key,
+                              session_token: config.bedrock_session_token,
+                              region: config.bedrock_region,
                               service: 'bedrock'
                             })
       end
 
-      def build_request(url, method: :post, payload: nil)
+      def build_request(url, config:, method: :post, payload: nil)
         {
-          connection: connection,
+          connection: connection(config),
           http_method: method,
           url: url || completion_url,
           body: payload ? JSON.generate(payload, ascii_only: false) : nil

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

@@ -114,8 +114,6 @@ module RubyLLM
           }
         }.freeze
 
-        private
-
         # Default input price when model family can't be determined
         # @return [Float] the default input price
         def default_input_price
@@ -133,6 +131,41 @@ module RubyLLM
         def default_cache_hit_price
           0.07 # Default to chat cache hit price
         end
+
+        def modalities_for(_model_id)
+          {
+            input: ['text'],
+            output: ['text']
+          }
+        end
+
+        def capabilities_for(model_id)
+          capabilities = ['streaming']
+
+          # Function calling for chat models
+          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]
+          }
+
+          # Add cached pricing if available
+          standard_pricing[:cached_input_per_million] = prices[:input_hit] if prices[:input_hit]
+
+          {
+            text_tokens: {
+              standard: standard_pricing
+            }
+          }
+        end
       end
     end
   end

data/lib/ruby_llm/providers/deepseek.rb

@@ -9,13 +9,13 @@ module RubyLLM
 
       module_function
 
-      def api_base
+      def api_base(_config)
         'https://api.deepseek.com'
       end
 
-      def headers
+      def headers(config)
         {
-          'Authorization' => "Bearer #{RubyLLM.config.deepseek_api_key}"
+          'Authorization' => "Bearer #{config.deepseek_api_key}"
         }
       end