ruby_llm 1.3.0rc1 → 1.3.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ff16d82f5fc8836eba0943ee83bc3fe3b1558172ecc78cc6d4136fa504461e8f
-  data.tar.gz: 73cd15c8c05f53dae87740e0022cbb4b72ebd151918d7fe97d2f9a6047264069
+  metadata.gz: a2287ea41c7591e593a315a35fd34ef8e32968c1b7337042c0b08338caeda784
+  data.tar.gz: 55a2690e1faa46d9ecdda3e8115ae64549be8d52c80fb5ffdb2aadd6fa8887dd
 SHA512:
-  metadata.gz: d9bff16dce3e4cef7f57d8afad8cf90fd995045a6da5412588fc019ac2e57fa4137628525c603ef4df259eec6bf40d748296619671713094ca7d8e7c824c0e78
-  data.tar.gz: 3f44c0c2783202e8f162d9d705f10061a7ca717f23a26026bbbcdb2cea214edd48c9a0458ec9a226a03eb823f3ec8f3d9a601526c01e277c24f4988bb0634521
+  metadata.gz: 8d5c7d2b3b73f289bdad5c5faac487a03221101302567a1d36b073de84e97e3650cc4d103ce6f9e641659c0ecc69484593535ed964b933f7d14b19b5dce34e81
+  data.tar.gz: 1515124ad74198461fdbc8105f7173392df7bee2038c701ad85d6da258107bb3ddd366878fa140bd5de354b41dfe8abc5887a78adf2c7cb3beb0cf6caa64f764

data/README.md

@@ -37,7 +37,7 @@
 
 Every AI provider comes with its own client library, its own response format, its own conventions for streaming, and its own way of handling errors. Want to use multiple providers? Prepare to juggle incompatible APIs and bloated dependencies.
 
-RubyLLM fixes all that. One beautiful API for everything. One consistent format. Minimal dependencies — just Faraday and Zeitwerk. Because working with AI should be a joy, not a chore.
+RubyLLM fixes all that. One beautiful API for everything. One consistent format. Minimal dependencies — just Faraday, Zeitwerk, and Marcel. Because working with AI should be a joy, not a chore.
 
 ## What makes it great
 
@@ -46,14 +46,14 @@ RubyLLM fixes all that. One beautiful API for everything. One consistent format.
 chat = RubyLLM.chat
 chat.ask "What's the best way to learn Ruby?"
 
-# Analyze images
-chat.ask "What's in this image?", with: { image: "ruby_conf.jpg" }
+# Analyze images, audio, documents, and text files
+chat.ask "What's in this image?", with: "ruby_conf.jpg"
+chat.ask "Describe this meeting", with: "meeting.wav"
+chat.ask "Summarize this document", with: "contract.pdf"
+chat.ask "Explain this code", with: "app.rb"
 
-# Analyze audio recordings
-chat.ask "Describe this meeting", with: { audio: "meeting.wav" }
-
-# Analyze documents
-chat.ask "Summarize this document", with: { pdf: "contract.pdf" }
+# Multiple files at once - types automatically detected
+chat.ask "Analyze these files", with: ["diagram.png", "report.pdf", "notes.txt"]
 
 # Stream responses in real-time
 chat.ask "Tell me a story about a Ruby programmer" do |chunk|
@@ -90,7 +90,7 @@ chat.with_tool(Weather).ask "What's the weather in Berlin? (52.5200, 13.4050)"
 *   💬 **Unified Chat:** Converse with models from OpenAI, Anthropic, Gemini, Bedrock, OpenRouter, DeepSeek, Ollama, or any OpenAI-compatible API using `RubyLLM.chat`.
 *   👁️ **Vision:** Analyze images within chats.
 *   🔊 **Audio:** Transcribe and understand audio content.
-*   📄 **PDF Analysis:** Extract information and summarize PDF documents.
+*   📄 **Document Analysis:** Extract information from PDFs, text files, and other documents.
 *   🖼️ **Image Generation:** Create images with `RubyLLM.paint`.
 *   📊 **Embeddings:** Generate text embeddings for vector search with `RubyLLM.embed`.
 *   🔧 **Tools (Function Calling):** Let AI models call your Ruby code using `RubyLLM::Tool`.
@@ -143,6 +143,10 @@ end
 # Now interacting with a Chat record persists the conversation:
 chat_record = Chat.create!(model_id: "gpt-4.1-nano")
 chat_record.ask("Explain Active Record callbacks.") # User & Assistant messages saved
+
+# Works seamlessly with file attachments - types automatically detected
+chat_record.ask("What's in this file?", with: "report.pdf")
+chat_record.ask("Analyze these", with: ["image.jpg", "data.csv", "notes.txt"])
 ```
 Check the [Rails Integration Guide](https://rubyllm.com/guides/rails) for more.
 

data/lib/ruby_llm/active_record/acts_as.rb

@@ -18,10 +18,10 @@ module RubyLLM
           has_many :messages,
                    -> { order(created_at: :asc) },
                    class_name: @message_class,
+                   inverse_of: :chat,
                    dependent: :destroy
 
-          delegate :add_message,
-                   to: :to_llm
+          delegate :add_message, to: :to_llm
         end
 
         def acts_as_message(chat_class: 'Chat',
@@ -88,26 +88,18 @@ module RubyLLM
         @chat ||= RubyLLM.chat(model: model_id)
         @chat.reset_messages!
 
-        # Load existing messages into chat
         messages.each do |msg|
           @chat.add_message(msg.to_llm)
         end
 
-        # Set up message persistence
         @chat.on_new_message { persist_new_message }
              .on_end_message { |msg| persist_message_completion(msg) }
       end
 
       def with_instructions(instructions, replace: false)
         transaction do
-          # If replace is true, remove existing system messages
           messages.where(role: :system).destroy_all if replace
-
-          # Create the new system message
-          messages.create!(
-            role: :system,
-            content: instructions
-          )
+          messages.create!(role: :system, content: instructions)
         end
         to_llm.with_instructions(instructions)
         self
@@ -124,7 +116,7 @@ module RubyLLM
       end
 
       def with_model(...)
-        to_llm.with_model(...)
+        update(model_id: to_llm.with_model(...).model.id)
         self
       end
 
@@ -133,6 +125,11 @@ module RubyLLM
         self
       end
 
+      def with_context(...)
+        to_llm.with_context(...)
+        self
+      end
+
       def on_new_message(...)
         to_llm.on_new_message(...)
         self
@@ -144,21 +141,8 @@ module RubyLLM
       end
 
       def create_user_message(content, with: nil)
-        message_record = messages.create!(
-          role: :user,
-          content: content
-        )
-
-        if with.present?
-          files = Array(with).reject(&:blank?)
-
-          if files.any? && files.first.is_a?(ActionDispatch::Http::UploadedFile)
-            message_record.attachments.attach(files)
-          else
-            attach_files(message_record, process_attachments(with))
-          end
-        end
-
+        message_record = messages.create!(role: :user, content: content)
+        persist_content(message_record, with) if with.present?
         message_record
       end
 
@@ -182,21 +166,16 @@ module RubyLLM
       private
 
       def persist_new_message
-        @message = messages.create!(
-          role: :assistant,
-          content: String.new
-        )
+        @message = messages.create!(role: :assistant, content: String.new)
       end
 
       def persist_message_completion(message)
         return unless message
 
-        if message.tool_call_id
-          tool_call_id = self.class.tool_call_class.constantize.find_by(tool_call_id: message.tool_call_id)&.id
-        end
+        tool_call_id = find_tool_call_id(message.tool_call_id) if message.tool_call_id
 
         transaction do
-          @message.update(
+          @message.update!(
             role: message.role,
             content: message.content,
             model_id: message.model_id,
@@ -217,84 +196,46 @@ module RubyLLM
         end
       end
 
-      def process_attachments(attachments) # rubocop:disable Metrics/PerceivedComplexity
-        return {} if attachments.nil?
-
-        result = {}
-        files = Array(attachments)
-
-        files.each do |file|
-          content_type = if file.respond_to?(:content_type)
-                           file.content_type
-                         elsif file.is_a?(ActiveStorage::Attachment)
-                           file.blob.content_type
-                         else
-                           RubyLLM::MimeTypes.detect_from_path(file.to_s)
-                         end
-
-          if RubyLLM::MimeTypes.image?(content_type)
-            result[:image] ||= []
-            result[:image] << file
-          elsif RubyLLM::MimeTypes.audio?(content_type)
-            result[:audio] ||= []
-            result[:audio] << file
-          else
-            # Default to PDF for unknown types
-            result[:pdf] ||= []
-            result[:pdf] << file
-          end
-        end
-
-        result
+      def find_tool_call_id(tool_call_id)
+        self.class.tool_call_class.constantize.find_by(tool_call_id: tool_call_id)&.id
       end
 
-      def attach_files(message, attachments_hash)
-        return unless message.respond_to?(:attachments)
+      def persist_content(message_record, attachments)
+        return unless message_record.respond_to?(:attachments)
 
-        %i[image audio pdf].each do |type|
-          Array(attachments_hash[type]).each do |file_source|
-            attach_file(message, file_source)
-          end
-        end
+        attachables = prepare_for_active_storage(attachments)
+        message_record.attachments.attach(attachables) if attachables.any?
       end
 
-      def attach_file(message, file_source)
-        if file_source.to_s.match?(%r{^https?://})
-          # For URLs, create a special attachment that just stores the URL
-          content_type = RubyLLM::MimeTypes.detect_from_path(file_source.to_s)
-
-          # Create a minimal blob that just stores the URL
-          blob = ActiveStorage::Blob.create_and_upload!(
-            io: StringIO.new('URL Reference'),
-            filename: File.basename(file_source),
-            content_type: content_type,
-            metadata: { original_url: file_source.to_s }
-          )
-          message.attachments.attach(blob)
-        elsif file_source.respond_to?(:read)
-          # Handle various file source types
-          message.attachments.attach(
-            io: file_source,
-            filename: extract_filename(file_source),
-            content_type: RubyLLM::MimeTypes.detect_from_path(extract_filename(file_source))
-          ) # Already a file-like object
-        elsif file_source.is_a?(::ActiveStorage::Attachment)
-          # Copy from existing ActiveStorage attachment
-          message.attachments.attach(file_source.blob)
-        elsif file_source.is_a?(::ActiveStorage::Blob)
-          message.attachments.attach(file_source)
-        else
-          # Local file path
-          message.attachments.attach(
-            io: File.open(file_source),
-            filename: File.basename(file_source),
-            content_type: RubyLLM::MimeTypes.detect_from_path(file_source)
-          )
-        end
+      def prepare_for_active_storage(attachments)
+        Utils.to_safe_array(attachments).filter_map do |attachment|
+          case attachment
+          when ActionDispatch::Http::UploadedFile, ActiveStorage::Blob
+            attachment
+          when ActiveStorage::Attached::One, ActiveStorage::Attached::Many
+            attachment.blobs
+          when Hash
+            attachment.values.map { |v| prepare_for_active_storage(v) }
+          else
+            convert_to_active_storage_format(attachment)
+          end
+        end.flatten.compact
       end
 
-      def extract_filename(file)
-        file.respond_to?(:original_filename) ? file.original_filename : 'attachment'
+      def convert_to_active_storage_format(source)
+        return if source.blank?
+
+        # Let RubyLLM::Attachment handle the heavy lifting
+        attachment = RubyLLM::Attachment.new(source)
+
+        {
+          io: StringIO.new(attachment.content),
+          filename: attachment.filename,
+          content_type: attachment.mime_type
+        }
+      rescue StandardError => e
+        RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
+        nil
       end
     end
 
@@ -319,6 +260,8 @@ module RubyLLM
         )
       end
 
+      private
+
       def extract_tool_calls
         tool_calls.to_h do |tool_call|
           [
@@ -336,55 +279,31 @@ module RubyLLM
         parent_tool_call&.tool_call_id
       end
 
-      def extract_content # rubocop:disable Metrics/PerceivedComplexity
+      def extract_content
         return content unless respond_to?(:attachments) && attachments.attached?
 
-        content_obj = RubyLLM::Content.new(content)
-
-        # We need to keep tempfiles alive for the duration of the API call
-        @_tempfiles = []
-
-        attachments.each do |attachment|
-          attachment_data = if attachment.metadata&.key?('original_url')
-                              attachment.metadata['original_url']
-                            elsif defined?(ActiveJob) && caller.any? { |c| c.include?('active_job') }
-                              # We're in a background job - need to download the data
-                              temp_file = Tempfile.new([File.basename(attachment.filename.to_s, '.*'),
-                                                        File.extname(attachment.filename.to_s)])
-                              temp_file.binmode
-                              temp_file.write(attachment.download)
-                              temp_file.flush
-                              temp_file.rewind
-
-                              # Store the tempfile reference in the instance variable to prevent GC
-                              @_tempfiles << temp_file
-
-                              # Return the file object itself, not just the path
-                              temp_file
-                            else
-                              blob_path_for(attachment)
-                            end
-
-          if RubyLLM::MimeTypes.image?(attachment.content_type)
-            content_obj.add_image(attachment_data)
-          elsif RubyLLM::MimeTypes.audio?(attachment.content_type)
-            content_obj.add_audio(attachment_data)
-          elsif RubyLLM::MimeTypes.pdf?(attachment.content_type)
-            content_obj.add_pdf(attachment_data)
+        RubyLLM::Content.new(content).tap do |content_obj|
+          @_tempfiles = []
+
+          attachments.each do |attachment|
+            tempfile = download_attachment(attachment)
+            content_obj.add_attachment(tempfile, filename: attachment.filename.to_s)
           end
         end
-
-        content_obj
       end
 
-      private
+      def download_attachment(attachment)
+        ext = File.extname(attachment.filename.to_s)
+        basename = File.basename(attachment.filename.to_s, ext)
+        tempfile = Tempfile.new([basename, ext])
+        tempfile.binmode
 
-      def blob_path_for(attachment)
-        if Rails.application.routes.url_helpers.respond_to?(:rails_blob_path)
-          Rails.application.routes.url_helpers.rails_blob_path(attachment, only_path: true)
-        else
-          attachment.service_url
-        end
+        attachment.download { |chunk| tempfile.write(chunk) }
+
+        tempfile.flush
+        tempfile.rewind
+        @_tempfiles << tempfile
+        tempfile
       end
     end
   end

data/lib/ruby_llm/aliases.json

@@ -1,80 +1,216 @@
 {
-  "claude-3-5-sonnet": {
-    "anthropic": "claude-3-5-sonnet-20241022",
-    "bedrock": "anthropic.claude-3-5-sonnet-20241022-v2:0",
-    "openrouter": "anthropic/claude-3.5-sonnet"
+  "chatgpt-4o": {
+    "openai": "chatgpt-4o-latest",
+    "openrouter": "openai/chatgpt-4o-latest"
+  },
+  "claude-2.0": {
+    "anthropic": "claude-2.0",
+    "openrouter": "anthropic/claude-2.0",
+    "bedrock": "anthropic.claude-v2:1:200k"
+  },
+  "claude-2.1": {
+    "anthropic": "claude-2.1",
+    "openrouter": "anthropic/claude-2.1",
+    "bedrock": "anthropic.claude-v2:1:200k"
   },
   "claude-3-5-haiku": {
     "anthropic": "claude-3-5-haiku-20241022",
-    "bedrock": "anthropic.claude-3-5-haiku-20241022-v1:0",
-    "openrouter": "anthropic/claude-3.5-haiku-20241022"
+    "openrouter": "anthropic/claude-3.5-haiku",
+    "bedrock": "anthropic.claude-3-5-haiku-20241022-v1:0"
+  },
+  "claude-3-5-sonnet": {
+    "anthropic": "claude-3-5-sonnet-20241022",
+    "openrouter": "anthropic/claude-3.5-sonnet",
+    "bedrock": "anthropic.claude-3-5-sonnet-20240620-v1:0:200k"
   },
   "claude-3-7-sonnet": {
     "anthropic": "claude-3-7-sonnet-20250219",
-    "bedrock": "us.anthropic.claude-3-7-sonnet-20250219-v1:0",
-    "openrouter": "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+    "openrouter": "anthropic/claude-3.7-sonnet",
+    "bedrock": "us.anthropic.claude-3-7-sonnet-20250219-v1:0"
+  },
+  "claude-3-haiku": {
+    "anthropic": "claude-3-haiku-20240307",
+    "openrouter": "anthropic/claude-3-haiku",
+    "bedrock": "anthropic.claude-3-haiku-20240307-v1:0:200k"
   },
   "claude-3-opus": {
     "anthropic": "claude-3-opus-20240229",
-    "bedrock": "anthropic.claude-3-opus-20240229-v1:0"
+    "openrouter": "anthropic/claude-3-opus",
+    "bedrock": "anthropic.claude-3-opus-20240229-v1:0:200k"
   },
   "claude-3-sonnet": {
     "anthropic": "claude-3-sonnet-20240229",
-    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0"
+    "openrouter": "anthropic/claude-3-sonnet",
+    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0:200k"
   },
-  "claude-3-haiku": {
-    "anthropic": "claude-3-haiku-20240307",
-    "bedrock": "anthropic.claude-3-haiku-20240307-v1:0"
+  "claude-opus-4": {
+    "anthropic": "claude-opus-4-20250514",
+    "openrouter": "anthropic/claude-opus-4",
+    "bedrock": "us.anthropic.claude-opus-4-20250514-v1:0"
   },
-  "claude-3": {
-    "anthropic": "claude-3-sonnet-20240229",
-    "bedrock": "anthropic.claude-3-sonnet-20240229-v1:0",
-    "openrouter": "anthropic/claude-3-sonnet"
+  "claude-sonnet-4": {
+    "anthropic": "claude-sonnet-4-20250514",
+    "openrouter": "anthropic/claude-sonnet-4",
+    "bedrock": "us.anthropic.claude-sonnet-4-20250514-v1:0"
   },
-  "claude-2": {
-    "anthropic": "claude-2.0",
-    "bedrock": "anthropic.claude-2.0",
-    "openrouter": "anthropic/claude-2"
+  "deepseek-chat": {
+    "deepseek": "deepseek-chat",
+    "openrouter": "deepseek/deepseek-chat"
   },
-  "claude-2-1": {
-    "anthropic": "claude-2.1",
-    "bedrock": "anthropic.claude-2.1",
-    "openrouter": "anthropic/claude-2.1"
+  "gemini-2.0-flash-001": {
+    "gemini": "gemini-2.0-flash-001",
+    "openrouter": "google/gemini-2.0-flash-001"
+  },
+  "gemini-2.0-flash-lite-001": {
+    "gemini": "gemini-2.0-flash-lite-001",
+    "openrouter": "google/gemini-2.0-flash-lite-001"
+  },
+  "gemini-2.5-flash-preview-05-20": {
+    "gemini": "gemini-2.5-flash-preview-05-20",
+    "openrouter": "google/gemini-2.5-flash-preview-05-20"
+  },
+  "gemini-2.5-pro-exp-03-25": {
+    "gemini": "gemini-2.5-pro-exp-03-25",
+    "openrouter": "google/gemini-2.5-pro-exp-03-25"
+  },
+  "gemini-2.5-pro-preview-05-06": {
+    "gemini": "gemini-2.5-pro-preview-05-06",
+    "openrouter": "google/gemini-2.5-pro-preview-05-06"
+  },
+  "gemma-3-12b-it": {
+    "gemini": "gemma-3-12b-it",
+    "openrouter": "google/gemma-3-12b-it"
+  },
+  "gemma-3-27b-it": {
+    "gemini": "gemma-3-27b-it",
+    "openrouter": "google/gemma-3-27b-it"
+  },
+  "gemma-3-4b-it": {
+    "gemini": "gemma-3-4b-it",
+    "openrouter": "google/gemma-3-4b-it"
+  },
+  "gpt-3.5-turbo": {
+    "openai": "gpt-3.5-turbo",
+    "openrouter": "openai/gpt-3.5-turbo"
+  },
+  "gpt-3.5-turbo-0125": {
+    "openai": "gpt-3.5-turbo-0125",
+    "openrouter": "openai/gpt-3.5-turbo-0125"
+  },
+  "gpt-3.5-turbo-1106": {
+    "openai": "gpt-3.5-turbo-1106",
+    "openrouter": "openai/gpt-3.5-turbo-1106"
+  },
+  "gpt-3.5-turbo-16k": {
+    "openai": "gpt-3.5-turbo-16k",
+    "openrouter": "openai/gpt-3.5-turbo-16k"
+  },
+  "gpt-3.5-turbo-instruct": {
+    "openai": "gpt-3.5-turbo-instruct",
+    "openrouter": "openai/gpt-3.5-turbo-instruct"
+  },
+  "gpt-4": {
+    "openai": "gpt-4",
+    "openrouter": "openai/gpt-4"
+  },
+  "gpt-4-1106-preview": {
+    "openai": "gpt-4-1106-preview",
+    "openrouter": "openai/gpt-4-1106-preview"
+  },
+  "gpt-4-turbo": {
+    "openai": "gpt-4-turbo",
+    "openrouter": "openai/gpt-4-turbo"
+  },
+  "gpt-4-turbo-preview": {
+    "openai": "gpt-4-turbo-preview",
+    "openrouter": "openai/gpt-4-turbo-preview"
+  },
+  "gpt-4.1": {
+    "openai": "gpt-4.1",
+    "openrouter": "openai/gpt-4.1"
+  },
+  "gpt-4.1-mini": {
+    "openai": "gpt-4.1-mini",
+    "openrouter": "openai/gpt-4.1-mini"
+  },
+  "gpt-4.1-nano": {
+    "openai": "gpt-4.1-nano",
+    "openrouter": "openai/gpt-4.1-nano"
+  },
+  "gpt-4.5-preview": {
+    "openai": "gpt-4.5-preview",
+    "openrouter": "openai/gpt-4.5-preview"
   },
   "gpt-4o": {
     "openai": "gpt-4o",
     "openrouter": "openai/gpt-4o"
   },
+  "gpt-4o-2024-05-13": {
+    "openai": "gpt-4o-2024-05-13",
+    "openrouter": "openai/gpt-4o-2024-05-13"
+  },
+  "gpt-4o-2024-08-06": {
+    "openai": "gpt-4o-2024-08-06",
+    "openrouter": "openai/gpt-4o-2024-08-06"
+  },
+  "gpt-4o-2024-11-20": {
+    "openai": "gpt-4o-2024-11-20",
+    "openrouter": "openai/gpt-4o-2024-11-20"
+  },
   "gpt-4o-mini": {
     "openai": "gpt-4o-mini",
     "openrouter": "openai/gpt-4o-mini"
   },
-  "gpt-4-turbo": {
-    "openai": "gpt-4-turbo",
-    "openrouter": "openai/gpt-4-turbo"
-  },
-  "gemini-1.5-flash": {
-    "gemini": "gemini-1.5-flash",
-    "openrouter": "google/gemini-flash-1.5"
+  "gpt-4o-mini-2024-07-18": {
+    "openai": "gpt-4o-mini-2024-07-18",
+    "openrouter": "openai/gpt-4o-mini-2024-07-18"
   },
-  "gemini-1.5-flash-8b": {
-    "gemini": "gemini-1.5-flash-8b",
-    "openrouter": "google/gemini-flash-1.5-8b"
+  "gpt-4o-mini-search-preview": {
+    "openai": "gpt-4o-mini-search-preview",
+    "openrouter": "openai/gpt-4o-mini-search-preview"
   },
-  "gemini-1.5-pro": {
-    "gemini": "gemini-1.5-pro",
-    "openrouter": "google/gemini-pro-1.5"
-  },
-  "gemini-2.0-flash": {
-    "gemini": "gemini-2.0-flash",
-    "openrouter": "google/gemini-2.0-flash-001"
+  "gpt-4o-search-preview": {
+    "openai": "gpt-4o-search-preview",
+    "openrouter": "openai/gpt-4o-search-preview"
   },
   "o1": {
     "openai": "o1",
     "openrouter": "openai/o1"
   },
+  "o1-mini": {
+    "openai": "o1-mini",
+    "openrouter": "openai/o1-mini"
+  },
+  "o1-mini-2024-09-12": {
+    "openai": "o1-mini-2024-09-12",
+    "openrouter": "openai/o1-mini-2024-09-12"
+  },
+  "o1-preview": {
+    "openai": "o1-preview",
+    "openrouter": "openai/o1-preview"
+  },
+  "o1-preview-2024-09-12": {
+    "openai": "o1-preview-2024-09-12",
+    "openrouter": "openai/o1-preview-2024-09-12"
+  },
+  "o1-pro": {
+    "openai": "o1-pro",
+    "openrouter": "openai/o1-pro"
+  },
+  "o3": {
+    "openai": "o3",
+    "openrouter": "openai/o3"
+  },
   "o3-mini": {
     "openai": "o3-mini",
     "openrouter": "openai/o3-mini"
+  },
+  "o3-pro": {
+    "openai": "o3-pro",
+    "openrouter": "openai/o3-pro"
+  },
+  "o4-mini": {
+    "openai": "o4-mini",
+    "openrouter": "openai/o4-mini"
   }
 }