Refactored ActiveStorage integration

Author: crmne

lib/ruby_llm/active_record/acts_as.rb

@@ -143,26 +143,9 @@ def on_end_message(...)
         self
       end
 
-      def create_user_message(content, with: nil) # rubocop:disable Metrics/PerceivedComplexity
-        message_record = messages.create!(
-          role: :user,
-          content: content
-        )
-
-        if with.present?
-          files = Array(with).reject do |f|
-            f.nil? || (f.respond_to?(:empty?) && f.empty?) || (f.respond_to?(:blank?) && f.blank?)
-          end
-
-          if files.any?
-            if files.first.is_a?(ActionDispatch::Http::UploadedFile)
-              message_record.attachments.attach(files)
-            else
-              attach_files(message_record, process_attachments(with))
-            end
-          end
-        end
-
+      def create_user_message(content, with: nil)
+        message_record = messages.create!(role: :user, content: content)
+        persist_content(message_record, with) if with.present?
         message_record
       end
 
@@ -221,82 +204,13 @@ def persist_tool_calls(tool_calls)
         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
-          elsif RubyLLM::MimeTypes.pdf?(content_type)
-            result[:pdf] ||= []
-            result[:pdf] << file
-          else
-            result[:text] ||= []
-            result[:text] << file
-          end
-        end
-
-        result
-      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 text].each do |type|
-          Array(attachments_hash[type]).each do |file_source|
-            attach_file(message, file_source)
-          end
-        end
-      end
+        attachments = Utils.to_safe_array(attachments).reject(&:blank?)
+        return if attachments.empty?
 
-      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
+        message_record.attachments.attach(attachments)
       end
 
       def extract_filename(file)
@@ -342,57 +256,40 @@ def extract_tool_call_id
         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)
-          else
-            content_obj.add_text(attachment_data)
+        RubyLLM::Content.new(content).tap do |content_obj|
+          # Prevent tempfiles from being garbage-collected during API calls
+          @_tempfiles = []
+
+          attachments.each do |attachment|
+            # Always download the file to ensure it works across all storage backends
+            tempfile = download_attachment(attachment)
+            content_obj.add_attachment(tempfile)
           end
         end
-
-        content_obj
       end
 
       private
 
-      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
+      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 do |chunk|
+          tempfile.write(chunk)
         end
+
+        tempfile.flush
+        tempfile.rewind
+
+        # Keep reference to prevent GC
+        @_tempfiles << tempfile
+
+        tempfile
       end
     end
   end