ruby_llm 1.12.0 → 1.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e8ff2f4da0c39e4909925217affa2b76908207e2c936a6dc05b56cffb2781863
-  data.tar.gz: 0eebb76434b049d4332a247e7581bb721d4dd86b0496be8655d15a4adcb42f65
+  metadata.gz: efa046d43a24a45287ca68b9ec54c12374dd7a716a41bda2226974925067f547
+  data.tar.gz: e7d5187b9cb8d543e8b3b6b2590569cdcedec745f7ff35b6944d68768f803a6c
 SHA512:
-  metadata.gz: 95a3eb5a1c6a50c69dd8166044d99d77848fc8dcdd5d31b748e8303a3e8c5756cc86a8ce0220dd3c643bc0b32080f6c2125c79f5e437bb654725a119b4b4b601
-  data.tar.gz: 5efbd317193ca7f5e28df0a2d9bcc7ffd8a1740f40d29e7b872bed8a2ee910db376dc2dc890723b0c253718404993e55deab87356d414afdfd741d9392bd5e0f
+  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
 
@@ -53,8 +59,6 @@ module RubyLLM
                      foreign_key: model_foreign_key,
                      optional: true
 
-          delegate :add_message, to: :to_llm
-
           define_method :messages_association do
             send(messages_association_name)
           end

data/lib/ruby_llm/active_record/acts_as_legacy.rb

@@ -18,8 +18,6 @@ module RubyLLM
                    class_name: @message_class,
                    inverse_of: :chat,
                    dependent: :destroy
-
-          delegate :add_message, to: :to_llm
         end
 
         def acts_as_message(chat_class: 'Chat',
@@ -99,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
@@ -111,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
@@ -185,14 +192,34 @@ module RubyLLM
         self
       end
 
-      def create_user_message(content, with: nil)
-        message_record = messages.create!(role: :user, content: content)
-        persist_content(message_record, with) if with.present?
+      def add_message(message_or_attributes)
+        llm_message = message_or_attributes.is_a?(RubyLLM::Message) ? message_or_attributes : RubyLLM::Message.new(message_or_attributes)
+        content, attachments_to_persist = prepare_content_for_storage(llm_message.content)
+
+        attrs = { role: llm_message.role, content: }
+        tool_call_foreign_key = messages.klass.tool_call_foreign_key
+        if llm_message.tool_call_id && tool_call_foreign_key
+          tool_call_id = find_tool_call_id(llm_message.tool_call_id)
+          attrs[tool_call_foreign_key] = tool_call_id if tool_call_id
+        end
+
+        message_record = messages.create!(attrs)
+        persist_content(message_record, attachments_to_persist) if attachments_to_persist.present?
+        persist_tool_calls(llm_message.tool_calls, message_record:) if llm_message.tool_calls.present?
+
         message_record
       end
 
-      def ask(message, with: nil, &)
-        create_user_message(message, with:)
+      def create_user_message(content, with: nil)
+        RubyLLM.logger.warn(
+          '`create_user_message` is deprecated and will be removed in RubyLLM 2.0. ' \
+          'Use `add_message(role: :user, content: ...)` instead.'
+        )
+        add_message(role: :user, content: build_content(content, with))
+      end
+
+      def ask(message = nil, with: nil, &)
+        add_message(role: :user, content: build_content(message, with))
         complete(&)
       end
 
@@ -267,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)
 
@@ -281,21 +328,13 @@ module RubyLLM
         @message = messages.create!(role: :assistant, content: '')
       end
 
-      def persist_message_completion(message) # rubocop:disable Metrics/PerceivedComplexity
+      def persist_message_completion(message)
         return unless message
 
         tool_call_id = find_tool_call_id(message.tool_call_id) if message.tool_call_id
 
         transaction do
-          content = message.content
-          attachments_to_persist = nil
-
-          if content.is_a?(RubyLLM::Content)
-            attachments_to_persist = content.attachments if content.attachments.any?
-            content = content.text
-          elsif content.is_a?(Hash) || content.is_a?(Array)
-            content = content.to_json
-          end
+          content, attachments_to_persist = prepare_content_for_storage(message.content)
 
           @message.update!(
             role: message.role,
@@ -312,14 +351,17 @@ module RubyLLM
         end
       end
 
-      def persist_tool_calls(tool_calls)
-        supports_thought_signature = tool_calls.klass.column_names.include?('thought_signature')
+      def persist_tool_calls(tool_calls, message_record: @message)
+        tool_call_assoc = message_record.respond_to?(:tool_calls) ? message_record.tool_calls : nil
+        return unless tool_call_assoc
+
+        supports_thought_signature = tool_call_assoc.klass.column_names.include?('thought_signature')
 
         tool_calls.each_value do |tool_call|
           attributes = tool_call.to_h
           attributes.delete(:thought_signature) unless supports_thought_signature
           attributes[:tool_call_id] = attributes.delete(:id)
-          @message.tool_calls.create!(**attributes)
+          tool_call_assoc.create!(**attributes)
         end
       end
 
@@ -363,6 +405,29 @@ module RubyLLM
         RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
         nil
       end
+
+      def build_content(message, attachments)
+        return message if content_like?(message)
+
+        RubyLLM::Content.new(message, attachments)
+      end
+
+      def content_like?(object)
+        object.is_a?(RubyLLM::Content) || object.is_a?(RubyLLM::Content::Raw)
+      end
+
+      def prepare_content_for_storage(content)
+        attachments = nil
+
+        if content.is_a?(RubyLLM::Content)
+          attachments = content.attachments if content.attachments.any?
+          [content.text, attachments]
+        elsif content.is_a?(Hash) || content.is_a?(Array)
+          [content.to_json, attachments]
+        else
+          [content, attachments]
+        end
+      end
     end
 
     # Methods mixed into message models.

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
@@ -178,22 +188,32 @@ module RubyLLM
         self
       end
 
-      def create_user_message(content, with: nil)
-        content_text, attachments, content_raw = prepare_content_for_storage(content)
+      def add_message(message_or_attributes)
+        llm_message = message_or_attributes.is_a?(RubyLLM::Message) ? message_or_attributes : RubyLLM::Message.new(message_or_attributes)
+        content_text, attachments, content_raw = prepare_content_for_storage(llm_message.content)
 
-        message_record = messages_association.build(role: :user)
-        message_record.content = content_text
-        message_record.content_raw = content_raw if message_record.respond_to?(:content_raw=)
-        message_record.save!
+        attrs = { role: llm_message.role, content: content_text }
+        parent_tool_call_assoc = messages_association.klass.reflect_on_association(:parent_tool_call)
+        if parent_tool_call_assoc && llm_message.tool_call_id
+          tool_call_id = find_tool_call_id(llm_message.tool_call_id)
+          attrs[parent_tool_call_assoc.foreign_key] = tool_call_id if tool_call_id
+        end
+
+        message_record = messages_association.create!(attrs)
+        message_record.update!(content_raw:) if message_record.respond_to?(:content_raw=)
 
-        persist_content(message_record, with) if with.present?
         persist_content(message_record, attachments) if attachments.present?
+        persist_tool_calls(llm_message.tool_calls, message_record:) if llm_message.tool_calls.present?
 
         message_record
       end
 
-      def ask(message, with: nil, &)
-        create_user_message(message, with:)
+      def create_user_message(content, with: nil)
+        add_message(role: :user, content: build_content(content, with))
+      end
+
+      def ask(message = nil, with: nil, &)
+        add_message(role: :user, content: build_content(message, with))
         complete(&)
       end
 
@@ -223,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)
@@ -278,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
@@ -323,15 +364,15 @@ module RubyLLM
       end
       # rubocop:enable Metrics/PerceivedComplexity
 
-      def persist_tool_calls(tool_calls)
-        tool_call_klass = @message.tool_calls_association.klass
+      def persist_tool_calls(tool_calls, message_record: @message)
+        tool_call_klass = message_record.tool_calls_association.klass
         supports_thought_signature = tool_call_klass.column_names.include?('thought_signature')
 
         tool_calls.each_value do |tool_call|
           attributes = tool_call.to_h
           attributes.delete(:thought_signature) unless supports_thought_signature
           attributes[:tool_call_id] = attributes.delete(:id)
-          @message.tool_calls_association.create!(**attributes)
+          message_record.tool_calls_association.create!(**attributes)
         end
       end
 
@@ -386,6 +427,16 @@ module RubyLLM
         nil
       end
 
+      def build_content(message, attachments)
+        return message if content_like?(message)
+
+        RubyLLM::Content.new(message, attachments)
+      end
+
+      def content_like?(object)
+        object.is_a?(RubyLLM::Content) || object.is_a?(RubyLLM::Content::Raw)
+      end
+
       def prepare_content_for_storage(content)
         attachments = nil
         content_raw = nil

data/lib/ruby_llm/agent.rb

@@ -1,11 +1,14 @@
 # frozen_string_literal: true
 
 require 'erb'
+require 'forwardable'
 require 'pathname'
+require 'ruby_llm/schema'
 
 module RubyLLM
   # Base class for simple, class-configured agents.
   class Agent
+    extend Forwardable
     include Enumerable
 
     class << self
@@ -136,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)
@@ -175,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)
@@ -202,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
@@ -215,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(
@@ -232,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|
@@ -316,8 +346,9 @@ module RubyLLM
 
     attr_reader :chat
 
-    delegate :ask, :say, :complete, :add_message, :messages,
-             :on_new_message, :on_end_message, :on_tool_call, :on_tool_result, :each,
-             to: :chat
+    def_delegators :chat, :model, :messages, :tools, :params, :headers, :schema, :ask, :say, :with_tool, :with_tools,
+                   :with_model, :with_temperature, :with_thinking, :with_context, :with_params, :with_headers,
+                   :with_schema, :on_new_message, :on_end_message, :on_tool_call, :on_tool_result, :each, :complete,
+                   :add_message, :reset_messages!
   end
 end

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"