ruby_llm 1.0.0 → 1.1.0rc1

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

@@ -7,202 +7,169 @@ module RubyLLM
       module Capabilities # rubocop:disable Metrics/ModuleLength
         module_function
 
-        # Returns the context window size for the given model ID
-        # @param model_id [String] the model identifier
-        # @return [Integer] the context window size in tokens
-        def context_window_for(model_id)
-          case model_id
-          when /o1-2024/, /o3-mini/, /o3-mini-2025/ then 200_000
-          when /gpt-4o/, /gpt-4o-mini/, /gpt-4-turbo/, /o1-mini/ then 128_000
-          when /gpt-4-0[0-9]{3}/ then 8_192
-          when /gpt-3.5-turbo$/, /babbage-002/, /davinci-002/, /16k/ then 16_385
+        MODEL_PATTERNS = {
+          dall_e: /^dall-e/,
+          chatgpt4o: /^chatgpt-4o/,
+          gpt4: /^gpt-4(?:-\d{6})?$/,
+          gpt4_turbo: /^gpt-4(?:\.5)?-(?:\d{6}-)?(preview|turbo)/,
+          gpt35_turbo: /^gpt-3\.5-turbo/,
+          gpt4o: /^gpt-4o(?!-(?:mini|audio|realtime|transcribe|tts|search))/,
+          gpt4o_audio: /^gpt-4o-(?:audio)/,
+          gpt4o_mini: /^gpt-4o-mini(?!-(?:audio|realtime|transcribe|tts|search))/,
+          gpt4o_mini_audio: /^gpt-4o-mini-audio/,
+          gpt4o_mini_realtime: /^gpt-4o-mini-realtime/,
+          gpt4o_mini_transcribe: /^gpt-4o-mini-transcribe/,
+          gpt4o_mini_tts: /^gpt-4o-mini-tts/,
+          gpt4o_realtime: /^gpt-4o-realtime/,
+          gpt4o_search: /^gpt-4o-search/,
+          gpt4o_transcribe: /^gpt-4o-transcribe/,
+          o1: /^o1(?!-(?:mini|pro))/,
+          o1_mini: /^o1-mini/,
+          o1_pro: /^o1-pro/,
+          o3_mini: /^o3-mini/,
+          babbage: /^babbage/,
+          davinci: /^davinci/,
+          embedding3_large: /^text-embedding-3-large/,
+          embedding3_small: /^text-embedding-3-small/,
+          embedding_ada: /^text-embedding-ada/,
+          tts1: /^tts-1(?!-hd)/,
+          tts1_hd: /^tts-1-hd/,
+          whisper: /^whisper/,
+          moderation: /^(?:omni|text)-moderation/
+        }.freeze
+
+        def context_window_for(model_id) # rubocop:disable Metrics/MethodLength
+          case model_family(model_id)
+          when 'chatgpt4o', 'gpt4_turbo', 'gpt4o', 'gpt4o_audio', 'gpt4o_mini',
+               'gpt4o_mini_audio', 'gpt4o_mini_realtime', 'gpt4o_realtime',
+               'gpt4o_search', 'gpt4o_transcribe', 'gpt4o_mini_search', 'o1_mini' then 128_000
+          when 'gpt4' then 8_192
+          when 'gpt4o_mini_transcribe' then 16_000
+          when 'o1', 'o1_pro', 'o3_mini' then 200_000
+          when 'gpt35_turbo' then 16_385
+          when 'gpt4o_mini_tts', 'tts1', 'tts1_hd', 'whisper', 'moderation',
+               'embedding3_large', 'embedding3_small', 'embedding_ada' then nil
           else 4_096
           end
         end
 
-        # Returns the maximum output tokens for the given model ID
-        # @param model_id [String] the model identifier
-        # @return [Integer] the maximum output tokens
-        def max_tokens_for(model_id)
-          case model_id
-          when /o1-2024/, /o3-mini/, /o3-mini-2025/ then 100_000
-          when /o1-mini-2024/ then 65_536
-          when /gpt-4o/, /gpt-4o-mini/, /gpt-4o-audio/, /gpt-4o-mini-audio/, /babbage-002/, /davinci-002/ then 16_384
-          when /gpt-4-0[0-9]{3}/ then 8_192
-          else 4_096
+        def max_tokens_for(model_id) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength
+          case model_family(model_id)
+          when 'chatgpt4o', 'gpt4o', 'gpt4o_mini', 'gpt4o_mini_search' then 16_384
+          when 'babbage', 'davinci' then 16_384 # rubocop:disable Lint/DuplicateBranch
+          when 'gpt4' then 8_192
+          when 'gpt35_turbo' then 4_096
+          when 'gpt4_turbo', 'gpt4o_realtime', 'gpt4o_mini_realtime' then 4_096 # rubocop:disable Lint/DuplicateBranch
+          when 'gpt4o_mini_transcribe' then 2_000
+          when 'o1', 'o1_pro', 'o3_mini' then 100_000
+          when 'o1_mini' then 65_536
+          when 'gpt4o_mini_tts', 'tts1', 'tts1_hd', 'whisper', 'moderation',
+               'embedding3_large', 'embedding3_small', 'embedding_ada' then nil
+          else 16_384 # rubocop:disable Lint/DuplicateBranch
           end
         end
 
-        # Returns the input price per million tokens for the given model ID
-        # @param model_id [String] the model identifier
-        # @return [Float] the price per million tokens for input
-        def input_price_for(model_id)
-          PRICES.dig(model_family(model_id), :input) || default_input_price
+        def supports_vision?(model_id)
+          case model_family(model_id)
+          when 'chatgpt4o', 'gpt4', 'gpt4_turbo', 'gpt4o', 'gpt4o_mini', 'o1', 'o1_pro',
+               'moderation', 'gpt4o_search', 'gpt4o_mini_search' then true
+          else false
+          end
         end
 
-        # Returns the output price per million tokens for the given model ID
-        # @param model_id [String] the model identifier
-        # @return [Float] the price per million tokens for output
-        def output_price_for(model_id)
-          PRICES.dig(model_family(model_id), :output) || default_output_price
+        def supports_functions?(model_id)
+          case model_family(model_id)
+          when 'gpt4', 'gpt4_turbo', 'gpt4o', 'gpt4o_mini', 'o1', 'o1_pro', 'o3_mini' then true
+          when 'chatgpt4o', 'gpt35_turbo', 'o1_mini', 'gpt4o_mini_tts',
+               'gpt4o_transcribe', 'gpt4o_search', 'gpt4o_mini_search' then false
+          else false # rubocop:disable Lint/DuplicateBranch
+          end
         end
 
-        # Determines if the model supports vision capabilities
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports vision
-        def supports_vision?(model_id)
-          model_id.match?(/gpt-4o|o1/) || model_id.match?(/gpt-4-(?!0314|0613)/)
+        def supports_structured_output?(model_id)
+          case model_family(model_id)
+          when 'chatgpt4o', 'gpt4o', 'gpt4o_mini', 'o1', 'o1_pro', 'o3_mini' then true
+          else false
+          end
         end
 
-        # Determines if the model supports function calling
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports functions
-        def supports_functions?(model_id)
-          !model_id.include?('instruct')
+        def supports_json_mode?(model_id)
+          supports_structured_output?(model_id)
         end
 
-        # Determines if the model supports audio input/output
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports audio
-        def supports_audio?(model_id)
-          model_id.match?(/audio-preview|realtime-preview|whisper|tts/)
+        PRICES = {
+          chatgpt4o: { input: 5.0, output: 15.0 },
+          gpt4: { input: 10.0, output: 30.0 },
+          gpt4_turbo: { input: 10.0, output: 30.0 },
+          gpt45: { input: 75.0, output: 150.0 },
+          gpt35_turbo: { input: 0.5, output: 1.5 },
+          gpt4o: { input: 2.5, output: 10.0 },
+          gpt4o_audio: { input: 2.5, output: 10.0, audio_input: 40.0, audio_output: 80.0 },
+          gpt4o_mini: { input: 0.15, output: 0.6 },
+          gpt4o_mini_audio: { input: 0.15, output: 0.6, audio_input: 10.0, audio_output: 20.0 },
+          gpt4o_mini_realtime: { input: 0.6, output: 2.4 },
+          gpt4o_mini_transcribe: { input: 1.25, output: 5.0, audio_input: 3.0 },
+          gpt4o_mini_tts: { input: 0.6, output: 12.0 },
+          gpt4o_realtime: { input: 5.0, output: 20.0 },
+          gpt4o_search: { input: 2.5, output: 10.0 },
+          gpt4o_transcribe: { input: 2.5, output: 10.0, audio_input: 6.0 },
+          o1: { input: 15.0, output: 60.0 },
+          o1_mini: { input: 1.1, output: 4.4 },
+          o1_pro: { input: 150.0, output: 600.0 },
+          o3_mini: { input: 1.1, output: 4.4 },
+          babbage: { input: 0.4, output: 0.4 },
+          davinci: { input: 2.0, output: 2.0 },
+          embedding3_large: { price: 0.13 },
+          embedding3_small: { price: 0.02 },
+          embedding_ada: { price: 0.10 },
+          tts1: { price: 15.0 },
+          tts1_hd: { price: 30.0 },
+          whisper: { price: 0.006 },
+          moderation: { price: 0.0 }
+        }.freeze
+
+        def model_family(model_id)
+          MODEL_PATTERNS.each do |family, pattern|
+            return family.to_s if model_id.match?(pattern)
+          end
+          'other'
         end
 
-        # Determines if the model supports JSON mode
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports JSON mode
-        def supports_json_mode?(model_id)
-          model_id.match?(/gpt-4-\d{4}-preview/) ||
-            model_id.include?('turbo') ||
-            model_id.match?(/gpt-3.5-turbo-(?!0301|0613)/)
+        def input_price_for(model_id)
+          family = model_family(model_id).to_sym
+          prices = PRICES.fetch(family, { input: default_input_price })
+          prices[:input] || prices[:price] || default_input_price
         end
 
-        # Formats the model ID into a human-readable display name
-        # @param model_id [String] the model identifier
-        # @return [String] the formatted display name
-        def format_display_name(model_id)
-          model_id.then { |id| humanize(id) }
-                  .then { |name| apply_special_formatting(name) }
+        def output_price_for(model_id)
+          family = model_family(model_id).to_sym
+          prices = PRICES.fetch(family, { output: default_output_price })
+          prices[:output] || prices[:price] || default_output_price
         end
 
-        # Determines the type of model
-        # @param model_id [String] the model identifier
-        # @return [String] the model type (chat, embedding, image, audio, moderation)
         def model_type(model_id)
-          case model_id
-          when /text-embedding|embedding/ then 'embedding'
-          when /dall-e/ then 'image'
-          when /tts|whisper/ then 'audio'
-          when /omni-moderation|text-moderation/ then 'moderation'
+          case model_family(model_id)
+          when /embedding/ then 'embedding'
+          when /^tts|whisper|gpt4o_(?:mini_)?(?:transcribe|tts)$/ then 'audio'
+          when 'moderation' then 'moderation'
+          when /dall/ then 'image'
           else 'chat'
           end
         end
 
-        # Determines if the model supports structured output
-        # @param model_id [String] the model identifier
-        # @return [Boolean] true if the model supports structured output
-        def supports_structured_output?(model_id)
-          model_id.match?(/gpt-4o|o[13]-mini|o1|o3-mini/)
-        end
-
-        # Determines the model family for pricing and capability lookup
-        # @param model_id [String] the model identifier
-        # @return [Symbol] the model family identifier
-        def model_family(model_id) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength
-          case model_id
-          when /o3-mini/ then 'o3_mini'
-          when /o1-mini/ then 'o1_mini'
-          when /o1/ then 'o1'
-          when /gpt-4o-audio/ then 'gpt4o_audio'
-          when /gpt-4o-realtime/ then 'gpt4o_realtime'
-          when /gpt-4o-mini-audio/ then 'gpt4o_mini_audio'
-          when /gpt-4o-mini-realtime/ then 'gpt4o_mini_realtime'
-          when /gpt-4o-mini/ then 'gpt4o_mini'
-          when /gpt-4o/ then 'gpt4o'
-          when /gpt-4-turbo/ then 'gpt4_turbo'
-          when /gpt-4/ then 'gpt4'
-          when /gpt-3.5-turbo-instruct/ then 'gpt35_instruct'
-          when /gpt-3.5/ then 'gpt35'
-          when /dall-e-3/ then 'dalle3'
-          when /dall-e-2/ then 'dalle2'
-          when /text-embedding-3-large/ then 'embedding3_large'
-          when /text-embedding-3-small/ then 'embedding3_small'
-          when /text-embedding-ada/ then 'embedding2'
-          when /tts-1-hd/ then 'tts1_hd'
-          when /tts-1/ then 'tts1'
-          when /whisper/ then 'whisper1'
-          when /omni-moderation|text-moderation/ then 'moderation'
-          when /babbage/ then 'babbage'
-          when /davinci/ then 'davinci'
-          else 'other'
-          end
-        end
-
-        # Pricing information for OpenAI models (per million tokens unless otherwise specified)
-        PRICES = {
-          o1: { input: 15.0, cached_input: 7.5, output: 60.0 },
-          o1_mini: { input: 1.10, cached_input: 0.55, output: 4.40 },
-          o3_mini: { input: 1.10, cached_input: 0.55, output: 4.40 },
-          gpt4o: { input: 2.50, cached_input: 1.25, output: 10.0 },
-          gpt4o_audio: {
-            text_input: 2.50,
-            audio_input: 40.0,
-            text_output: 10.0,
-            audio_output: 80.0
-          },
-          gpt4o_realtime: {
-            text_input: 5.0,
-            cached_text_input: 2.50,
-            audio_input: 40.0,
-            cached_audio_input: 2.50,
-            text_output: 20.0,
-            audio_output: 80.0
-          },
-          gpt4o_mini: { input: 0.15, cached_input: 0.075, output: 0.60 },
-          gpt4o_mini_audio: {
-            text_input: 0.15,
-            audio_input: 10.0,
-            text_output: 0.60,
-            audio_output: 20.0
-          },
-          gpt4o_mini_realtime: {
-            text_input: 0.60,
-            cached_text_input: 0.30,
-            audio_input: 10.0,
-            cached_audio_input: 0.30,
-            text_output: 2.40,
-            audio_output: 20.0
-          },
-          gpt4_turbo: { input: 10.0, output: 30.0 },
-          gpt4: { input: 30.0, output: 60.0 },
-          gpt35: { input: 0.50, output: 1.50 },
-          gpt35_instruct: { input: 1.50, output: 2.0 },
-          embedding3_large: { price: 0.13 },
-          embedding3_small: { price: 0.02 },
-          embedding2: { price: 0.10 },
-          davinci: { input: 2.0, output: 2.0 },
-          babbage: { input: 0.40, output: 0.40 },
-          tts1: { price: 15.0 }, # per million characters
-          tts1_hd: { price: 30.0 }, # per million characters
-          whisper1: { price: 0.006 }, # per minute
-          moderation: { price: 0.0 } # free
-        }.freeze
-
-        # Default input price when model-specific pricing is not available
-        # @return [Float] the default price per million tokens
         def default_input_price
           0.50
         end
 
-        # Default output price when model-specific pricing is not available
-        # @return [Float] the default price per million tokens
         def default_output_price
           1.50
         end
 
-        # Converts a model ID to a human-readable format
-        # @param id [String] the model identifier
-        # @return [String] the humanized model name
+        def format_display_name(model_id)
+          model_id.then { |id| humanize(id) }
+                  .then { |name| apply_special_formatting(name) }
+        end
+
         def humanize(id)
           id.tr('-', ' ')
             .split
@@ -210,25 +177,35 @@ module RubyLLM
             .join(' ')
         end
 
-        # Applies special formatting rules to model names
-        # @param name [String] the humanized model name
-        # @return [String] the specially formatted model name
-        def apply_special_formatting(name) # rubocop:disable Metrics/MethodLength
+        def apply_special_formatting(name)
           name
             .gsub(/(\d{4}) (\d{2}) (\d{2})/, '\1\2\3')
-            .gsub(/^Gpt /, 'GPT-')
+            .gsub(/^(?:Gpt|Chatgpt|Tts|Dall E) /) { |m| special_prefix_format(m.strip) }
             .gsub(/^O([13]) /, 'O\1-')
-            .gsub(/^O3 Mini/, 'O3-Mini')
-            .gsub(/^O1 Mini/, 'O1-Mini')
-            .gsub(/^Chatgpt /, 'ChatGPT-')
-            .gsub(/^Tts /, 'TTS-')
-            .gsub(/^Dall E /, 'DALL-E-')
-            .gsub('3.5 ', '3.5-')
-            .gsub('4 ', '4-')
-            .gsub(/4o (?=Mini|Preview|Turbo|Audio|Realtime)/, '4o-')
+            .gsub(/^O[13] Mini/, '\0'.gsub(' ', '-'))
+            .gsub(/\d\.\d /, '\0'.sub(' ', '-'))
+            .gsub(/4o (?=Mini|Preview|Turbo|Audio|Realtime|Transcribe|Tts)/, '4o-')
             .gsub(/\bHd\b/, 'HD')
-            .gsub('Omni Moderation', 'Omni-Moderation')
-            .gsub('Text Moderation', 'Text-Moderation')
+            .gsub(/(?:Omni|Text) Moderation/, '\0'.gsub(' ', '-'))
+            .gsub('Text Embedding', 'text-embedding-')
+        end
+
+        def special_prefix_format(prefix)
+          case prefix # rubocop:disable Style/HashLikeCase
+          when 'Gpt' then 'GPT-'
+          when 'Chatgpt' then 'ChatGPT-'
+          when 'Tts' then 'TTS-'
+          when 'Dall E' then 'DALL-E-'
+          end
+        end
+
+        def normalize_temperature(temperature, model_id)
+          if model_id.match?(/^o[13]/)
+            RubyLLM.logger.debug "Model #{model_id} requires temperature=1.0, ignoring provided value"
+            1.0
+          else
+            temperature
+          end
         end
       end
     end

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

@@ -11,19 +11,15 @@ module RubyLLM
           completion_url
         end
 
-        def handle_stream(&block) # rubocop:disable Metrics/MethodLength
-          to_json_stream do |data|
-            block.call(
-              Chunk.new(
-                role: :assistant,
-                model_id: data['model'],
-                content: data.dig('choices', 0, 'delta', 'content'),
-                tool_calls: parse_tool_calls(data.dig('choices', 0, 'delta', 'tool_calls'), parse_arguments: false),
-                input_tokens: data.dig('usage', 'prompt_tokens'),
-                output_tokens: data.dig('usage', 'completion_tokens')
-              )
-            )
-          end
+        def build_chunk(data)
+          Chunk.new(
+            role: :assistant,
+            model_id: data['model'],
+            content: data.dig('choices', 0, 'delta', 'content'),
+            tool_calls: parse_tool_calls(data.dig('choices', 0, 'delta', 'tool_calls'), parse_arguments: false),
+            input_tokens: data.dig('usage', 'prompt_tokens'),
+            output_tokens: data.dig('usage', 'completion_tokens')
+          )
         end
       end
     end

data/lib/ruby_llm/providers/openai.rb

@@ -45,6 +45,10 @@ module RubyLLM
       def slug
         'openai'
       end
+
+      def configuration_requirements
+        %i[openai_api_key]
+      end
     end
   end
 end

data/lib/ruby_llm/streaming.rb

@@ -0,0 +1,96 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Handles streaming responses from AI providers. Provides a unified way to process
+  # chunked responses, accumulate content, and handle provider-specific streaming formats.
+  # Each provider implements provider-specific parsing while sharing common stream handling
+  # patterns.
+  module Streaming
+    module_function
+
+    def stream_response(payload, &block)
+      accumulator = StreamAccumulator.new
+
+      post stream_url, payload do |req|
+        req.options.on_data = handle_stream do |chunk|
+          accumulator.add chunk
+          block.call chunk
+        end
+      end
+
+      accumulator.to_message
+    end
+
+    def handle_stream(&block)
+      to_json_stream do |data|
+        block.call(build_chunk(data)) if data
+      end
+    end
+
+    private
+
+    def to_json_stream(&block) # rubocop:disable Metrics/MethodLength
+      buffer = String.new
+      parser = EventStreamParser::Parser.new
+
+      proc do |chunk, _bytes, env|
+        RubyLLM.logger.debug "Received chunk: #{chunk}"
+
+        if error_chunk?(chunk)
+          handle_error_chunk(chunk, env)
+        elsif env&.status != 200
+          handle_failed_response(chunk, buffer, env)
+        else
+          yield handle_sse(chunk, parser, env, &block)
+        end
+      end
+    end
+
+    def error_chunk?(chunk)
+      chunk.start_with?('event: error')
+    end
+
+    def handle_error_chunk(chunk, env)
+      error_data = chunk.split("\n")[1].delete_prefix('data: ')
+      status, _message = parse_streaming_error(error_data)
+      error_response = env.merge(body: JSON.parse(error_data), status: status)
+      ErrorMiddleware.parse_error(provider: self, response: error_response)
+    rescue JSON::ParserError => e
+      RubyLLM.logger.debug "Failed to parse error chunk: #{e.message}"
+    end
+
+    def handle_failed_response(chunk, buffer, env)
+      buffer << chunk
+      error_data = JSON.parse(buffer)
+      error_response = env.merge(body: error_data)
+      ErrorMiddleware.parse_error(provider: self, response: error_response)
+    rescue JSON::ParserError
+      RubyLLM.logger.debug "Accumulating error chunk: #{chunk}"
+    end
+
+    def handle_sse(chunk, parser, env, &block)
+      parser.feed(chunk) do |type, data|
+        case type.to_sym
+        when :error
+          handle_error_event(data, env)
+        else
+          yield handle_data(data, &block) unless data == '[DONE]'
+        end
+      end
+    end
+
+    def handle_data(data)
+      JSON.parse(data)
+    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)
+      error_response = env.merge(body: JSON.parse(data), status: status)
+      ErrorMiddleware.parse_error(provider: self, response: error_response)
+    rescue JSON::ParserError => e
+      RubyLLM.logger.debug "Failed to parse error event: #{e.message}"
+    end
+  end
+end

data/lib/ruby_llm/tool.rb

@@ -18,14 +18,19 @@ module RubyLLM
   # interface for defining parameters and implementing tool behavior.
   #
   # Example:
-  #   class Calculator < RubyLLM::Tool
-  #     description "Performs arithmetic calculations"
-  #     param :expression, type: :string, desc: "Math expression to evaluate"
+  #    require 'tzinfo'
   #
-  #     def execute(expression:)
-  #       eval(expression).to_s
-  #     end
-  #   end
+  #    class TimeInfo < RubyLLM::Tool
+  #      description 'Gets the current time in various timezones'
+  #      param :timezone, desc: "Timezone name (e.g., 'UTC', 'America/New_York')"
+  #
+  #      def execute(timezone:)
+  #        time = TZInfo::Timezone.get(timezone).now.strftime('%Y-%m-%d %H:%M:%S')
+  #        "Current time in #{timezone}: #{time}"
+  #       rescue StandardError => e
+  #          { error: e.message }
+  #       end
+  #    end
   class Tool
     class << self
       def description(text = nil)
@@ -45,6 +50,9 @@ module RubyLLM
 
     def name
       self.class.name
+          .unicode_normalize(:nfkd)
+          .encode('ASCII', replace: '')
+          .gsub(/[^a-zA-Z0-9_-]/, '-')
           .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
           .gsub(/([a-z\d])([A-Z])/, '\1_\2')
           .downcase

data/lib/ruby_llm/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module RubyLLM
-  VERSION = '1.0.0'
+  VERSION = '1.1.0rc1'
 end

data/lib/ruby_llm.rb

@@ -15,8 +15,12 @@ loader.inflector.inflect(
   'llm' => 'LLM',
   'openai' => 'OpenAI',
   'api' => 'API',
-  'deepseek' => 'DeepSeek'
+  'deepseek' => 'DeepSeek',
+  'bedrock' => 'Bedrock'
 )
+loader.ignore("#{__dir__}/tasks")
+loader.ignore("#{__dir__}/ruby_llm/railtie")
+loader.ignore("#{__dir__}/ruby_llm/active_record")
 loader.setup
 
 # A delightful Ruby interface to modern AI language models.
@@ -26,8 +30,8 @@ module RubyLLM
   class Error < StandardError; end
 
   class << self
-    def chat(model: nil)
-      Chat.new(model: model)
+    def chat(model: nil, provider: nil)
+      Chat.new(model: model, provider: provider)
     end
 
     def embed(...)
@@ -68,6 +72,7 @@ RubyLLM::Provider.register :openai, RubyLLM::Providers::OpenAI
 RubyLLM::Provider.register :anthropic, RubyLLM::Providers::Anthropic
 RubyLLM::Provider.register :gemini, RubyLLM::Providers::Gemini
 RubyLLM::Provider.register :deepseek, RubyLLM::Providers::DeepSeek
+RubyLLM::Provider.register :bedrock, RubyLLM::Providers::Bedrock
 
 if defined?(Rails::Railtie)
   require 'ruby_llm/railtie'