ruby_llm 1.6.3 → 1.7.0

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -0,0 +1,336 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module ActiveRecord
+    # Methods mixed into chat models.
+    module ChatMethods
+      extend ActiveSupport::Concern
+
+      included do
+        before_save :resolve_model_from_strings
+      end
+
+      attr_accessor :assume_model_exists, :context
+
+      def model=(value)
+        @model_string = value if value.is_a?(String)
+        return if value.is_a?(String)
+
+        if self.class.model_association_name == :model
+          super
+        else
+          self.model_association = value
+        end
+      end
+
+      def model_id=(value)
+        @model_string = value
+      end
+
+      def model_id
+        model_association&.model_id
+      end
+
+      def provider=(value)
+        @provider_string = value
+      end
+
+      def provider
+        model_association&.provider
+      end
+
+      private
+
+      def resolve_model_from_strings # rubocop:disable Metrics/PerceivedComplexity
+        config = context&.config || RubyLLM.config
+        @model_string ||= config.default_model unless model_association
+        return unless @model_string
+
+        model_info, _provider = Models.resolve(
+          @model_string,
+          provider: @provider_string,
+          assume_exists: assume_model_exists || false,
+          config: config
+        )
+
+        model_class = self.class.model_class.constantize
+        model_record = model_class.find_or_create_by!(
+          model_id: model_info.id,
+          provider: model_info.provider
+        ) do |m|
+          m.name = model_info.name || model_info.id
+          m.family = model_info.family
+          m.context_window = model_info.context_window
+          m.max_output_tokens = model_info.max_output_tokens
+          m.capabilities = model_info.capabilities || []
+          m.modalities = model_info.modalities || {}
+          m.pricing = model_info.pricing || {}
+          m.metadata = model_info.metadata || {}
+        end
+
+        self.model_association = model_record
+        @model_string = nil
+        @provider_string = nil
+      end
+
+      public
+
+      def to_llm
+        model_record = model_association
+        @chat ||= (context || RubyLLM).chat(
+          model: model_record.model_id,
+          provider: model_record.provider.to_sym
+        )
+        @chat.reset_messages!
+
+        messages_association.each do |msg|
+          @chat.add_message(msg.to_llm)
+        end
+
+        setup_persistence_callbacks
+      end
+
+      def with_instructions(instructions, replace: false)
+        transaction do
+          messages_association.where(role: :system).destroy_all if replace
+          messages_association.create!(role: :system, content: instructions)
+        end
+        to_llm.with_instructions(instructions)
+        self
+      end
+
+      def with_tool(...)
+        to_llm.with_tool(...)
+        self
+      end
+
+      def with_tools(...)
+        to_llm.with_tools(...)
+        self
+      end
+
+      def with_model(model_name, provider: nil, assume_exists: false)
+        self.model = model_name
+        self.provider = provider if provider
+        self.assume_model_exists = assume_exists
+        resolve_model_from_strings
+        save!
+        to_llm.with_model(model.model_id, provider: model.provider.to_sym, assume_exists:)
+        self
+      end
+
+      def with_temperature(...)
+        to_llm.with_temperature(...)
+        self
+      end
+
+      def with_params(...)
+        to_llm.with_params(...)
+        self
+      end
+
+      def with_headers(...)
+        to_llm.with_headers(...)
+        self
+      end
+
+      def with_schema(...)
+        to_llm.with_schema(...)
+        self
+      end
+
+      def on_new_message(&block)
+        to_llm
+
+        existing_callback = @chat.instance_variable_get(:@on)[:new_message]
+
+        @chat.on_new_message do
+          existing_callback&.call
+          block&.call
+        end
+        self
+      end
+
+      def on_end_message(&block)
+        to_llm
+
+        existing_callback = @chat.instance_variable_get(:@on)[:end_message]
+
+        @chat.on_end_message do |msg|
+          existing_callback&.call(msg)
+          block&.call(msg)
+        end
+        self
+      end
+
+      def on_tool_call(...)
+        to_llm.on_tool_call(...)
+        self
+      end
+
+      def on_tool_result(...)
+        to_llm.on_tool_result(...)
+        self
+      end
+
+      def create_user_message(content, with: nil)
+        message_record = messages_association.create!(role: :user, content: content)
+        persist_content(message_record, with) if with.present?
+        message_record
+      end
+
+      def ask(message, with: nil, &)
+        create_user_message(message, with:)
+        complete(&)
+      end
+
+      alias say ask
+
+      def complete(...)
+        to_llm.complete(...)
+      rescue RubyLLM::Error => e
+        cleanup_failed_messages if @message&.persisted? && @message.content.blank?
+        cleanup_orphaned_tool_results
+        raise e
+      end
+
+      private
+
+      def cleanup_failed_messages
+        RubyLLM.logger.warn "RubyLLM: API call failed, destroying message: #{@message.id}"
+        @message.destroy
+      end
+
+      def cleanup_orphaned_tool_results # rubocop:disable Metrics/PerceivedComplexity
+        messages_association.reload
+        last = messages_association.order(:id).last
+
+        return unless last&.tool_call? || last&.tool_result?
+
+        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)
+
+          if expected_results.sort != actual_results.sort
+            tool_call_message.tool_results.each(&:destroy)
+            tool_call_message.destroy
+          end
+        end
+      end
+
+      def setup_persistence_callbacks
+        return @chat if @chat.instance_variable_get(:@_persistence_callbacks_setup)
+
+        @chat.on_new_message { persist_new_message }
+        @chat.on_end_message { |msg| persist_message_completion(msg) }
+
+        @chat.instance_variable_set(:@_persistence_callbacks_setup, true)
+        @chat
+      end
+
+      def persist_new_message
+        @message = messages_association.create!(role: :assistant, content: '')
+      end
+
+      def persist_message_completion(message) # rubocop:disable Metrics/PerceivedComplexity
+        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
+
+          attrs = {
+            role: message.role,
+            content: content,
+            input_tokens: message.input_tokens,
+            output_tokens: message.output_tokens
+          }
+
+          # Add model association dynamically
+          attrs[self.class.model_association_name] = model_association
+
+          if tool_call_id
+            parent_tool_call_assoc = @message.class.reflect_on_association(:parent_tool_call)
+            attrs[parent_tool_call_assoc.foreign_key] = tool_call_id
+          end
+
+          @message.update!(attrs)
+
+          persist_content(@message, attachments_to_persist) if attachments_to_persist
+          persist_tool_calls(message.tool_calls) if message.tool_calls.present?
+        end
+      end
+
+      def persist_tool_calls(tool_calls)
+        tool_calls.each_value do |tool_call|
+          attributes = tool_call.to_h
+          attributes[:tool_call_id] = attributes.delete(:id)
+          @message.tool_calls_association.create!(**attributes)
+        end
+      end
+
+      def find_tool_call_id(tool_call_id)
+        messages = messages_association
+        message_class = messages.klass
+        tool_calls_assoc = message_class.tool_calls_association_name
+        tool_call_table_name = message_class.reflect_on_association(tool_calls_assoc).table_name
+
+        message_with_tool_call = messages.joins(tool_calls_assoc)
+                                         .find_by(tool_call_table_name => { tool_call_id: tool_call_id })
+        return nil unless message_with_tool_call
+
+        tool_call = message_with_tool_call.tool_calls_association.find_by(tool_call_id: tool_call_id)
+        tool_call&.id
+      end
+
+      def persist_content(message_record, attachments)
+        return unless message_record.respond_to?(:attachments)
+
+        attachables = prepare_for_active_storage(attachments)
+        message_record.attachments.attach(attachables) if attachables.any?
+      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 convert_to_active_storage_format(source)
+        return if source.blank?
+
+        attachment = source.is_a?(RubyLLM::Attachment) ? source : 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
+  end
+end

data/lib/ruby_llm/active_record/message_methods.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module ActiveRecord
+    # Methods mixed into message models.
+    module MessageMethods
+      extend ActiveSupport::Concern
+
+      class_methods do
+        attr_reader :chat_class, :tool_call_class, :chat_foreign_key, :tool_call_foreign_key
+      end
+
+      def to_llm
+        RubyLLM::Message.new(
+          role: role.to_sym,
+          content: extract_content,
+          tool_calls: extract_tool_calls,
+          tool_call_id: extract_tool_call_id,
+          input_tokens: input_tokens,
+          output_tokens: output_tokens,
+          model_id: model_association&.model_id
+        )
+      end
+
+      private
+
+      def extract_tool_calls
+        tool_calls_association.to_h do |tool_call|
+          [
+            tool_call.tool_call_id,
+            RubyLLM::ToolCall.new(
+              id: tool_call.tool_call_id,
+              name: tool_call.name,
+              arguments: tool_call.arguments
+            )
+          ]
+        end
+      end
+
+      def extract_tool_call_id
+        parent_tool_call&.tool_call_id
+      end
+
+      def extract_content
+        return content unless respond_to?(:attachments) && attachments.attached?
+
+        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
+      end
+
+      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
+
+        attachment.download { |chunk| tempfile.write(chunk) }
+
+        tempfile.flush
+        tempfile.rewind
+        @_tempfiles << tempfile
+        tempfile
+      end
+    end
+  end
+end

data/lib/ruby_llm/active_record/model_methods.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module ActiveRecord
+    # Methods mixed into model registry models.
+    module ModelMethods
+      extend ActiveSupport::Concern
+
+      class_methods do # rubocop:disable Metrics/BlockLength
+        def refresh!
+          RubyLLM.models.refresh!
+
+          transaction do
+            RubyLLM.models.all.each do |model_info|
+              model = find_or_initialize_by(
+                model_id: model_info.id,
+                provider: model_info.provider
+              )
+              model.update!(from_llm_attributes(model_info))
+            end
+          end
+        end
+
+        def save_to_database
+          transaction do
+            RubyLLM.models.all.each do |model_info|
+              model = find_or_initialize_by(
+                model_id: model_info.id,
+                provider: model_info.provider
+              )
+              model.update!(from_llm_attributes(model_info))
+            end
+          end
+        end
+
+        def from_llm(model_info)
+          new(from_llm_attributes(model_info))
+        end
+
+        private
+
+        def from_llm_attributes(model_info)
+          {
+            model_id: model_info.id,
+            name: model_info.name,
+            provider: model_info.provider,
+            family: model_info.family,
+            model_created_at: model_info.created_at,
+            context_window: model_info.context_window,
+            max_output_tokens: model_info.max_output_tokens,
+            knowledge_cutoff: model_info.knowledge_cutoff,
+            modalities: model_info.modalities.to_h,
+            capabilities: model_info.capabilities,
+            pricing: model_info.pricing.to_h,
+            metadata: model_info.metadata
+          }
+        end
+      end
+
+      def to_llm
+        RubyLLM::Model::Info.new(
+          id: model_id,
+          name: name,
+          provider: provider,
+          family: family,
+          created_at: model_created_at,
+          context_window: context_window,
+          max_output_tokens: max_output_tokens,
+          knowledge_cutoff: knowledge_cutoff,
+          modalities: modalities&.deep_symbolize_keys || {},
+          capabilities: capabilities,
+          pricing: pricing&.deep_symbolize_keys || {},
+          metadata: metadata&.deep_symbolize_keys || {}
+        )
+      end
+
+      delegate :supports?, :supports_vision?, :supports_functions?, :type,
+               :input_price_per_million, :output_price_per_million,
+               :function_calling?, :structured_output?, :batch?,
+               :reasoning?, :citations?, :streaming?,
+               to: :to_llm
+    end
+  end
+end

data/lib/ruby_llm/aliases.json

@@ -50,21 +50,57 @@
     "deepseek": "deepseek-chat",
     "openrouter": "deepseek/deepseek-chat"
   },
+  "gemini-1.5-flash": {
+    "gemini": "gemini-1.5-flash",
+    "vertexai": "gemini-1.5-flash"
+  },
+  "gemini-1.5-flash-002": {
+    "gemini": "gemini-1.5-flash-002",
+    "vertexai": "gemini-1.5-flash-002"
+  },
+  "gemini-1.5-flash-8b": {
+    "gemini": "gemini-1.5-flash-8b",
+    "vertexai": "gemini-1.5-flash-8b"
+  },
+  "gemini-1.5-pro": {
+    "gemini": "gemini-1.5-pro",
+    "vertexai": "gemini-1.5-pro"
+  },
+  "gemini-1.5-pro-002": {
+    "gemini": "gemini-1.5-pro-002",
+    "vertexai": "gemini-1.5-pro-002"
+  },
+  "gemini-2.0-flash": {
+    "gemini": "gemini-2.0-flash",
+    "vertexai": "gemini-2.0-flash"
+  },
   "gemini-2.0-flash-001": {
     "gemini": "gemini-2.0-flash-001",
-    "openrouter": "google/gemini-2.0-flash-001"
+    "openrouter": "google/gemini-2.0-flash-001",
+    "vertexai": "gemini-2.0-flash-001"
+  },
+  "gemini-2.0-flash-exp": {
+    "gemini": "gemini-2.0-flash-exp",
+    "vertexai": "gemini-2.0-flash-exp"
   },
   "gemini-2.0-flash-lite-001": {
     "gemini": "gemini-2.0-flash-lite-001",
-    "openrouter": "google/gemini-2.0-flash-lite-001"
+    "openrouter": "google/gemini-2.0-flash-lite-001",
+    "vertexai": "gemini-2.0-flash-lite-001"
   },
   "gemini-2.5-flash": {
     "gemini": "gemini-2.5-flash",
-    "openrouter": "google/gemini-2.5-flash"
+    "openrouter": "google/gemini-2.5-flash",
+    "vertexai": "gemini-2.5-flash"
+  },
+  "gemini-2.5-flash-image-preview": {
+    "gemini": "gemini-2.5-flash-image-preview",
+    "openrouter": "google/gemini-2.5-flash-image-preview"
   },
   "gemini-2.5-flash-lite": {
     "gemini": "gemini-2.5-flash-lite",
-    "openrouter": "google/gemini-2.5-flash-lite"
+    "openrouter": "google/gemini-2.5-flash-lite",
+    "vertexai": "gemini-2.5-flash-lite"
   },
   "gemini-2.5-flash-lite-preview-06-17": {
     "gemini": "gemini-2.5-flash-lite-preview-06-17",
@@ -72,12 +108,21 @@
   },
   "gemini-2.5-pro": {
     "gemini": "gemini-2.5-pro",
-    "openrouter": "google/gemini-2.5-pro"
+    "openrouter": "google/gemini-2.5-pro",
+    "vertexai": "gemini-2.5-pro"
   },
   "gemini-2.5-pro-preview-05-06": {
     "gemini": "gemini-2.5-pro-preview-05-06",
     "openrouter": "google/gemini-2.5-pro-preview-05-06"
   },
+  "gemini-embedding-001": {
+    "gemini": "gemini-embedding-001",
+    "vertexai": "gemini-embedding-001"
+  },
+  "gemini-exp-1206": {
+    "gemini": "gemini-exp-1206",
+    "vertexai": "gemini-exp-1206"
+  },
   "gemma-3-12b-it": {
     "gemini": "gemma-3-12b-it",
     "openrouter": "google/gemma-3-12b-it"
@@ -150,6 +195,10 @@
     "openai": "gpt-4o-2024-11-20",
     "openrouter": "openai/gpt-4o-2024-11-20"
   },
+  "gpt-4o-audio-preview": {
+    "openai": "gpt-4o-audio-preview",
+    "openrouter": "openai/gpt-4o-audio-preview"
+  },
   "gpt-4o-mini": {
     "openai": "gpt-4o-mini",
     "openrouter": "openai/gpt-4o-mini"
@@ -178,14 +227,6 @@
     "openai": "gpt-5-nano",
     "openrouter": "openai/gpt-5-nano"
   },
-  "gpt-oss-120b": {
-    "openai": "gpt-oss-120b",
-    "openrouter": "openai/gpt-oss-120b"
-  },
-  "gpt-oss-20b": {
-    "openai": "gpt-oss-20b",
-    "openrouter": "openai/gpt-oss-20b"
-  },
   "o1": {
     "openai": "o1",
     "openrouter": "openai/o1"
@@ -217,5 +258,9 @@
   "o4-mini": {
     "openai": "o4-mini",
     "openrouter": "openai/o4-mini"
+  },
+  "text-embedding-004": {
+    "gemini": "text-embedding-004",
+    "vertexai": "text-embedding-004"
   }
 }

data/lib/ruby_llm/attachment.rb

@@ -65,6 +65,15 @@ module RubyLLM
       Base64.strict_encode64(content)
     end
 
+    def for_llm
+      case type
+      when :text
+        "<file name='#{filename}' mime_type='#{mime_type}'>#{content}</file>"
+      else
+        "data:#{mime_type};base64,#{encoded}"
+      end
+    end
+
     def type
       return :image if image?
       return :audio if audio?
@@ -82,6 +91,17 @@ module RubyLLM
       RubyLLM::MimeType.audio? mime_type
     end
 
+    def format
+      case mime_type
+      when 'audio/mpeg'
+        'mp3'
+      when 'audio/wav', 'audio/wave', 'audio/x-wav'
+        'wav'
+      else
+        mime_type.split('/').last
+      end
+    end
+
     def pdf?
       RubyLLM::MimeType.pdf? mime_type
     end

data/lib/ruby_llm/chat.rb

@@ -126,7 +126,7 @@ module RubyLLM
         messages,
         tools: @tools,
         temperature: @temperature,
-        model: @model.id,
+        model: @model,
         params: @params,
         headers: @headers,
         schema: @schema,
@@ -163,6 +163,10 @@ module RubyLLM
       @messages.clear
     end
 
+    def instance_variables
+      super - %i[@connection @config]
+    end
+
     private
 
     def wrap_streaming_block(&block)
@@ -181,7 +185,7 @@ module RubyLLM
       end
     end
 
-    def handle_tool_calls(response, &)
+    def handle_tool_calls(response, &) # rubocop:disable Metrics/PerceivedComplexity
       halt_result = nil
 
       response.tool_calls.each_value do |tool_call|
@@ -189,7 +193,8 @@ module RubyLLM
         @on[:tool_call]&.call(tool_call)
         result = execute_tool tool_call
         @on[:tool_result]&.call(result)
-        message = add_message role: :tool, content: result.to_s, tool_call_id: tool_call.id
+        content = result.is_a?(Content) ? result : result.to_s
+        message = add_message role: :tool, content:, tool_call_id: tool_call.id
         @on[:end_message]&.call(message)
 
         halt_result = result if result.is_a?(Tool::Halt)
@@ -203,9 +208,5 @@ module RubyLLM
       args = tool_call.arguments
       tool.call(args)
     end
-
-    def instance_variables
-      super - %i[@connection @config]
-    end
   end
 end