Refactor media attachment handling across providers

- Updated media.rb files for Anthropic, Bedrock, Gemini, Ollama, and OpenAI to use attachment types instead of classes for better clarity and maintainability.
- Enhanced error handling to raise UnsupportedAttachmentError with attachment type.
- Modified format_text_file_for_llm to include mime_type in the output.
- Added 'marcel' gem dependency for improved file type detection.
- Updated chat_content_spec to verify attachment filename and mime_type for various content types, ensuring accurate handling of remote and local files.
- Removed redundant tests and improved error handling for missing extensions and bad URLs.

Author: crmne

lib/ruby_llm/attachment.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # A class representing a file attachment.
+  class Attachment
+    attr_reader :source, :filename, :mime_type
+
+    def initialize(source, filename: nil)
+      @source = source
+      if url?
+        @source = URI source
+        @filename = filename || File.basename(@source.path).to_s
+      elsif path?
+        @source = Pathname.new source
+        @filename = filename || @source.basename.to_s
+      else
+        @filename = filename
+      end
+
+      @mime_type = RubyLLM::MimeType.for @source, name: @filename
+      @mime_type = RubyLLM::MimeType.for content if @mime_type == 'application/octet-stream'
+    end
+
+    def url?
+      @source.is_a?(URI) || (@source.is_a?(String) && @source.match?(%r{^https?://}))
+    end
+
+    def path?
+      @source.is_a?(Pathname) || (@source.is_a?(String) && !url?)
+    end
+
+    def io_like?
+      @source.respond_to?(:read) && !path?
+    end
+
+    def content
+      return @content if defined?(@content) && !@content.nil?
+
+      if url?
+        fetch_content
+      elsif path?
+        load_content_from_path
+      elsif io_like?
+        load_content_from_io
+      else
+        RubyLLM.logger.warn "Source is neither a URL, path, nor IO-like: #{@source.class}"
+        nil
+      end
+
+      @content
+    end
+
+    def encoded
+      Base64.strict_encode64(content)
+    end
+
+    def type
+      return :image if image?
+      return :audio if audio?
+      return :pdf if pdf?
+
+      :text
+    end
+
+    def image?
+      RubyLLM::MimeType.image? mime_type
+    end
+
+    def audio?
+      RubyLLM::MimeType.audio? mime_type
+    end
+
+    def pdf?
+      RubyLLM::MimeType.pdf? mime_type
+    end
+
+    def text?
+      RubyLLM::MimeType.text? mime_type
+    end
+
+    def as_json
+      { type: a.type, source: a.source }
+    end
+
+    private
+
+    def fetch_content
+      response = Connection.basic.get @source.to_s
+      @content = response.body
+    end
+
+    def load_content_from_path
+      @content = File.read(@source)
+    end
+
+    def load_content_from_io
+      @source.rewind if source.respond_to? :rewind
+      @content = @source.read
+    end
+  end
+end

lib/ruby_llm/attachments.rb

@@ -5,6 +5,19 @@ module RubyLLM
   class Connection
     attr_reader :provider, :connection, :config
 
+    def self.basic
+      Faraday.new do |faraday|
+        faraday.response :logger,
+                         RubyLLM.logger,
+                         bodies: false,
+                         response: false,
+                         errors: true,
+                         headers: false,
+                         log_level: :debug
+        faraday.use Faraday::Response::RaiseError
+      end
+    end
+
     def initialize(provider, config)
       @provider = provider
       @config = config
@@ -40,8 +53,13 @@ def setup_timeout(faraday)
     end
 
     def setup_logging(faraday)
-      faraday.response :logger, RubyLLM.logger, bodies: true, response: true,
-                                                errors: true, headers: false, log_level: :debug do |logger|
+      faraday.response :logger,
+                       RubyLLM.logger,
+                       bodies: true,
+                       response: true,
+                       errors: true,
+                       headers: false,
+                       log_level: :debug do |logger|
         logger.filter(%r{[A-Za-z0-9+/=]{100,}}, 'data":"[BASE64 DATA]"')
         logger.filter(/[-\d.e,\s]{100,}/, '[EMBEDDINGS ARRAY]')
       end

lib/ruby_llm/attachments/audio.rb

@@ -2,8 +2,7 @@
 
 module RubyLLM
   # Represents the content sent to or received from an LLM.
-  # Stores data in a standard internal format, letting providers
-  # handle their own formatting needs.
+  # Selects the appropriate attachment class based on the content type.
   class Content
     attr_reader :text, :attachments
 
@@ -15,29 +14,11 @@ def initialize(text = nil, attachments = nil)
       raise ArgumentError, 'Text and attachments cannot be both nil' if @text.nil? && @attachments.empty?
     end
 
-    def add_attachment(klass, source)
-      props = extract_source_properties(source)
-      @attachments << klass.new(props[:location], filename: props[:filename], mime_type: props[:mime_type])
+    def add_attachment(source)
+      @attachments << Attachment.new(source)
       self
     end
 
-    def add_image(source)
-      add_attachment(Attachments::Image, source)
-    end
-
-    def add_audio(source)
-      add_attachment(Attachments::Audio, source)
-    end
-
-    def add_pdf(source)
-      add_attachment(Attachments::PDF, source)
-    end
-
-    def add_text(source)
-      puts source
-      add_attachment(Attachments::Text, source)
-    end
-
     def format
       if @text && @attachments.empty?
         @text
@@ -48,72 +29,21 @@ def format
 
     # For Rails serialization
     def as_json
-      hash = { text: @text }
-      unless @attachments.empty?
-        hash[:attachments] = @attachments.map do |a|
-          { type: a.type, source: a.source }
-        end
-      end
-      hash
+      { text: @text, attachments: @attachments.map(&:as_json) }
     end
 
     private
 
-    def extract_source_properties(source)
-      if source.is_a?(Hash) && Utils.hash_get(source, :location)
-        {
-          location: Utils.hash_get(source, :location),
-          mime_type: Utils.hash_get(source, :mime_type),
-          filename: Utils.hash_get(source, :filename)
-        }
-      else
-        { location: source }
-      end
-    end
-
-    def process_attachments_hash(attachments)
-      return unless attachments.is_a?(Hash)
-
-      Utils.to_safe_array(attachments[:image]).each { |source| add_image(source) }
-      Utils.to_safe_array(attachments[:audio]).each { |source| add_audio(source) }
-      Utils.to_safe_array(attachments[:pdf]).each { |source| add_pdf(source) }
-      Utils.to_safe_array(attachments[:text]).each { |source| add_text(source) }
-    end
-
     def process_attachments_array_or_string(attachments)
       Utils.to_safe_array(attachments).each do |file|
-        props = extract_source_properties(file)
-
-        if props[:mime_type]
-          # Use explicitly provided MIME type
-          add_attachment_by_mime_type(props[:location], props[:mime_type], props[:filename])
-        else
-          # Fall back to detection from path
-          detect_and_add_attachment(props[:location])
-        end
+        add_attachment(file)
       end
     end
 
-    def add_attachment_by_mime_type(source, mime_type, filename = nil)
-      if RubyLLM::MimeTypes.image?(mime_type)
-        add_image({ location: source, mime_type: mime_type, filename: filename })
-      elsif RubyLLM::MimeTypes.audio?(mime_type)
-        add_audio({ location: source, mime_type: mime_type, filename: filename })
-      elsif RubyLLM::MimeTypes.pdf?(mime_type)
-        add_pdf({ location: source, mime_type: mime_type, filename: filename })
-      else
-        add_text({ location: source, mime_type: mime_type, filename: filename })
-      end
-    end
-
-    def detect_and_add_attachment(file)
-      mime_type = RubyLLM::MimeTypes.detect_from_path(file.to_s)
-      add_attachment_by_mime_type(file, mime_type)
-    end
-
     def process_attachments(attachments)
       if attachments.is_a?(Hash)
-        process_attachments_hash attachments
+        # Ignores types (like :image, :audio, :text, :pdf) since we have robust MIME type detection
+        attachments.each_value(&method(:process_attachments_array_or_string))
       else
         process_attachments_array_or_string attachments
       end

lib/ruby_llm/attachments/image.rb

@@ -25,7 +25,6 @@ class InvalidRoleError < StandardError; end
   class ModelNotFoundError < StandardError; end
   class UnsupportedFunctionsError < StandardError; end
   class UnsupportedAttachmentError < StandardError; end
-  class MissingExtensionError < StandardError; end
 
   # Error classes for different HTTP status codes
   class BadRequestError < Error; end