ruby_llm 1.3.0rc1 → 1.3.1

data/lib/ruby_llm/attachment.rb

@@ -0,0 +1,164 @@
+# 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
+      elsif active_storage?
+        @filename = filename || extract_filename_from_active_storage
+      else
+        @filename = filename
+      end
+
+      determine_mime_type
+    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? && !active_storage?
+    end
+
+    def active_storage?
+      return false unless defined?(ActiveStorage)
+
+      @source.is_a?(ActiveStorage::Blob) ||
+        @source.is_a?(ActiveStorage::Attached::One) ||
+        @source.is_a?(ActiveStorage::Attached::Many)
+    end
+
+    def content
+      return @content if defined?(@content) && !@content.nil?
+
+      if url?
+        fetch_content
+      elsif path?
+        load_content_from_path
+      elsif active_storage?
+        load_content_from_active_storage
+      elsif io_like?
+        load_content_from_io
+      else
+        RubyLLM.logger.warn "Source is neither a URL, path, ActiveStorage, 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?
+      return :text if text?
+
+      :unknown
+    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 to_h
+      { type: type, source: @source }
+    end
+
+    private
+
+    def determine_mime_type
+      return @mime_type = active_storage_content_type if active_storage? && active_storage_content_type.present?
+
+      @mime_type = RubyLLM::MimeType.for(@source, name: @filename)
+      @mime_type = RubyLLM::MimeType.for(content) if @mime_type == 'application/octet-stream'
+      @mime_type = 'audio/wav' if @mime_type == 'audio/x-wav' # Normalize WAV type
+    end
+
+    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
+
+    def load_content_from_active_storage
+      return unless defined?(ActiveStorage)
+
+      @content = case @source
+                 when ActiveStorage::Blob
+                   @source.download
+                 when ActiveStorage::Attached::One
+                   @source.blob&.download
+                 when ActiveStorage::Attached::Many
+                   # For multiple attachments, just take the first one
+                   # This maintains the single-attachment interface
+                   @source.blobs.first&.download
+                 end
+    end
+
+    def extract_filename_from_active_storage # rubocop:disable Metrics/PerceivedComplexity
+      return 'attachment' unless defined?(ActiveStorage)
+
+      case @source
+      when ActiveStorage::Blob
+        @source.filename.to_s
+      when ActiveStorage::Attached::One
+        @source.blob&.filename&.to_s || 'attachment'
+      when ActiveStorage::Attached::Many
+        @source.blobs.first&.filename&.to_s || 'attachment'
+      else
+        'attachment'
+      end
+    end
+
+    def active_storage_content_type
+      return unless defined?(ActiveStorage)
+
+      case @source
+      when ActiveStorage::Blob
+        @source.content_type
+      when ActiveStorage::Attached::One
+        @source.blob&.content_type
+      when ActiveStorage::Attached::Many
+        @source.blobs.first&.content_type
+      end
+    end
+  end
+end

data/lib/ruby_llm/chat.rb

@@ -18,10 +18,10 @@ module RubyLLM
         raise ArgumentError, 'Provider must be specified if assume_model_exists is true'
       end
 
-      config = context&.config || RubyLLM.config
-      model_id = model || config.default_model
+      @context = context
+      @config = context&.config || RubyLLM.config
+      model_id = model || @config.default_model
       with_model(model_id, provider: provider, assume_exists: assume_model_exists)
-      @connection = context ? context.connection_for(@provider) : @provider.connection(config)
       @temperature = 0.7
       @messages = []
       @tools = {}
@@ -39,7 +39,7 @@ module RubyLLM
     alias say ask
 
     def with_instructions(instructions, replace: false)
-      @messages = @messages.reject! { |msg| msg.role == :system } if replace
+      @messages = @messages.reject { |msg| msg.role == :system } if replace
 
       add_message role: :system, content: instructions
       self
@@ -62,6 +62,7 @@ module RubyLLM
 
     def with_model(model_id, provider: nil, assume_exists: false)
       @model, @provider = Models.resolve(model_id, provider:, assume_exists:)
+      @connection = @context ? @context.connection_for(@provider) : @provider.connection(@config)
       self
     end
 
@@ -70,6 +71,13 @@ module RubyLLM
       self
     end
 
+    def with_context(context)
+      @context = context
+      @config = context.config
+      with_model(@model.id, provider: @provider.slug, assume_exists: true)
+      self
+    end
+
     def on_new_message(&block)
       @on[:new_message] = block
       self

data/lib/ruby_llm/configuration.rb

@@ -34,9 +34,12 @@ module RubyLLM
                   :retry_interval,
                   :retry_backoff_factor,
                   :retry_interval_randomness,
+                  :http_proxy,
                   # Logging configuration
+                  :logger,
                   :log_file,
-                  :log_level
+                  :log_level,
+                  :log_assume_model_exists
 
     def initialize
       # Connection configuration
@@ -45,6 +48,7 @@ module RubyLLM
       @retry_interval = 0.1
       @retry_backoff_factor = 2
       @retry_interval_randomness = 0.5
+      @http_proxy = nil
 
       # Default models
       @default_model = 'gpt-4.1-nano'
@@ -54,6 +58,7 @@ module RubyLLM
       # Logging configuration
       @log_file = $stdout
       @log_level = ENV['RUBYLLM_DEBUG'] ? Logger::DEBUG : Logger::INFO
+      @log_assume_model_exists = true
     end
 
     def inspect

data/lib/ruby_llm/connection.rb

@@ -5,6 +5,20 @@ module RubyLLM
   class Connection
     attr_reader :provider, :connection, :config
 
+    def self.basic(&)
+      Faraday.new do |f|
+        f.response :logger,
+                   RubyLLM.logger,
+                   bodies: false,
+                   response: false,
+                   errors: true,
+                   headers: false,
+                   log_level: :debug
+        f.response :raise_error
+        yield f if block_given?
+      end
+    end
+
     def initialize(provider, config)
       @provider = provider
       @config = config
@@ -15,6 +29,7 @@ module RubyLLM
         setup_logging(faraday)
         setup_retry(faraday)
         setup_middleware(faraday)
+        setup_http_proxy(faraday)
       end
     end
 
@@ -40,8 +55,13 @@ module RubyLLM
     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
@@ -65,6 +85,12 @@ module RubyLLM
       faraday.use :llm_errors, provider: @provider
     end
 
+    def setup_http_proxy(faraday)
+      return unless @config.http_proxy
+
+      faraday.proxy = @config.http_proxy
+    end
+
     def retry_exceptions
       [
         Errno::ETIMEDOUT,

data/lib/ruby_llm/content.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,18 +14,8 @@ module RubyLLM
       raise ArgumentError, 'Text and attachments cannot be both nil' if @text.nil? && @attachments.empty?
     end
 
-    def add_image(source)
-      @attachments << Attachments::Image.new(source)
-      self
-    end
-
-    def add_audio(source)
-      @attachments << Attachments::Audio.new(source)
-      self
-    end
-
-    def add_pdf(source)
-      @attachments << Attachments::PDF.new(source)
+    def add_attachment(source, filename: nil)
+      @attachments << Attachment.new(source, filename:)
       self
     end
 
@@ -39,42 +28,22 @@ module RubyLLM
     end
 
     # 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
+    def to_h
+      { text: @text, attachments: @attachments.map(&:to_h) }
     end
 
     private
 
-    def process_attachments_hash(attachments)
-      return unless attachments.is_a?(Hash)
-
-      Array(attachments[:image]).each { |source| add_image(source) }
-      Array(attachments[:audio]).each { |source| add_audio(source) }
-      Array(attachments[:pdf]).each { |source| add_pdf(source) }
-    end
-
     def process_attachments_array_or_string(attachments)
-      Array(attachments).each do |file|
-        mime_type = RubyLLM::MimeTypes.detect_from_path(file.to_s)
-        if RubyLLM::MimeTypes.image?(mime_type)
-          add_image file
-        elsif RubyLLM::MimeTypes.audio?(mime_type)
-          add_audio file
-        else
-          add_pdf file # Default to PDF for unknown types for now
-        end
+      Utils.to_safe_array(attachments).each do |file|
+        add_attachment(file)
       end
     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

data/lib/ruby_llm/error.rb

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

data/lib/ruby_llm/image.rb

@@ -22,10 +22,9 @@ module RubyLLM
     # Returns the raw binary image data regardless of source
     def to_blob
       if base64?
-        Base64.decode64(@data)
+        Base64.decode64 @data
       else
-        # Use Faraday instead of URI.open for better security
-        response = Faraday.get(@url)
+        response = Connection.basic.get @url
         response.body
       end
     end

data/lib/ruby_llm/message.rb

@@ -10,8 +10,8 @@ module RubyLLM
     attr_reader :role, :tool_calls, :tool_call_id, :input_tokens, :output_tokens, :model_id
 
     def initialize(options = {})
-      @role = options[:role].to_sym
-      @content = normalize_content(options[:content])
+      @role = options.fetch(:role).to_sym
+      @content = normalize_content(options.fetch(:content))
       @tool_calls = options[:tool_calls]
       @input_tokens = options[:input_tokens]
       @output_tokens = options[:output_tokens]

data/lib/ruby_llm/mime_type.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'marcel'
+
+module RubyLLM
+  # MimeTypes module provides methods to handle MIME types using Marcel gem
+  module MimeType
+    module_function
+
+    def for(...)
+      Marcel::MimeType.for(...)
+    end
+
+    def image?(type)
+      type.start_with?('image/')
+    end
+
+    def audio?(type)
+      type.start_with?('audio/')
+    end
+
+    def pdf?(type)
+      type == 'application/pdf'
+    end
+
+    def text?(type)
+      type.start_with?('text/') ||
+        TEXT_SUFFIXES.any? { |suffix| type.end_with?(suffix) } ||
+        NON_TEXT_PREFIX_TEXT_MIME_TYPES.include?(type)
+    end
+
+    # MIME types that have a text/ prefix but need to be handled differently
+    TEXT_SUFFIXES = ['+json', '+xml', '+html', '+yaml', '+csv', '+plain', '+javascript', '+svg'].freeze
+
+    # MIME types that don't have a text/ prefix but should be treated as text
+    NON_TEXT_PREFIX_TEXT_MIME_TYPES = [
+      'application/json', # Base type, even if specific ones end with +json
+      'application/xml',  # Base type, even if specific ones end with +xml
+      'application/javascript',
+      'application/ecmascript',
+      'application/rtf',
+      'application/sql',
+      'application/x-sh',
+      'application/x-csh',
+      'application/x-httpd-php',
+      'application/sdp',
+      'application/sparql-query',
+      'application/graphql',
+      'application/yang', # Data modeling language, often serialized as XML/JSON but the type itself is distinct
+      'application/mbox', # Mailbox format
+      'application/x-tex',
+      'application/x-latex',
+      'application/x-perl',
+      'application/x-python',
+      'application/x-tcl',
+      'application/pgp-signature', # Often ASCII armored
+      'application/pgp-keys',      # Often ASCII armored
+      'application/vnd.coffeescript',
+      'application/vnd.dart',
+      'application/vnd.oai.openapi', # Base for OpenAPI, often with +json or +yaml suffix
+      'application/vnd.zul',         # ZK User Interface Language (can be XML-like)
+      'application/x-yaml',          # Common non-standard for YAML
+      'application/yaml',            # Standard for YAML
+      'application/toml'             # TOML configuration files
+    ].freeze
+  end
+end

data/lib/ruby_llm/model/info.rb

@@ -0,0 +1,101 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # Information about an AI model's capabilities, pricing, and metadata.
+    # Used by the Models registry to help developers choose the right model
+    # for their needs.
+    #
+    # Example:
+    #   model = RubyLLM.models.find('gpt-4')
+    #   model.supports_vision?          # => true
+    #   model.supports_functions?       # => true
+    #   model.input_price_per_million   # => 30.0
+    class Info
+      attr_reader :id, :name, :provider, :family, :created_at, :context_window, :max_output_tokens, :knowledge_cutoff,
+                  :modalities, :capabilities, :pricing, :metadata
+
+      def initialize(data)
+        @id = data[:id]
+        @name = data[:name]
+        @provider = data[:provider]
+        @family = data[:family]
+        @created_at = data[:created_at]
+        @context_window = data[:context_window]
+        @max_output_tokens = data[:max_output_tokens]
+        @knowledge_cutoff = data[:knowledge_cutoff]
+        @modalities = Modalities.new(data[:modalities] || {})
+        @capabilities = data[:capabilities] || []
+        @pricing = Pricing.new(data[:pricing] || {})
+        @metadata = data[:metadata] || {}
+      end
+
+      # Capability methods
+      def supports?(capability)
+        capabilities.include?(capability.to_s)
+      end
+
+      %w[function_calling structured_output batch reasoning citations streaming].each do |cap|
+        define_method "#{cap}?" do
+          supports?(cap)
+        end
+      end
+
+      # Backward compatibility methods
+      def display_name
+        name
+      end
+
+      def max_tokens
+        max_output_tokens
+      end
+
+      def supports_vision?
+        modalities.input.include?('image')
+      end
+
+      def supports_functions?
+        function_calling?
+      end
+
+      def input_price_per_million
+        pricing.text_tokens.input
+      end
+
+      def output_price_per_million
+        pricing.text_tokens.output
+      end
+
+      def type # rubocop:disable Metrics/PerceivedComplexity
+        if modalities.output.include?('embeddings') && !modalities.output.include?('text')
+          'embedding'
+        elsif modalities.output.include?('image') && !modalities.output.include?('text')
+          'image'
+        elsif modalities.output.include?('audio') && !modalities.output.include?('text')
+          'audio'
+        elsif modalities.output.include?('moderation')
+          'moderation'
+        else
+          'chat'
+        end
+      end
+
+      def to_h
+        {
+          id: id,
+          name: name,
+          provider: provider,
+          family: family,
+          created_at: created_at,
+          context_window: context_window,
+          max_output_tokens: max_output_tokens,
+          knowledge_cutoff: knowledge_cutoff,
+          modalities: modalities.to_h,
+          capabilities: capabilities,
+          pricing: pricing.to_h,
+          metadata: metadata
+        }
+      end
+    end
+  end
+end

data/lib/ruby_llm/model/modalities.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # Holds and manages input and output modalities for a language model
+    class Modalities
+      attr_reader :input, :output
+
+      def initialize(data)
+        @input = Array(data[:input]).map(&:to_s)
+        @output = Array(data[:output]).map(&:to_s)
+      end
+
+      def to_h
+        {
+          input: input,
+          output: output
+        }
+      end
+    end
+  end
+end

data/lib/ruby_llm/model/pricing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # A collection that manages and provides access to different categories of pricing information
+    # (text tokens, images, audio tokens, embeddings)
+    class Pricing
+      def initialize(data)
+        @data = {}
+
+        # Initialize pricing categories
+        %i[text_tokens images audio_tokens embeddings].each do |category|
+          @data[category] = PricingCategory.new(data[category]) if data[category] && !empty_pricing?(data[category])
+        end
+      end
+
+      def method_missing(method, *args)
+        if respond_to_missing?(method)
+          @data[method.to_sym] || PricingCategory.new
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        %i[text_tokens images audio_tokens embeddings].include?(method.to_sym) || super
+      end
+
+      def to_h
+        @data.transform_values(&:to_h)
+      end
+
+      private
+
+      def empty_pricing?(data)
+        # Check if all pricing values in this category are zero or nil
+        return true unless data
+
+        %i[standard batch].each do |tier|
+          next unless data[tier]
+
+          data[tier].each_value do |value|
+            return false if value && value != 0.0
+          end
+        end
+
+        true
+      end
+    end
+  end
+end