ruby_llm 1.2.0 → 1.3.0

data/lib/ruby_llm/content.rb

@@ -2,103 +2,51 @@
 
 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
-    def initialize(text = nil, attachments = {}) # rubocop:disable Metrics/AbcSize,Metrics/MethodLength
-      @parts = []
-      @parts << { type: 'text', text: text } unless text.nil? || text.empty?
+    attr_reader :text, :attachments
 
-      Array(attachments[:image]).each do |source|
-        @parts << attach_image(source)
-      end
-
-      Array(attachments[:audio]).each do |source|
-        @parts << attach_audio(source)
-      end
+    def initialize(text = nil, attachments = nil)
+      @text = text
+      @attachments = []
 
-      Array(attachments[:pdf]).each do |source|
-        @parts << attach_pdf(source)
-      end
+      process_attachments(attachments)
+      raise ArgumentError, 'Text and attachments cannot be both nil' if @text.nil? && @attachments.empty?
     end
 
-    def to_a
-      return if @parts.empty?
-
-      @parts
+    def add_attachment(source, filename: nil)
+      @attachments << Attachment.new(source, filename:)
+      self
     end
 
     def format
-      return @parts.first[:text] if @parts.size == 1 && @parts.first[:type] == 'text'
-
-      to_a
-    end
-
-    private
-
-    def attach_image(source) # rubocop:disable Metrics/MethodLength
-      source = File.expand_path(source) unless source.start_with?('http')
-
-      return { type: 'image', source: { url: source } } if source.start_with?('http')
-
-      data = Base64.strict_encode64(File.read(source))
-      mime_type = mime_type_for(source)
-
-      {
-        type: 'image',
-        source: {
-          type: 'base64',
-          media_type: mime_type,
-          data: data
-        }
-      }
+      if @text && @attachments.empty?
+        @text
+      else
+        self
+      end
     end
 
-    def attach_audio(source)
-      source = File.expand_path(source) unless source.start_with?('http')
-      data = encode_file(source)
-      format = File.extname(source).delete('.') || 'wav'
-
-      {
-        type: 'input_audio',
-        input_audio: {
-          data: data,
-          format: format
-        }
-      }
+    # For Rails serialization
+    def to_h
+      { text: @text, attachments: @attachments.map(&:to_h) }
     end
 
-    def attach_pdf(source)
-      source = File.expand_path(source) unless source.start_with?('http')
-
-      pdf_data = {
-        type: 'pdf',
-        source: source
-      }
-
-      # For local files, validate they exist
-      unless source.start_with?('http')
-        raise Error, "PDF file not found: #{source}" unless File.exist?(source)
+    private
 
-        # Preload file content for providers that need it
-        pdf_data[:content] = File.read(source)
+    def process_attachments_array_or_string(attachments)
+      Utils.to_safe_array(attachments).each do |file|
+        add_attachment(file)
       end
-
-      pdf_data
     end
 
-    def encode_file(source)
-      if source.start_with?('http')
-        response = Faraday.get(source)
-        Base64.strict_encode64(response.body)
+    def process_attachments(attachments)
+      if attachments.is_a?(Hash)
+        # Ignores types (like :image, :audio, :text, :pdf) since we have robust MIME type detection
+        attachments.each_value(&method(:process_attachments_array_or_string))
       else
-        Base64.strict_encode64(File.read(source))
+        process_attachments_array_or_string attachments
       end
     end
-
-    def mime_type_for(path)
-      ext = File.extname(path).delete('.')
-      "image/#{ext}"
-    end
   end
 end

data/lib/ruby_llm/context.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Holds per-call configs
+  class Context
+    attr_reader :config
+
+    def initialize(config)
+      @config = config
+      @connections = {}
+    end
+
+    def chat(*args, **kwargs, &)
+      Chat.new(*args, **kwargs, context: self, &)
+    end
+
+    def embed(*args, **kwargs, &)
+      Embedding.embed(*args, **kwargs, context: self, &)
+    end
+
+    def paint(*args, **kwargs, &)
+      Image.paint(*args, **kwargs, context: self, &)
+    end
+
+    def connection_for(provider_module)
+      slug = provider_module.slug.to_sym
+      @connections[slug] ||= Connection.new(provider_module, @config)
+    end
+  end
+end

data/lib/ruby_llm/embedding.rb

@@ -12,12 +12,20 @@ module RubyLLM
       @input_tokens = input_tokens
     end
 
-    def self.embed(text, model: nil)
-      model_id = model || RubyLLM.config.default_embedding_model
-      Models.find(model_id)
+    def self.embed(text, # rubocop:disable Metrics/ParameterLists
+                   model: nil,
+                   provider: nil,
+                   assume_model_exists: false,
+                   context: nil,
+                   dimensions: nil)
+      config = context&.config || RubyLLM.config
+      model ||= config.default_embedding_model
+      model, provider = Models.resolve(model, provider: provider, assume_exists: assume_model_exists)
+      model_id = model.id
 
-      provider = Provider.for(model_id)
-      provider.embed(text, model: model_id)
+      provider = Provider.for(model_id) if provider.nil?
+      connection = context ? context.connection_for(provider) : provider.connection(config)
+      provider.embed(text, model: model_id, connection:, dimensions:)
     end
   end
 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
@@ -50,7 +51,7 @@ module RubyLLM
     end
 
     class << self
-      def parse_error(provider:, response:) # rubocop:disable Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/AbcSize,Metrics/PerceivedComplexity
+      def parse_error(provider:, response:) # rubocop:disable Metrics/PerceivedComplexity
         message = provider&.parse_error(response)
 
         case response.status

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
@@ -36,12 +35,20 @@ module RubyLLM
       path
     end
 
-    def self.paint(prompt, model: nil, size: '1024x1024')
-      model_id = model || RubyLLM.config.default_image_model
-      Models.find(model_id) # Validate model exists
+    def self.paint(prompt, # rubocop:disable Metrics/ParameterLists
+                   model: nil,
+                   provider: nil,
+                   assume_model_exists: false,
+                   size: '1024x1024',
+                   context: nil)
+      config = context&.config || RubyLLM.config
+      model ||= config.default_image_model
+      model, provider = Models.resolve(model, provider: provider, assume_exists: assume_model_exists)
+      model_id = model.id
 
-      provider = Provider.for(model_id)
-      provider.paint(prompt, model: model_id, size: size)
+      provider = Provider.for(model_id) if provider.nil?
+      connection = context ? context.connection_for(provider) : provider.connection(config)
+      provider.paint(prompt, model: model_id, size:, connection:)
     end
   end
 end

data/lib/ruby_llm/message.rb

@@ -7,11 +7,11 @@ module RubyLLM
   class Message
     ROLES = %i[system user assistant tool].freeze
 
-    attr_reader :role, :content, :tool_calls, :tool_call_id, :input_tokens, :output_tokens, :model_id
+    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]
@@ -21,6 +21,14 @@ module RubyLLM
       ensure_valid_role
     end
 
+    def content
+      if @content.is_a?(Content) && @content.text && @content.attachments.empty?
+        @content.text
+      else
+        @content
+      end
+    end
+
     def tool_call?
       !tool_calls.nil? && !tool_calls.empty?
     end
@@ -49,9 +57,9 @@ module RubyLLM
 
     def normalize_content(content)
       case content
-      when Content then content.format
-      when String then Content.new(content).format
-      else content
+      when String then Content.new(content)
+      when Hash then Content.new(content[:text], content)
+      else content # Pass through nil, Content, or other types
       end
     end
 

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

data/lib/ruby_llm/model/pricing_category.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # Represents pricing tiers for different usage categories (standard and batch)
+    class PricingCategory
+      attr_reader :standard, :batch
+
+      def initialize(data = {})
+        @standard = PricingTier.new(data[:standard] || {}) unless empty_tier?(data[:standard])
+        @batch = PricingTier.new(data[:batch] || {}) unless empty_tier?(data[:batch])
+      end
+
+      # Shorthand methods that default to standard tier
+      def input
+        standard&.input_per_million
+      end
+
+      def output
+        standard&.output_per_million
+      end
+
+      def cached_input
+        standard&.cached_input_per_million
+      end
+
+      # Get value for a specific tier
+      def [](key)
+        key == :batch ? batch : standard
+      end
+
+      def to_h
+        result = {}
+        result[:standard] = standard.to_h if standard
+        result[:batch] = batch.to_h if batch
+        result
+      end
+
+      private
+
+      def empty_tier?(tier_data)
+        return true unless tier_data
+
+        tier_data.values.all? { |v| v.nil? || v == 0.0 }
+      end
+    end
+  end
+end

data/lib/ruby_llm/model/pricing_tier.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  module Model
+    # A dynamic class for storing non-zero pricing values with flexible attribute access
+    class PricingTier
+      def initialize(data = {})
+        @values = {}
+
+        # Only store non-zero values
+        data.each do |key, value|
+          @values[key.to_sym] = value if value && value != 0.0
+        end
+      end
+
+      def method_missing(method, *args)
+        if method.to_s.end_with?('=')
+          key = method.to_s.chomp('=').to_sym
+          @values[key] = args.first if args.first && args.first != 0.0
+        elsif @values.key?(method)
+          @values[method]
+        end
+      end
+
+      def respond_to_missing?(method, include_private = false)
+        method.to_s.end_with?('=') || @values.key?(method.to_sym) || super
+      end
+
+      def to_h
+        @values
+      end
+    end
+  end
+end

data/lib/ruby_llm/model.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # Model-related classes for working with LLM models
+  module Model
+  end
+end