ruby_llm 1.12.1 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6f2aa1f16058fca83243f2b098b0a3f454fb9383e410a00b04955cd5b48cbf54
-  data.tar.gz: fb4591fe16b50449dc1baf90f77a2b92baa986a51b9573f5c0b79dc231d9a9b9
+  metadata.gz: efa046d43a24a45287ca68b9ec54c12374dd7a716a41bda2226974925067f547
+  data.tar.gz: e7d5187b9cb8d543e8b3b6b2590569cdcedec745f7ff35b6944d68768f803a6c
 SHA512:
-  metadata.gz: 687200d2c127d604e0bbff56c888ef5bb5ab2938b585ec2f8959f77b74ad35ae0d0dbad588068ccccd3219ab0aa4208dbc47b8436606c7b12ec1de10cf2928c2
-  data.tar.gz: 9aab7e7a79aa98b2772e4a01f4269c17a1969755276fde9b0fb4b3311a81dd4ff3a4a1e4e4c4a1f0fa863a162caaa4f3d3cd05cc044cfc5116ceaaa878963737
+  metadata.gz: 61a499df157a4276b21aaaebab88518ad8a57a497dc032307bce6a02522ae45eccad01e7989ae1dfafb7149502eb5878d1604cba99ab3f4e2c0a34ef33e43c56
+  data.tar.gz: e2a03066ca8fdc265316bff01a9afed4c16a8e9bb32d7ed7f05bb594a00b3897c621039800b7fa8a75eb729b4511af133e240fdd054065d9aa82617899664595

data/README.md

@@ -159,6 +159,8 @@ end
 ```bash
 # Install Rails Integration
 rails generate ruby_llm:install
+rails db:migrate
+rails ruby_llm:load_models # v1.13+
 
 # Add Chat UI (optional)
 rails generate ruby_llm:chat_ui

data/lib/generators/ruby_llm/chat_ui/templates/jobs/chat_response_job.rb.tt

@@ -3,7 +3,7 @@ class <%= chat_job_class_name %> < ApplicationJob
     <%= chat_variable_name %> = <%= chat_model_name %>.find(<%= chat_variable_name %>_id)
 
     <%= chat_variable_name %>.ask(content) do |chunk|
-      if chunk.content && !chunk.content.blank?
+      if chunk.content && !chunk.content.empty?
         <%= message_variable_name %> = <%= chat_variable_name %>.<%= message_table_name %>.last
         <%= message_variable_name %>.broadcast_append_chunk(chunk.content)
       end

data/lib/generators/ruby_llm/generator_helpers.rb

@@ -121,6 +121,10 @@ module RubyLLM
         "[#{Rails::VERSION::MAJOR}.#{Rails::VERSION::MINOR}]"
       end
 
+      def create_migration_class_name(table_name)
+        "create_#{table_name}".camelize
+      end
+
       def postgresql?
         ::ActiveRecord::Base.connection.adapter_name.downcase.include?('postgresql')
       rescue StandardError

data/lib/generators/ruby_llm/install/install_generator.rb

@@ -77,12 +77,13 @@ module RubyLLM
 
         say "\n  Next steps:", :yellow
         say '     1. Run: rails db:migrate'
-        say '     2. Set your API keys in config/initializers/ruby_llm.rb'
+        say '     2. Run: rails ruby_llm:load_models'
+        say '     3. Set your API keys in config/initializers/ruby_llm.rb'
 
-        say "     3. Start chatting: #{chat_model_name}.create!(model: 'gpt-4.1-nano').ask('Hello!')"
+        say "     4. Start chatting: #{chat_model_name}.create!(model: 'gpt-4.1-nano').ask('Hello!')"
 
-        say "\n  🚀 Model registry is database-backed!", :cyan
-        say '     Models automatically load from the database'
+        say "\n  🚀 Model registry supports database + JSON fallback!", :cyan
+        say '     Models load from database when present, otherwise from models.json'
         say '     Pass model names as strings - RubyLLM handles the rest!'
         say "     Specify provider when needed: Chat.create!(model: 'gemini-2.5-flash', provider: 'vertexai')"
 

data/lib/generators/ruby_llm/install/templates/create_chats_migration.rb.tt

@@ -1,4 +1,4 @@
-class Create<%= chat_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class <%= create_migration_class_name(chat_table_name) %> < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :<%= chat_table_name %> do |t|
       t.timestamps

data/lib/generators/ruby_llm/install/templates/create_messages_migration.rb.tt

@@ -1,4 +1,4 @@
-class Create<%= message_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class <%= create_migration_class_name(message_table_name) %> < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :<%= message_table_name %> do |t|
       t.string :role, null: false

data/lib/generators/ruby_llm/install/templates/create_models_migration.rb.tt

@@ -1,4 +1,4 @@
-class Create<%= model_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class <%= create_migration_class_name(model_table_name) %> < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :<%= model_table_name %> do |t|
       t.string :model_id, null: false
@@ -36,10 +36,5 @@ class Create<%= model_model_name.gsub('::', '').pluralize %> < ActiveRecord::Mig
 <% end %>
     end
 
-    # Load models from JSON
-    say_with_time "Loading models from models.json" do
-      RubyLLM.models.load_from_json!
-      <%= model_model_name %>.save_to_database
-    end
   end
 end

data/lib/generators/ruby_llm/install/templates/create_tool_calls_migration.rb.tt

@@ -1,5 +1,5 @@
 <%#- # Migration for creating tool_calls table with database-specific JSON handling -%>
-class Create<%= tool_call_model_name.gsub('::', '').pluralize %> < ActiveRecord::Migration<%= migration_version %>
+class <%= create_migration_class_name(tool_call_table_name) %> < ActiveRecord::Migration<%= migration_version %>
   def change
     create_table :<%= tool_call_table_name %> do |t|
       t.string :tool_call_id, null: false

data/lib/ruby_llm/active_record/acts_as.rb

@@ -12,15 +12,21 @@ module RubyLLM
         # Monkey-patch Models to use database when ActsAs is active
         RubyLLM::Models.class_eval do
           def self.load_models
-            read_from_database
+            database_models = read_from_database
+            return database_models if database_models.any?
+
+            RubyLLM.logger.debug { 'Model registry is empty in database, falling back to JSON registry' }
+            read_from_json
           rescue StandardError => e
-            RubyLLM.logger.debug "Failed to load models from database: #{e.message}, falling back to JSON"
+            RubyLLM.logger.debug { "Failed to load models from database: #{e.message}, falling back to JSON" }
             read_from_json
           end
 
           def self.read_from_database
             model_class = RubyLLM.config.model_registry_class
             model_class = model_class.constantize if model_class.is_a?(String)
+            return [] unless model_class.table_exists?
+
             model_class.all.map(&:to_llm)
           end
 

data/lib/ruby_llm/active_record/acts_as_legacy.rb

@@ -97,6 +97,7 @@ module RubyLLM
         ordered_messages.each do |msg|
           @chat.add_message(msg.to_llm)
         end
+        reapply_runtime_instructions(@chat)
 
         setup_persistence_callbacks
       end
@@ -109,6 +110,14 @@ module RubyLLM
         self
       end
 
+      def with_runtime_instructions(instructions, append: false, replace: nil)
+        append = append_instructions?(append:, replace:)
+        store_runtime_instruction(instructions, append:)
+
+        to_llm.with_instructions(instructions, append:, replace:)
+        self
+      end
+
       def with_tool(...)
         to_llm.with_tool(...)
         self
@@ -285,6 +294,26 @@ module RubyLLM
         system_messages + non_system_messages
       end
 
+      def runtime_instructions
+        @runtime_instructions ||= []
+      end
+
+      def store_runtime_instruction(instructions, append:)
+        if append
+          runtime_instructions << instructions
+        else
+          @runtime_instructions = [instructions]
+        end
+      end
+
+      def reapply_runtime_instructions(chat)
+        return if runtime_instructions.empty?
+
+        first, *rest = runtime_instructions
+        chat.with_instructions(first)
+        rest.each { |instruction| chat.with_instructions(instruction, append: true) }
+      end
+
       def setup_persistence_callbacks
         return @chat if @chat.instance_variable_get(:@_persistence_callbacks_setup)
 

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -79,7 +79,8 @@ module RubyLLM
         model_record = model_association
         @chat ||= (context || RubyLLM).chat(
           model: model_record.model_id,
-          provider: model_record.provider.to_sym
+          provider: model_record.provider.to_sym,
+          assume_model_exists: assume_model_exists || false
         )
         @chat.reset_messages!
 
@@ -87,6 +88,7 @@ module RubyLLM
         ordered_messages.each do |msg|
           @chat.add_message(msg.to_llm)
         end
+        reapply_runtime_instructions(@chat)
 
         setup_persistence_callbacks
       end
@@ -99,6 +101,14 @@ module RubyLLM
         self
       end
 
+      def with_runtime_instructions(instructions, append: false, replace: nil)
+        append = append_instructions?(append:, replace:)
+        store_runtime_instruction(instructions, append:)
+
+        to_llm.with_instructions(instructions, append:, replace:)
+        self
+      end
+
       def with_tool(...)
         to_llm.with_tool(...)
         self
@@ -233,9 +243,10 @@ module RubyLLM
         if last.tool_call?
           last.destroy
         elsif last.tool_result?
-          tool_call_message = last.parent_tool_call.message
-          expected_results = tool_call_message.tool_calls.pluck(:id)
-          actual_results = tool_call_message.tool_results.pluck(:tool_call_id)
+          tool_call_message = last.parent_tool_call.message_association
+          expected_results = tool_call_message.tool_calls_association.pluck(:id)
+          fk_column = tool_call_message.class.reflections['tool_results'].foreign_key
+          actual_results = tool_call_message.tool_results.pluck(fk_column)
 
           if expected_results.sort != actual_results.sort
             tool_call_message.tool_results.each(&:destroy)
@@ -288,6 +299,26 @@ module RubyLLM
         system_messages + non_system_messages
       end
 
+      def runtime_instructions
+        @runtime_instructions ||= []
+      end
+
+      def store_runtime_instruction(instructions, append:)
+        if append
+          runtime_instructions << instructions
+        else
+          @runtime_instructions = [instructions]
+        end
+      end
+
+      def reapply_runtime_instructions(chat)
+        return if runtime_instructions.empty?
+
+        first, *rest = runtime_instructions
+        chat.with_instructions(first)
+        rest.each { |instruction| chat.with_instructions(instruction, append: true) }
+      end
+
       def persist_new_message
         @message = messages_association.create!(role: :assistant, content: '')
       end

data/lib/ruby_llm/agent.rb

@@ -3,6 +3,7 @@
 require 'erb'
 require 'forwardable'
 require 'pathname'
+require 'ruby_llm/schema'
 
 module RubyLLM
   # Base class for simple, class-configured agents.
@@ -138,7 +139,10 @@ module RubyLLM
 
       def render_prompt(name, chat:, inputs:, locals:)
         path = prompt_path_for(name)
-        return nil unless File.exist?(path)
+        unless File.exist?(path)
+          raise RubyLLM::PromptNotFoundError,
+                "Prompt file not found for #{self}: #{path}. Create the file or use inline instructions."
+        end
 
         resolved_locals = resolve_prompt_locals(locals, runtime: runtime_context(chat:, inputs:), chat:, inputs:)
         ERB.new(File.read(path)).result_with_hash(resolved_locals)
@@ -177,7 +181,10 @@ module RubyLLM
         value = resolved_instructions_value(chat_object, runtime, inputs:)
         return if value.nil?
 
-        instruction_target(chat_object, persist:).with_instructions(value)
+        target = instruction_target(chat_object, persist:)
+        return target.with_runtime_instructions(value) if use_runtime_instructions?(target, persist:)
+
+        target.with_instructions(value)
       end
 
       def apply_tools(llm_chat, runtime)
@@ -204,10 +211,21 @@ module RubyLLM
       end
 
       def apply_schema(llm_chat, runtime)
-        value = evaluate(schema, runtime)
+        value = resolved_schema_value(runtime)
         llm_chat.with_schema(value) if value
       end
 
+      def resolved_schema_value(runtime)
+        value = schema
+        return value unless value.is_a?(Proc)
+
+        evaluate(value, runtime)
+      rescue NoMethodError => e
+        raise unless e.receiver.equal?(runtime)
+
+        RubyLLM::Schema.create(&value)
+      end
+
       def llm_chat_for(chat_object)
         chat_object.respond_to?(:to_llm) ? chat_object.to_llm : chat_object
       end
@@ -217,7 +235,7 @@ module RubyLLM
       end
 
       def resolved_instructions_value(chat_object, runtime, inputs:)
-        value = evaluate(instructions, runtime)
+        value = evaluate(@instructions, runtime)
         return value unless prompt_instruction?(value)
 
         runtime.prompt(
@@ -234,10 +252,20 @@ module RubyLLM
         if persist || !chat_object.respond_to?(:to_llm)
           chat_object
         else
-          chat_object.to_llm
+          runtime_instruction_target(chat_object)
         end
       end
 
+      def runtime_instruction_target(chat_object)
+        return chat_object if chat_object.respond_to?(:with_runtime_instructions)
+
+        chat_object.to_llm
+      end
+
+      def use_runtime_instructions?(target, persist:)
+        !persist && target.respond_to?(:with_runtime_instructions)
+      end
+
       def resolve_prompt_locals(locals, runtime:, chat:, inputs:)
         base = { chat: chat }.merge(inputs)
         evaluated = locals.each_with_object({}) do |(key, value), acc|

data/lib/ruby_llm/aliases.json

@@ -1,8 +1,4 @@
 {
-  "chatgpt-4o": {
-    "openai": "chatgpt-4o-latest",
-    "openrouter": "openai/chatgpt-4o-latest"
-  },
   "claude-3-5-haiku": {
     "anthropic": "claude-3-5-haiku-20241022",
     "openrouter": "anthropic/claude-3.5-haiku",
@@ -31,7 +27,7 @@
   },
   "claude-3-opus": {
     "anthropic": "claude-3-opus-20240229",
-    "bedrock": "anthropic.claude-3-opus-20240229-v1:0:200k"
+    "bedrock": "anthropic.claude-3-opus-20240229-v1:0"
   },
   "claude-3-sonnet": {
     "anthropic": "claude-3-sonnet-20240229",
@@ -82,6 +78,11 @@
     "bedrock": "anthropic.claude-sonnet-4-5-20250929-v1:0",
     "azure": "claude-sonnet-4-5-20250929"
   },
+  "claude-sonnet-4-6": {
+    "anthropic": "claude-sonnet-4-6",
+    "openrouter": "anthropic/claude-sonnet-4.6",
+    "bedrock": "anthropic.claude-sonnet-4-6"
+  },
   "deepseek-chat": {
     "deepseek": "deepseek-chat",
     "openrouter": "deepseek/deepseek-chat"
@@ -181,14 +182,19 @@
     "openrouter": "google/gemini-3-pro-preview",
     "vertexai": "gemini-3-pro-preview"
   },
+  "gemini-3.1-pro-preview": {
+    "gemini": "gemini-3.1-pro-preview",
+    "openrouter": "google/gemini-3.1-pro-preview",
+    "vertexai": "gemini-3.1-pro-preview"
+  },
+  "gemini-3.1-pro-preview-customtools": {
+    "gemini": "gemini-3.1-pro-preview-customtools",
+    "vertexai": "gemini-3.1-pro-preview-customtools"
+  },
   "gemini-embedding-001": {
     "gemini": "gemini-embedding-001",
     "vertexai": "gemini-embedding-001"
   },
-  "gemini-exp-1206": {
-    "gemini": "gemini-exp-1206",
-    "vertexai": "gemini-exp-1206"
-  },
   "gemini-flash": {
     "gemini": "gemini-flash-latest",
     "vertexai": "gemini-flash-latest"
@@ -347,6 +353,10 @@
     "openai": "gpt-5.2-pro",
     "openrouter": "openai/gpt-5.2-pro"
   },
+  "gpt-5.3-codex": {
+    "openai": "gpt-5.3-codex",
+    "openrouter": "openai/gpt-5.3-codex"
+  },
   "gpt-audio": {
     "openai": "gpt-audio",
     "openrouter": "openai/gpt-audio"

data/lib/ruby_llm/chat.rb

@@ -5,7 +5,7 @@ module RubyLLM
   class Chat
     include Enumerable
 
-    attr_reader :model, :messages, :tools, :params, :headers, :schema
+    attr_reader :model, :messages, :tools, :tool_prefs, :params, :headers, :schema
 
     def initialize(model: nil, provider: nil, assume_model_exists: false, context: nil)
       if assume_model_exists && !provider
@@ -19,6 +19,7 @@ module RubyLLM
       @temperature = nil
       @messages = []
       @tools = {}
+      @tool_prefs = { choice: nil, calls: nil }
       @params = {}
       @headers = {}
       @schema = nil
@@ -50,15 +51,19 @@ module RubyLLM
       self
     end
 
-    def with_tool(tool)
-      tool_instance = tool.is_a?(Class) ? tool.new : tool
-      @tools[tool_instance.name.to_sym] = tool_instance
+    def with_tool(tool, choice: nil, calls: nil)
+      unless tool.nil?
+        tool_instance = tool.is_a?(Class) ? tool.new : tool
+        @tools[tool_instance.name.to_sym] = tool_instance
+      end
+      update_tool_options(choice:, calls:)
       self
     end
 
-    def with_tools(*tools, replace: false)
+    def with_tools(*tools, replace: false, choice: nil, calls: nil)
       @tools.clear if replace
       tools.compact.each { |tool| with_tool tool }
+      update_tool_options(choice:, calls:)
       self
     end
 
@@ -100,12 +105,9 @@ module RubyLLM
     def with_schema(schema)
       schema_instance = schema.is_a?(Class) ? schema.new : schema
 
-      # Accept both RubyLLM::Schema instances and plain JSON schemas
-      @schema = if schema_instance.respond_to?(:to_json_schema)
-                  schema_instance.to_json_schema[:schema]
-                else
-                  schema_instance
-                end
+      @schema = normalize_schema_payload(
+        schema_instance.respond_to?(:to_json_schema) ? schema_instance.to_json_schema : schema_instance
+      )
 
       self
     end
@@ -138,6 +140,7 @@ module RubyLLM
       response = @provider.complete(
         messages,
         tools: @tools,
+        tool_prefs: @tool_prefs,
         temperature: @temperature,
         model: @model,
         params: @params,
@@ -183,6 +186,36 @@ module RubyLLM
 
     private
 
+    def normalize_schema_payload(raw_schema)
+      return nil if raw_schema.nil?
+      return raw_schema unless raw_schema.is_a?(Hash)
+
+      schema = RubyLLM::Utils.deep_symbolize_keys(raw_schema)
+      schema_def = extract_schema_definition(schema)
+      strict = extract_schema_strict(schema, schema_def)
+      build_schema_payload(schema, schema_def, strict)
+    end
+
+    def extract_schema_definition(schema)
+      RubyLLM::Utils.deep_dup(schema[:schema] || schema)
+    end
+
+    def extract_schema_strict(schema, schema_def)
+      return schema[:strict] if schema.key?(:strict)
+      return schema_def.delete(:strict) if schema_def.is_a?(Hash)
+
+      nil
+    end
+
+    def build_schema_payload(schema, schema_def, strict)
+      {
+        name: schema[:name] || 'response',
+        schema: schema_def,
+        strict: strict.nil? || strict,
+        description: schema[:description]
+      }.compact
+    end
+
     def wrap_streaming_block(&block)
       return nil unless block_given?
 
@@ -209,15 +242,78 @@ module RubyLLM
         halt_result = result if result.is_a?(Tool::Halt)
       end
 
+      reset_tool_choice if forced_tool_choice?
       halt_result || complete(&)
     end
 
     def execute_tool(tool_call)
       tool = tools[tool_call.name.to_sym]
+      if tool.nil?
+        return {
+          error: "Model tried to call unavailable tool `#{tool_call.name}`. " \
+                 "Available tools: #{tools.keys.to_json}."
+        }
+      end
+
       args = tool_call.arguments
       tool.call(args)
     end
 
+    def update_tool_options(choice:, calls:)
+      unless choice.nil?
+        normalized_choice = normalize_tool_choice(choice)
+        valid_tool_choices = %i[auto none required] + tools.keys
+        unless valid_tool_choices.include?(normalized_choice)
+          raise InvalidToolChoiceError,
+                "Invalid tool choice: #{choice}. Valid choices are: #{valid_tool_choices.join(', ')}"
+        end
+
+        @tool_prefs[:choice] = normalized_choice
+      end
+
+      @tool_prefs[:calls] = normalize_calls(calls) unless calls.nil?
+    end
+
+    def normalize_calls(calls)
+      case calls
+      when :many, 'many'
+        :many
+      when :one, 'one', 1
+        :one
+      else
+        raise ArgumentError, "Invalid calls value: #{calls.inspect}. Valid values are: :many, :one, or 1"
+      end
+    end
+
+    def normalize_tool_choice(choice)
+      return choice.to_sym if choice.is_a?(String) || choice.is_a?(Symbol)
+      return tool_name_for_choice_class(choice) if choice.is_a?(Class)
+
+      choice.respond_to?(:name) ? choice.name.to_sym : choice.to_sym
+    end
+
+    def tool_name_for_choice_class(tool_class)
+      matched_tool_name = tools.find { |_name, tool| tool.is_a?(tool_class) }&.first
+      return matched_tool_name if matched_tool_name
+
+      classify_tool_name(tool_class.name)
+    end
+
+    def classify_tool_name(class_name)
+      class_name.split('::').last
+                .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+                .downcase
+                .to_sym
+    end
+
+    def forced_tool_choice?
+      @tool_prefs[:choice] && !%i[auto none].include?(@tool_prefs[:choice])
+    end
+
+    def reset_tool_choice
+      @tool_prefs[:choice] = nil
+    end
+
     def build_content(message, attachments)
       return message if content_like?(message)
 

data/lib/ruby_llm/configuration.rb

@@ -11,20 +11,25 @@ module RubyLLM
                   :azure_api_base,
                   :azure_api_key,
                   :azure_ai_auth_token,
+                  :anthropic_api_base,
                   :anthropic_api_key,
                   :gemini_api_key,
                   :gemini_api_base,
                   :vertexai_project_id,
                   :vertexai_location,
+                  :vertexai_service_account_key,
                   :deepseek_api_key,
+                  :deepseek_api_base,
                   :perplexity_api_key,
                   :bedrock_api_key,
                   :bedrock_secret_key,
                   :bedrock_region,
                   :bedrock_session_token,
+                  :openrouter_api_base,
                   :openrouter_api_key,
                   :xai_api_key,
                   :ollama_api_base,
+                  :ollama_api_key,
                   :gpustack_api_base,
                   :gpustack_api_key,
                   :mistral_api_key,
@@ -51,6 +56,7 @@ module RubyLLM
                   :log_file,
                   :log_level,
                   :log_stream_debug
+    attr_reader :log_regexp_timeout
 
     def initialize
       @request_timeout = 300
@@ -73,10 +79,22 @@ module RubyLLM
       @log_file = $stdout
       @log_level = ENV['RUBYLLM_DEBUG'] ? Logger::DEBUG : Logger::INFO
       @log_stream_debug = ENV['RUBYLLM_STREAM_DEBUG'] == 'true'
+      self.log_regexp_timeout = Regexp.respond_to?(:timeout) ? (Regexp.timeout || 1.0) : nil
     end
 
     def instance_variables
       super.reject { |ivar| ivar.to_s.match?(/_id|_key|_secret|_token$/) }
     end
+
+    def log_regexp_timeout=(value)
+      if value.nil?
+        @log_regexp_timeout = nil
+      elsif Regexp.respond_to?(:timeout)
+        @log_regexp_timeout = value
+      else
+        RubyLLM.logger.warn("log_regexp_timeout is not supported on Ruby #{RUBY_VERSION}")
+        @log_regexp_timeout = value
+      end
+    end
   end
 end

data/lib/ruby_llm/connection.rb

@@ -65,19 +65,25 @@ module RubyLLM
                        errors: true,
                        headers: false,
                        log_level: :debug do |logger|
-        logger.filter(%r{[A-Za-z0-9+/=]{100,}}, '[BASE64 DATA]')
-        logger.filter(/[-\d.e,\s]{100,}/, '[EMBEDDINGS ARRAY]')
+        logger.filter(logging_regexp('[A-Za-z0-9+/=]{100,}'), '[BASE64 DATA]')
+        logger.filter(logging_regexp('[-\\d.e,\\s]{100,}'), '[EMBEDDINGS ARRAY]')
       end
     end
 
+    def logging_regexp(pattern)
+      return Regexp.new(pattern) if @config.log_regexp_timeout.nil? || !Regexp.respond_to?(:timeout)
+
+      Regexp.new(pattern, timeout: @config.log_regexp_timeout)
+    end
+
     def setup_retry(faraday)
       faraday.request :retry, {
         max: @config.max_retries,
         interval: @config.retry_interval,
         interval_randomness: @config.retry_interval_randomness,
         backoff_factor: @config.retry_backoff_factor,
-        exceptions: retry_exceptions,
-        retry_statuses: [429, 500, 502, 503, 504, 529]
+        methods: Faraday::Retry::Middleware::IDEMPOTENT_METHODS + [:post],
+        exceptions: retry_exceptions
       }
     end
 

data/lib/ruby_llm/content.rb

@@ -53,9 +53,7 @@ module RubyLLM
       end
     end
   end
-end
 
-module RubyLLM
   class Content
     # Represents provider-specific payloads that should bypass RubyLLM formatting.
     class Raw