ruby_llm 1.13.2 → 1.16.0

data/lib/ruby_llm/active_record/acts_as_legacy.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'active_support/concern'
+require 'active_support/inflector'
+
 module RubyLLM
   module ActiveRecord
     # Adds chat and message persistence capabilities to ActiveRecord models.
@@ -58,6 +61,8 @@ module RubyLLM
         end
 
         def acts_as_tool_call(message_class: 'Message', message_foreign_key: nil, result_foreign_key: nil)
+          include RubyLLM::ActiveRecord::ToolCallMethods
+
           @message_class = message_class.to_s
           @message_foreign_key = message_foreign_key || ActiveSupport::Inflector.foreign_key(@message_class)
           @result_foreign_key = result_foreign_key || ActiveSupport::Inflector.foreign_key(name)
@@ -158,27 +163,33 @@ module RubyLLM
         self
       end
 
-      def on_new_message(&block)
-        to_llm
+      def on_new_message(&)
+        to_llm.on_new_message(&)
+        self
+      end
 
-        existing_callback = @chat.instance_variable_get(:@on)[:new_message]
+      def on_end_message(&)
+        to_llm.on_end_message(&)
+        self
+      end
 
-        @chat.on_new_message do
-          existing_callback&.call
-          block&.call
-        end
+      def before_message(...)
+        to_llm.before_message(...)
         self
       end
 
-      def on_end_message(&block)
-        to_llm
+      def after_message(...)
+        to_llm.after_message(...)
+        self
+      end
 
-        existing_callback = @chat.instance_variable_get(:@on)[:end_message]
+      def before_tool_call(...)
+        to_llm.before_tool_call(...)
+        self
+      end
 
-        @chat.on_end_message do |msg|
-          existing_callback&.call(msg)
-          block&.call(msg)
-        end
+      def after_tool_result(...)
+        to_llm.after_tool_result(...)
         self
       end
 
@@ -211,7 +222,7 @@ module RubyLLM
       end
 
       def create_user_message(content, with: nil)
-        RubyLLM.logger.warn(
+        RubyLLM.deprecator.warn(
           '`create_user_message` is deprecated and will be removed in RubyLLM 2.0. ' \
           'Use `add_message(role: :user, content: ...)` instead.'
         )
@@ -317,8 +328,8 @@ module RubyLLM
       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.before_message { persist_new_message }
+        @chat.after_message { |msg| persist_message_completion(msg) }
 
         @chat.instance_variable_set(:@_persistence_callbacks_setup, true)
         @chat
@@ -381,8 +392,8 @@ module RubyLLM
           case attachment
           when ActionDispatch::Http::UploadedFile, ActiveStorage::Blob
             attachment
-          when ActiveStorage::Attached::One, ActiveStorage::Attached::Many
-            attachment.blobs
+          when ActiveStorage::Attachment, ActiveStorage::Attached::One, ActiveStorage::Attached::Many
+            active_storage_blobs(attachment)
           when Hash
             attachment.values.map { |v| prepare_for_active_storage(v) }
           else
@@ -396,16 +407,28 @@ module RubyLLM
 
         attachment = source.is_a?(RubyLLM::Attachment) ? source : RubyLLM::Attachment.new(source)
 
-        {
-          io: StringIO.new(attachment.content),
-          filename: attachment.filename,
-          content_type: attachment.mime_type
-        }
+        if attachment.active_storage?
+          active_storage_blobs(attachment.source)
+        else
+          {
+            io: StringIO.new(attachment.content),
+            filename: attachment.filename,
+            content_type: attachment.mime_type
+          }
+        end
       rescue StandardError => e
         RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
         nil
       end
 
+      def active_storage_blobs(attachment)
+        case attachment
+        when ActiveStorage::Blob then attachment
+        when ActiveStorage::Attachment, ActiveStorage::Attached::One then attachment.blob
+        when ActiveStorage::Attached::Many then attachment.blobs
+        end
+      end
+
       def build_content(message, attachments)
         return message if content_like?(message)
 
@@ -471,18 +494,91 @@ module RubyLLM
       end
 
       def extract_content
-        return content unless respond_to?(:attachments) && attachments.attached?
+        text_content = if content.respond_to?(:to_plain_text)
+                         content.to_plain_text
+                       else
+                         content
+                       end
+
+        return text_content unless respond_to?(:attachments) && attachments.attached?
 
-        RubyLLM::Content.new(content).tap do |content_obj|
+        RubyLLM::Content.new(text_content).tap do |content_obj|
           @_tempfiles = []
 
-          attachments.each do |attachment|
-            tempfile = download_attachment(attachment)
-            content_obj.add_attachment(tempfile, filename: attachment.filename.to_s)
+          attachment_sources.each do |attachment, attachable|
+            add_attachment_to_content(content_obj, attachment, attachable)
           end
         end
       end
 
+      def attachment_sources
+        change = pending_attachment_change
+        return attachments.map { |attachment| [attachment, nil] } unless pending_attachment_change?(change)
+
+        change.attachments.zip(change.attachables)
+      end
+
+      def pending_attachment_change
+        attachment_changes['attachments'] if respond_to?(:attachment_changes)
+      end
+
+      def pending_attachment_change?(change)
+        change.respond_to?(:attachments) && change.respond_to?(:attachables)
+      end
+
+      def add_attachment_to_content(content_obj, attachment, attachable)
+        if pending_upload_attachable?(attachable)
+          add_pending_upload_attachment(content_obj, attachable)
+        else
+          tempfile = download_attachment(attachment)
+          content_obj.add_attachment(tempfile, filename: attachment.filename.to_s)
+        end
+      end
+
+      def pending_upload_attachable?(attachable)
+        return false if attachable.nil? || attachable.is_a?(String)
+        return false if instance_of_class?(attachable, 'ActiveStorage::Blob')
+
+        uploaded_file?(attachable) || active_storage_upload_hash?(attachable) ||
+          attachable.is_a?(File) || pathname?(attachable)
+      end
+
+      def uploaded_file?(attachable)
+        instance_of_class?(attachable, 'ActionDispatch::Http::UploadedFile') ||
+          instance_of_class?(attachable, 'Rack::Test::UploadedFile')
+      end
+
+      def active_storage_upload_hash?(attachable)
+        attachable.is_a?(Hash) && attachment_hash_io(attachable).present?
+      end
+
+      def pathname?(attachable)
+        defined?(Pathname) && attachable.is_a?(Pathname)
+      end
+
+      def add_pending_upload_attachment(content_obj, attachable)
+        if attachable.is_a?(Hash)
+          content_obj.add_attachment(attachment_hash_io(attachable), filename: attachment_hash_filename(attachable))
+        else
+          content_obj.add_attachment(attachable)
+        end
+      end
+
+      def attachment_hash_io(attachable)
+        attachable[:io] || attachable['io']
+      end
+
+      def attachment_hash_filename(attachable)
+        filename = attachable[:filename] || attachable['filename']
+        filename&.to_s
+      end
+
+      def instance_of_class?(object, class_name)
+        Object.const_get(class_name).then { |klass| object.is_a?(klass) }
+      rescue NameError
+        false
+      end
+
       def download_attachment(attachment)
         ext = File.extname(attachment.filename.to_s)
         basename = File.basename(attachment.filename.to_s, ext)

data/lib/ruby_llm/active_record/chat_methods.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require 'active_support/concern'
+
 module RubyLLM
   module ActiveRecord
     # Methods mixed into chat models.
@@ -63,8 +65,8 @@ module RubyLLM
           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.modalities = model_info.modalities.to_h
+          m.pricing = model_info.pricing.to_h
           m.metadata = model_info.metadata || {}
         end
 
@@ -125,7 +127,7 @@ module RubyLLM
         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:)
+        to_llm.with_model(model_association.model_id, provider: model_association.provider.to_sym, assume_exists:)
         self
       end
 
@@ -154,27 +156,33 @@ module RubyLLM
         self
       end
 
-      def on_new_message(&block)
-        to_llm
+      def on_new_message(&)
+        to_llm.on_new_message(&)
+        self
+      end
 
-        existing_callback = @chat.instance_variable_get(:@on)[:new_message]
+      def on_end_message(&)
+        to_llm.on_end_message(&)
+        self
+      end
 
-        @chat.on_new_message do
-          existing_callback&.call
-          block&.call
-        end
+      def before_message(...)
+        to_llm.before_message(...)
         self
       end
 
-      def on_end_message(&block)
-        to_llm
+      def after_message(...)
+        to_llm.after_message(...)
+        self
+      end
 
-        existing_callback = @chat.instance_variable_get(:@on)[:end_message]
+      def before_tool_call(...)
+        to_llm.before_tool_call(...)
+        self
+      end
 
-        @chat.on_end_message do |msg|
-          existing_callback&.call(msg)
-          block&.call(msg)
-        end
+      def after_tool_result(...)
+        to_llm.after_tool_result(...)
         self
       end
 
@@ -208,6 +216,10 @@ module RubyLLM
         message_record
       end
 
+      def cost
+        RubyLLM::Cost.aggregate(messages_association.map(&:cost))
+      end
+
       def create_user_message(content, with: nil)
         add_message(role: :user, content: build_content(content, with))
       end
@@ -258,8 +270,8 @@ module RubyLLM
       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.before_message { persist_new_message }
+        @chat.after_message { |msg| persist_message_completion(msg) }
 
         @chat.instance_variable_set(:@_persistence_callbacks_setup, true)
         @chat
@@ -402,8 +414,8 @@ module RubyLLM
           case attachment
           when ActionDispatch::Http::UploadedFile, ActiveStorage::Blob
             attachment
-          when ActiveStorage::Attached::One, ActiveStorage::Attached::Many
-            attachment.blobs
+          when ActiveStorage::Attachment, ActiveStorage::Attached::One, ActiveStorage::Attached::Many
+            active_storage_blobs(attachment)
           when Hash
             attachment.values.map { |v| prepare_for_active_storage(v) }
           else
@@ -417,16 +429,28 @@ module RubyLLM
 
         attachment = source.is_a?(RubyLLM::Attachment) ? source : RubyLLM::Attachment.new(source)
 
-        {
-          io: StringIO.new(attachment.content),
-          filename: attachment.filename,
-          content_type: attachment.mime_type
-        }
+        if attachment.active_storage?
+          active_storage_blobs(attachment.source)
+        else
+          {
+            io: StringIO.new(attachment.content),
+            filename: attachment.filename,
+            content_type: attachment.mime_type
+          }
+        end
       rescue StandardError => e
         RubyLLM.logger.warn "Failed to process attachment #{source}: #{e.message}"
         nil
       end
 
+      def active_storage_blobs(attachment)
+        case attachment
+        when ActiveStorage::Blob then attachment
+        when ActiveStorage::Attachment, ActiveStorage::Attached::One then attachment.blob
+        when ActiveStorage::Attached::Many then attachment.blobs
+        end
+      end
+
       def build_content(message, attachments)
         return message if content_like?(message)
 

data/lib/ruby_llm/active_record/message_methods.rb

@@ -1,10 +1,14 @@
 # frozen_string_literal: true
 
+require 'active_support/concern'
+require 'ruby_llm/active_record/payload_helpers'
+
 module RubyLLM
   module ActiveRecord
     # Methods mixed into message models.
     module MessageMethods
       extend ActiveSupport::Concern
+      include PayloadHelpers
 
       class_methods do
         attr_reader :chat_class, :tool_call_class, :chat_foreign_key, :tool_call_foreign_key
@@ -39,6 +43,34 @@ module RubyLLM
         )
       end
 
+      def cost
+        RubyLLM::Cost.new(tokens:, model: model_association)
+      end
+
+      def cache_read_tokens
+        cached_value
+      end
+
+      def cache_write_tokens
+        cache_creation_value
+      end
+
+      def to_partial_path
+        partial_prefix = self.class.name.underscore.pluralize
+        role_partial = if to_llm.tool_call?
+                         'tool_calls'
+                       elsif role.to_s == 'tool'
+                         'tool'
+                       else
+                         role.to_s.presence || 'assistant'
+                       end
+        "#{partial_prefix}/#{role_partial}"
+      end
+
+      def tool_error_message
+        payload_error_message(content)
+      end
+
       private
 
       def thinking_text_value
@@ -82,20 +114,88 @@ module RubyLLM
       def extract_content
         return RubyLLM::Content::Raw.new(content_raw) if has_attribute?(:content_raw) && content_raw.present?
 
-        content_value = self[:content]
+        content_value = content
+        content_value = content_value.to_plain_text if content_value.respond_to?(:to_plain_text)
 
         return content_value unless respond_to?(:attachments) && attachments.attached?
 
         RubyLLM::Content.new(content_value).tap do |content_obj|
           @_tempfiles = []
 
-          attachments.each do |attachment|
-            tempfile = download_attachment(attachment)
-            content_obj.add_attachment(tempfile, filename: attachment.filename.to_s)
+          attachment_sources.each do |attachment, attachable|
+            add_attachment_to_content(content_obj, attachment, attachable)
           end
         end
       end
 
+      def attachment_sources
+        change = pending_attachment_change
+        return attachments.map { |attachment| [attachment, nil] } unless pending_attachment_change?(change)
+
+        change.attachments.zip(change.attachables)
+      end
+
+      def pending_attachment_change
+        attachment_changes['attachments'] if respond_to?(:attachment_changes)
+      end
+
+      def pending_attachment_change?(change)
+        change.respond_to?(:attachments) && change.respond_to?(:attachables)
+      end
+
+      def add_attachment_to_content(content_obj, attachment, attachable)
+        if pending_upload_attachable?(attachable)
+          add_pending_upload_attachment(content_obj, attachable)
+        else
+          tempfile = download_attachment(attachment)
+          content_obj.add_attachment(tempfile, filename: attachment.filename.to_s)
+        end
+      end
+
+      def pending_upload_attachable?(attachable)
+        return false if attachable.nil? || attachable.is_a?(String)
+        return false if instance_of_class?(attachable, 'ActiveStorage::Blob')
+
+        uploaded_file?(attachable) || active_storage_upload_hash?(attachable) ||
+          attachable.is_a?(File) || pathname?(attachable)
+      end
+
+      def uploaded_file?(attachable)
+        instance_of_class?(attachable, 'ActionDispatch::Http::UploadedFile') ||
+          instance_of_class?(attachable, 'Rack::Test::UploadedFile')
+      end
+
+      def active_storage_upload_hash?(attachable)
+        attachable.is_a?(Hash) && attachment_hash_io(attachable).present?
+      end
+
+      def pathname?(attachable)
+        defined?(Pathname) && attachable.is_a?(Pathname)
+      end
+
+      def add_pending_upload_attachment(content_obj, attachable)
+        if attachable.is_a?(Hash)
+          content_obj.add_attachment(attachment_hash_io(attachable), filename: attachment_hash_filename(attachable))
+        else
+          content_obj.add_attachment(attachable)
+        end
+      end
+
+      def attachment_hash_io(attachable)
+        attachable[:io] || attachable['io']
+      end
+
+      def attachment_hash_filename(attachable)
+        filename = attachable[:filename] || attachable['filename']
+        filename&.to_s
+      end
+
+      def instance_of_class?(object, class_name)
+        Object.const_get(class_name).then { |klass| object.is_a?(klass) }
+      rescue NameError
+        false
+      end
+
       def download_attachment(attachment)
         ext = File.extname(attachment.filename.to_s)
         basename = File.basename(attachment.filename.to_s, ext)

data/lib/ruby_llm/active_record/model_methods.rb

@@ -1,5 +1,8 @@
 # frozen_string_literal: true
 
+require 'active_support/concern'
+require 'active_support/core_ext/module/delegation'
+
 module RubyLLM
   module ActiveRecord
     # Methods mixed into model registry models.
@@ -10,15 +13,7 @@ module RubyLLM
         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
+          save_to_database
         end
 
         def save_to_database
@@ -76,8 +71,11 @@ module RubyLLM
 
       delegate :supports?, :supports_vision?, :supports_functions?, :type,
                :input_price_per_million, :output_price_per_million,
+               :cache_read_input_price_per_million, :cache_write_input_price_per_million,
+               :cached_input_price_per_million, :cache_creation_input_price_per_million,
                :function_calling?, :structured_output?, :batch?,
-               :reasoning?, :citations?, :streaming?, :provider_class,
+               :reasoning?, :citations?, :streaming?, :provider_class, :label,
+               :cost_for,
                to: :to_llm
     end
   end

data/lib/ruby_llm/active_record/payload_helpers.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'active_support/core_ext/object/blank'
+require 'json'
+
+module RubyLLM
+  module ActiveRecord
+    # Shared helpers for parsing serialized payloads on ActiveRecord-backed models.
+    module PayloadHelpers
+      private
+
+      def payload_error_message(value)
+        payload = parse_payload(value)
+        return unless payload.is_a?(Hash)
+
+        payload['error'] || payload[:error]
+      end
+
+      def parse_payload(value)
+        return value if value.is_a?(Hash) || value.is_a?(Array)
+        return if value.blank?
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        nil
+      end
+    end
+  end
+end

data/lib/ruby_llm/active_record/tool_call_methods.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'ruby_llm/active_record/payload_helpers'
+
+module RubyLLM
+  module ActiveRecord
+    # Methods mixed into tool call models.
+    module ToolCallMethods
+      extend ActiveSupport::Concern
+      include PayloadHelpers
+
+      def tool_error_message
+        payload_error_message(arguments)
+      end
+    end
+  end
+end

data/lib/ruby_llm/agent.rb

@@ -121,14 +121,17 @@ module RubyLLM
         input_values, = partition_inputs(kwargs)
         record = resolved_chat_model.find(id)
         apply_configuration(record, input_values:, persist_instructions: false)
+
         record
       end
 
+      # Mutates persisted instructions on the configured chat record.
       def sync_instructions!(chat_or_id, **kwargs)
         raise ArgumentError, 'chat_model must be configured to use sync_instructions!' unless resolved_chat_model
 
         input_values, = partition_inputs(kwargs)
         record = chat_or_id.is_a?(resolved_chat_model) ? chat_or_id : resolved_chat_model.find(chat_or_id)
+        apply_assume_model_exists(record)
         runtime = runtime_context(chat: record, inputs: input_values)
         instructions_value = resolved_instructions_value(record, runtime, inputs: input_values)
         return record if instructions_value.nil?
@@ -227,9 +230,18 @@ module RubyLLM
       end
 
       def llm_chat_for(chat_object)
+        apply_assume_model_exists(chat_object)
         chat_object.respond_to?(:to_llm) ? chat_object.to_llm : chat_object
       end
 
+      def apply_assume_model_exists(chat_object)
+        return unless chat_kwargs.key?(:assume_model_exists) &&
+                      resolved_chat_model &&
+                      chat_object.is_a?(resolved_chat_model)
+
+        chat_object.assume_model_exists = chat_kwargs[:assume_model_exists]
+      end
+
       def evaluate(value, runtime)
         value.is_a?(Proc) ? runtime.instance_exec(&value) : value
       end
@@ -348,7 +360,8 @@ module RubyLLM
 
     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!
+                   :with_schema, :on_new_message, :on_end_message, :on_tool_call, :on_tool_result, :before_message,
+                   :after_message, :before_tool_call, :after_tool_result, :each, :complete, :add_message,
+                   :reset_messages!, :cost
   end
 end