ruby_llm 2.1.1 → 2.2.0

data/lib/ruby_llm/configuration.rb

@@ -25,7 +25,7 @@ module RubyLLM
   # never set.
   class Configuration
     class << self
-      def option(key, default = nil) # :nodoc:
+      def option(key, default = nil, &normalize) # :nodoc:
         key = key.to_sym
         return if options.include?(key)
 
@@ -33,6 +33,7 @@ module RubyLLM
 
         define_method("#{key}=") do |value|
           value = nil if value.is_a?(String) && value.strip.empty?
+          value = normalize.call(value) if normalize
           instance_variable_set(:"@#{key}", value)
         end
 
@@ -65,8 +66,8 @@ module RubyLLM
     # :attr_accessor: default_model
     #
     # The model id used by RubyLLM.chat when no model is given.
-    # Default: <tt>'gpt-5.6'</tt>.
-    option :default_model, 'gpt-5.6'
+    # Default: <tt>'gpt-6.1-sol'</tt>.
+    option :default_model, 'gpt-6.1-sol'
 
     ##
     # :attr_accessor: default_embedding_model
@@ -159,6 +160,15 @@ module RubyLLM
     # Optional persistence adapter installed by the Rails integration.
     option :batch_store, nil # :nodoc:
 
+    ##
+    # :attr_accessor: broadcast_messages
+    #
+    # Whether +acts_as_message+ records broadcast a chat's messages and
+    # streamed chunks with Turbo. Needs turbo-rails and Action Cable. An
+    # +acts_as_message+ model's +broadcasts:+ option overrides it. The
+    # chat UI generator turns it on. Default: +false+.
+    option :broadcast_messages, false
+
     ##
     # :attr_accessor: mcp_credential_store
     #
@@ -186,6 +196,59 @@ module RubyLLM
     # registering RubyLLM. Default: +nil+.
     option :mcp_client_id, nil
 
+    ##
+    # :attr_accessor: sandbox
+    #
+    # Where code from a model runs by default, such as the code
+    # Chat#with_code_execution executes: an MXC::Sandbox class from the mxc
+    # gem, its name as a String, or any sandbox Sandbox describes. Default:
+    # +nil+ (nothing runs locally).
+    option :sandbox, nil
+
+    ##
+    # :attr_accessor: sandbox_backend
+    #
+    # What isolates an MXC::Sandbox on Linux: +:bubblewrap+, which gives
+    # each run its own namespaces, or +:landlock+, which only restricts
+    # the files it can open and runs without network access. Other
+    # platforms ignore it, and so does a sandbox class that names its own
+    # backend. Default: +:bubblewrap+.
+    option :sandbox_backend, :bubblewrap
+
+    ##
+    # :attr_accessor: package_cache_dir
+    #
+    # Directory holding the gems and Python packages declared with
+    # Chat#with_code_execution, installed once and reused by every run.
+    # Defaults to a +packages+ directory in the operating system's user
+    # cache directory.
+    option :package_cache_dir, -> { (directory = Support::Utils.cache_directory) && File.join(directory, 'packages') }
+
+    ##
+    # :attr_accessor: code_execution_max_file_size
+    #
+    # Bytes a file that Chat#with_code_execution's code writes may have and
+    # still come back with the result. Larger files stay out, and the
+    # model is told which ones. Default: 10 MB.
+    #
+    #   config.code_execution_max_file_size = 100 * 1024 * 1024
+    #
+    option :code_execution_max_file_size, 10 * 1024 * 1024
+
+    ##
+    # :attr_accessor: file_converters
+    #
+    # Converters that turn a chat's files into text for the model, as a
+    # Hash of MIME types to converters, tried before the ones RubyLLM
+    # ships. A type may end in <tt>/*</tt>, like <tt>"image/*"</tt>, and a
+    # converter is anything that answers +call+ with an Attachment and
+    # returns its text, or +nil+ to pass it on. See FileStore::Converters.
+    # Default: <tt>{}</tt>.
+    #
+    #   config.file_converters["image/*"] = RubyLLM::FileStore::Converters::OCR.new
+    #
+    option :file_converters, -> { {} }
+
     # Keeps custom 1.x initializers bootable long enough to run the 2.0
     # upgrade generator. The registry is always RubyLLM-owned in 2.0.
     def model_registry_class=(_value) # :nodoc:
@@ -206,6 +269,27 @@ module RubyLLM
     # Seconds to wait for a response before timing out. Default: 300.
     option :request_timeout, 300
 
+    ##
+    # :attr_accessor: connect_timeout
+    #
+    # Seconds to wait for a connection to open before timing out, or +nil+
+    # to wait as long as request_timeout. Default: +nil+.
+    option :connect_timeout, nil
+
+    ##
+    # :attr_accessor: stream_idle_timeout
+    #
+    # Seconds a streaming request may go without receiving a byte, from
+    # sending the request or since the last chunk, before it fails with a
+    # ConnectionError whose +timeout?+ is +true+, as a request_timeout
+    # does, so fallbacks take over. +request_timeout+ still bounds sending
+    # the request, and opening the connection unless connect_timeout is
+    # set. Requests that don't stream ignore it. Default: +nil+, which leaves streams to +request_timeout+.
+    #
+    #   config.request_timeout = 1800
+    #   config.stream_idle_timeout = 60
+    option :stream_idle_timeout
+
     ##
     # :attr_accessor: max_retries
     #
@@ -248,6 +332,17 @@ module RubyLLM
     # SOCKS5 proxies are supported. Default: +nil+.
     option :http_proxy, nil
 
+    ##
+    # :attr_accessor: ssl
+    #
+    # TLS options for all requests, as a Hash of Faraday's SSL option
+    # keys, such as <tt>{ ca_file: '/certs/internal-ca.pem' }</tt> or
+    # <tt>{ verify: false }</tt>. A context copies its strings, but shares
+    # objects such as a +cert_store+, so give each context its own and
+    # leave it unchanged once used. WebSocket connections raise
+    # ArgumentError when it is set. Default: +nil+.
+    option :ssl, nil
+
     ##
     # :attr_accessor: tool_concurrency
     #
@@ -256,6 +351,28 @@ module RubyLLM
     # for fibers via the async gem. Default: +false+.
     option :tool_concurrency, false
 
+    ##
+    # :attr_accessor: context_budget
+    #
+    # The shares of the context window every chat and agent keeps tool
+    # results within, as Chat#with_context_budget takes them. A chat's or
+    # agent's own budget wins, and +nil+ there turns it off. Default:
+    # +nil+ (no budget).
+    #
+    #   config.context_budget = { per_result: 0.25, per_request: 0.7 }
+    #
+    option(:context_budget, nil) { |budget| Chat::ContextBudget.normalize(budget) }
+
+    ##
+    # :attr_accessor: max_run_time
+    #
+    # Seconds a persisted chat's run may go without progress, or a tool
+    # call it runs may take, before another process treats it as crashed
+    # and resumes it. A run makes progress as it streams and between
+    # steps. A process that dies frees its claims within a minute.
+    # Default: 600.
+    option :max_run_time, 600
+
     ##
     # :attr_accessor: auto_upload_large_files
     #
@@ -286,6 +403,27 @@ module RubyLLM
     # +:raise+. Default: +:warn+.
     option :deprecation_behavior, :warn
 
+    ##
+    # :attr_accessor: redact_error_messages
+    #
+    # Whether Error#message leaves out what the provider wrote. When
+    # +true+, a provider's error reads as its HTTP status, provider, and
+    # error code only, such as <tt>openai returned HTTP 400
+    # (invalid_request_error)</tt>, because providers often quote the
+    # request back. The text stays on Error#provider_message and the raw
+    # body on Error#response_body. Default: +false+.
+    option :redact_error_messages, false
+
+    ##
+    # :attr_accessor: split_think_tags
+    #
+    # Whether Chat Completions responses that open with a
+    # <tt><think>...</think></tt> block move that block into the
+    # message's thinking. Turn it on for servers that leave reasoning
+    # inline, such as llama.cpp with <tt>--reasoning-format none</tt>.
+    # A +reasoning_content+ field still wins. Default: +false+.
+    option :split_think_tags, false
+
     ##
     # :attr_accessor: faraday_adapter
     #
@@ -332,8 +470,17 @@ module RubyLLM
       end
     end
 
+    # Copies file_converters too, so registering one on a context's copy,
+    # <tt>config.file_converters["image/*"] = ...</tt>, leaves the
+    # original alone.
+    def initialize_copy(source) # :nodoc:
+      super
+      @file_converters = @file_converters.dup
+      @ssl = @ssl.to_h.transform_values { |value| value.is_a?(String) ? value.dup : value } if @ssl
+    end
+
     def instance_variables # :nodoc:
-      super.reject { |ivar| ivar.to_s.match?(/(_id|_key|_secret|_token|_credential_provider)$/) }
+      super.reject { |ivar| ivar.to_s.match?(/(_id|_key|_secret|_token|_credential_provider|_proxy|\A@ssl)$/) }
     end
 
     # Object#inspect reads the instance variable table directly, so

data/lib/ruby_llm/content_filter.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+module RubyLLM
+  # A ContentFilter is one verdict of the provider's content filtering on a
+  # request or its response, such as Azure's hate or protected material
+  # filters. They appear on Message#content_filters for providers that
+  # report them, whether or not they stopped the response, so you can see
+  # why a reply ended with Message#content_filtered? or what came close.
+  #
+  #   response = chat.ask "Summarize this paper"
+  #   response.content_filtered?                       # => true
+  #   response.content_filters.select(&:filtered?).map(&:category) # => ["hate"]
+  #
+  # A verdict names a category and a severity, never the text it judged.
+  class ContentFilter
+    include Support::Inspectable
+
+    SOURCES = %i[prompt completion].freeze # :nodoc:
+
+    # Which side was judged: +:prompt+ for the request, +:completion+ for
+    # the response.
+    attr_reader :source
+
+    # The provider's name for the category, such as <tt>"hate"</tt>,
+    # <tt>"jailbreak"</tt>, or <tt>"protected_material_text"</tt>.
+    attr_reader :category
+
+    # The severity the provider gave, such as <tt>"safe"</tt>,
+    # <tt>"low"</tt>, or <tt>"medium"</tt>, or +nil+ for a category
+    # judged only as detected or not.
+    attr_reader :severity
+
+    def self.from_h(data) # :nodoc:
+      data = data.transform_keys(&:to_sym)
+      new(source: data[:source], category: data[:category], severity: data[:severity],
+          filtered: data[:filtered], detected: data[:detected])
+    end
+
+    def initialize(source:, category:, severity: nil, filtered: false, detected: nil) # :nodoc:
+      @source = source&.to_sym
+      @category = category.to_s
+      @severity = severity
+      @filtered = filtered == true
+      @detected = detected
+    end
+
+    # Returns whether the filter blocked or cut the text it judged.
+    def filtered?
+      @filtered
+    end
+
+    # Returns whether the provider detected what the category looks for,
+    # such as a jailbreak attempt or protected material, or +nil+ for a
+    # category judged by severity.
+    def detected?
+      @detected
+    end
+
+    # Returns the verdict as a Hash, omitting +nil+ values.
+    def to_h
+      { source: source, category: category, severity: severity, filtered: filtered?, detected: @detected }.compact
+    end
+
+    def inspect_attributes # :nodoc:
+      to_h
+    end
+  end
+end

data/lib/ruby_llm/cost.rb

@@ -13,9 +13,14 @@ module RubyLLM
   #   cost.output
   #
   # The components are RubyLLM's normalized token buckets: #input, #output,
-  # #cache_read, #cache_write, and #thinking. When the registry lacks
-  # pricing for tokens that were used, the affected component and #total
-  # return +nil+ instead of a false zero.
+  # #cache_read, #cache_write, and #thinking, plus #characters,
+  # #audio_seconds, and #search_units for operations billed in those units.
+  # When the registry lacks pricing for usage that was reported, the
+  # affected component and #total return +nil+ instead of a false zero.
+  #
+  #   speech = RubyLLM.speak "Hello"
+  #   speech.cost.characters # => 0.00015, or nil when no price is known
+  #
   #
   # When the provider reports the exact cost of a call, #total returns the
   # reported amount instead of a registry-price estimate, even when
@@ -28,7 +33,8 @@ module RubyLLM
   class Cost
     include Support::Inspectable
 
-    COMPONENTS = %i[input output cache_read cache_write thinking].freeze # :nodoc:
+    UNITS = %i[characters audio_seconds search_units].freeze # :nodoc:
+    COMPONENTS = (%i[input output cache_read cache_write thinking] + UNITS).freeze # :nodoc:
     PER_MILLION = 1_000_000.0 # :nodoc:
 
     class << self
@@ -58,33 +64,43 @@ module RubyLLM
 
       # Rebuilds a cost from a stored breakdown Hash, as produced by #to_h
       # and persisted alongside a usage entry. Keys may be Strings or
-      # Symbols. The component readers return the recorded amounts and
-      # #total equals the recorded +:total+.
+      # Symbols, and amounts may be numeric Strings, as JSON encodes
+      # decimals. The component readers return the recorded amounts and
+      # #total equals the recorded +:total+. A breakdown with a total omits
+      # the components that had no usage, so ::aggregate still sums them
+      # across costs. Pass +tokens+ to mark used components without a
+      # recorded amount as missing pricing.
       #
       #   RubyLLM::Cost.from_h({ input: 0.0001, total: 0.0003 }).total
       #
       def from_h(hash, tokens: nil)
-        amounts = COMPONENTS.to_h { |component| [component, hash[component] || hash[component.to_s]] }
+        amounts = COMPONENTS.to_h { |component| [component, recorded_amount(hash, component)] }
         total_recorded = hash.key?(:total) || hash.key?('total')
-        total = hash[:total] || hash['total'] if total_recorded
-        missing = missing_recorded_components(amounts, tokens, total_recorded)
+        total = recorded_amount(hash, :total) if total_recorded
+        missing = missing_recorded_components(amounts, tokens, total)
 
         new(amounts:, missing:, reported: recorded_tokens?(amounts, tokens, total_recorded), total:)
       end
 
       private
 
+      def recorded_amount(hash, key)
+        amount = hash[key] || hash[key.to_s]
+        amount.is_a?(String) ? Float(amount) : amount
+      end
+
       def aggregate_total(costs)
         totals = costs.map(&:total)
         totals.sum if totals.any? && totals.none?(&:nil?)
       end
 
-      def missing_recorded_components(amounts, tokens, total_recorded)
-        return [] if total_recorded
-        return COMPONENTS.reject { |component| amounts[component] } unless tokens
-
-        COMPONENTS.select do |component|
-          tokens.public_send(component).to_i.positive? && amounts[component].nil?
+      def missing_recorded_components(amounts, tokens, total)
+        if tokens
+          COMPONENTS.select { |component| tokens.public_send(component).to_f.positive? && amounts[component].nil? }
+        elsif total && amounts.values.any?
+          []
+        else
+          COMPONENTS.reject { |component| amounts[component] }
         end
       end
 
@@ -145,10 +161,29 @@ module RubyLLM
       @amounts[:thinking]
     end
 
+    # Returns the cost of billed characters in US dollars, or +nil+ when
+    # the count or its pricing is unavailable.
+    def characters
+      @amounts[:characters]
+    end
+
+    # Returns the cost of billed audio seconds in US dollars, or +nil+ when
+    # the duration or its pricing is unavailable.
+    def audio_seconds
+      @amounts[:audio_seconds]
+    end
+
+    # Returns the cost of billed search units in US dollars, or +nil+ when
+    # the count or its pricing is unavailable.
+    def search_units
+      @amounts[:search_units]
+    end
+
     # Returns the sum of all components in US dollars, or the exact amount
     # the provider reported when it reported one. Returns +nil+ when there
     # is no token usage, or when pricing is missing for tokens that were
-    # used and the provider reported no cost.
+    # used and the provider reported no cost. A calculated total covers only
+    # the counts the provider reported, so partial usage can leave out charges.
     def total
       return nil unless @complete
       return nil unless tokens?
@@ -164,14 +199,7 @@ module RubyLLM
     # Returns a hash of component costs in US dollars, plus +:total+,
     # omitting +nil+ values.
     def to_h
-      {
-        input: input,
-        output: output,
-        cache_read: cache_read,
-        cache_write: cache_write,
-        thinking: thinking,
-        total: total
-      }.compact
+      COMPONENTS.to_h { |component| [component, public_send(component)] }.merge(total: total).compact
     end
 
     def tokens? # :nodoc:
@@ -202,9 +230,8 @@ module RubyLLM
     def missing_component?(component)
       return image_input_missing? if component == :input && detailed_image_input?
       return cache_write_missing? if component == :cache_write && repriced_cache_writes?
-      return false if component == :thinking && !thinking_priced_separately?
 
-      tokens_for(component).to_i.positive? && price_for(component).nil?
+      tokens_for(component).to_f.positive? && price_for(component).nil?
     end
 
     def amount_for(component)
@@ -213,8 +240,6 @@ module RubyLLM
 
       token_count = tokens_for(component)
       return nil if token_count.nil?
-
-      token_count = token_count.to_i
       return 0.0 if token_count.zero?
 
       price = price_for(component)
@@ -237,6 +262,8 @@ module RubyLLM
         @tokens.cache_write
       when :thinking
         @tokens.thinking if thinking_priced_separately?
+      when *UNITS
+        @tokens.public_send(component) if @tokens.respond_to?(component)
       end
     end
 
@@ -247,9 +274,18 @@ module RubyLLM
       when :cache_read then text_price(:cache_read_input_per_million, text_pricing.cache_read_input)
       when :cache_write then text_price(:cache_write_input_per_million, text_pricing.cache_write_input)
       when :thinking then text_price(:reasoning_output_per_million, text_pricing.reasoning_output)
+      when *UNITS then unit_price(component)
       end
     end
 
+    def unit_price(unit)
+      pricing = @model&.pricing
+      return unless pricing
+
+      category = pricing.public_send(unit)
+      @tier == :batch ? category.batch&.input_per_million : category.input
+    end
+
     def input_price
       return text_input_price if @category == :text_tokens || image_cost?
 
@@ -257,7 +293,6 @@ module RubyLLM
     end
 
     def output_price
-      return image_pricing.output || text_output_price if image_cost?
       return text_output_price if @category == :text_tokens
 
       category_pricing.output || text_output_price
@@ -272,13 +307,9 @@ module RubyLLM
     end
 
     def text_price(attribute, standard_price)
-      applicable_text_tier&.public_send(attribute) || standard_price
-    end
-
-    def applicable_text_tier
-      return text_pricing.batch if @tier == :batch
+      return text_pricing.batch&.public_send(attribute) if @tier == :batch
 
-      text_pricing.tier_for(prompt_tokens)
+      text_pricing.tier_for(prompt_tokens)&.public_send(attribute) || standard_price
     end
 
     def prompt_tokens
@@ -294,7 +325,6 @@ module RubyLLM
     end
 
     def category_pricing
-      return text_pricing if @category == :text_tokens
       return image_pricing if image_cost?
 
       pricing = @model&.pricing
@@ -365,7 +395,6 @@ module RubyLLM
     end
 
     def image_input_parts
-      text_input_price = applicable_text_tier&.input_per_million || text_pricing.input
       [
         [:text, input_detail('text_tokens'), text_input_price],
         [:image, input_detail('image_tokens'), image_pricing.input || text_input_price]
@@ -377,12 +406,10 @@ module RubyLLM
     end
 
     def thinking_priced_separately?
-      tier = applicable_text_tier
-      reasoning_price = tier&.reasoning_output_per_million || text_pricing.reasoning_output
+      reasoning_price = price_for(:thinking)
       return false unless reasoning_price
 
-      output_price = tier&.output_per_million || text_pricing.output
-      output_price.nil? || reasoning_price != output_price
+      text_output_price.nil? || reasoning_price != text_output_price
     end
 
     def normalize_model(model)

data/lib/ruby_llm/downloaded_file.rb

@@ -9,19 +9,20 @@ module RubyLLM
   #
   class DownloadedFile < String
     include Support::Inspectable
+    include Files::Saving
 
-    # Returns the raw file bytes as a String.
-    def to_blob
-      to_s
-    end
-
+    ##
+    # :method: save
+    # :call-seq:
+    #   save(path)
+    #
     # Writes the file bytes to +path+, expanding it first. Returns +path+.
     #
     #   file.save("report.pdf")
-    #
-    def save(path)
-      File.binwrite(File.expand_path(path), to_blob)
-      path
+
+    # Returns the raw file bytes as a String.
+    def to_blob
+      to_s
     end
 
     private

data/lib/ruby_llm/embedding.rb

@@ -5,7 +5,7 @@ module RubyLLM
   # RubyLLM.embed returns one:
   #
   #   embedding = RubyLLM.embed("Ruby is a programmer's best friend")
-  #   embedding.vectors # => [0.018, -0.027, ...]
+  #   embedding.vector # => [0.018, -0.027, ...]
   #
   # Pass an array to embed several texts in one call on supported models:
   #
@@ -17,6 +17,7 @@ module RubyLLM
   class Embedding
     include Support::Inspectable
     include Accounting::Usage::Result
+    include Accounting::Usage::ModelInfo
 
     # The embedding vectors. A flat array of floats when a single text
     # was embedded, an array of such arrays when an array of texts was
@@ -32,6 +33,18 @@ module RubyLLM
     # The id of the model that produced the vectors, as a String.
     attr_reader :model
 
+    # Returns the only vector of this result. Raises Error when it holds
+    # several, one for each text of an array, so read #vectors instead.
+    #
+    #   RubyLLM.embed("Ruby").vector # => [0.018, -0.027, ...]
+    #
+    def vector
+      return vectors if !vectors.is_a?(Array) || vectors.all?(Numeric)
+      return vectors.first if vectors.size == 1
+
+      raise Error, "This embedding holds #{vectors.size} vectors; read them with #vectors"
+    end
+
     def initialize(vectors:, model:, sparse_vectors: nil, input_tokens: nil, reported_cost: nil) # :nodoc:
       @vectors = vectors
       @sparse_vectors = sparse_vectors
@@ -54,14 +67,6 @@ module RubyLLM
       Cost.new(tokens:, model: model_info, category: :embeddings)
     end
 
-    attr_writer :model_info # :nodoc:
-
-    def model_info # :nodoc:
-      @model_info ||= RubyLLM.models.find(model)
-    rescue ModelNotFoundError
-      nil
-    end
-
     # Generates embeddings for +text+ and returns an Embedding. +text+
     # may be a single string or, on supported models, an array of strings.
     # An array produces one vector per string in a single API call.
@@ -91,7 +96,7 @@ module RubyLLM
     # <tt>"RETRIEVAL_DOCUMENT"</tt>, while Bedrock Cohere takes an input
     # type such as <tt>"search_document"</tt>. +title:+ labels the
     # document on Vertex AI and Gemini retrieval tasks. Providers that
-    # have no task concept ignore both. +with:+ passes one or more media
+    # cannot carry either raise ArgumentError. +with:+ passes one or more media
     # attachments (images, audio, video, PDFs) to embed alongside the
     # text on multimodal embedding models such as Gemini's
     # gemini-embedding-2; providers without multimodal embeddings raise
@@ -100,7 +105,7 @@ module RubyLLM
     # request as-is. +metadata:+ is not sent to the provider; it is
     # attached to the emitted +embedding.ruby_llm+ instrumentation event.
     # +owner:+ attributes the usage to a record, such as a user, and wins
-    # over RubyLLM.with_usage_owner.
+    # over RubyLLM.with_owner.
     def self.embed(text,
                    model: nil,
                    provider: nil,
@@ -113,40 +118,20 @@ module RubyLLM
                    provider_options: {},
                    metadata: nil,
                    owner: nil)
-      config = context&.config || RubyLLM.config
-      model ||= config.default_embedding_model
-      model, provider_instance = Models.resolve(model, provider: provider, assume_model_exists: assume_model_exists,
-                                                       config: config)
-      model_id = model.id
-      empty_tokens = Tokens.new
-
-      payload = {
-        provider: provider_instance.slug,
-        provider_class: provider_instance.name,
-        model: model_id,
-        model_info: model,
-        input: text,
-        dimensions: dimensions,
-        task_type: task_type,
-        title: title,
-        attachment_count: Attachment.wrap(with).size,
-        provider_options: provider_options,
-        metadata: metadata,
-        tokens: empty_tokens,
-        cost: Cost.new(tokens: empty_tokens, model:, category: :embeddings)
-      }
-
-      RubyLLM.instrument('embedding.ruby_llm', payload, config: config) do |event|
-        result = Accounting::Usage.owned_by(owner) do
-          provider_instance.embed(text, model:, dimensions:, task_type:, title:, with:, provider_options:)
-        end
-        event[:result] = result
-        event[:response_model] = result.model
-        event[:tokens] = result.tokens
-        event[:cost] = result.cost
-        event[:embedding_dimensions] = vector_dimensions(result.vectors)
-        event[:embedding_count] = embedding_count(result.vectors)
-        result
+      Accounting::Operation.new(
+        'embedding', model, default: :default_embedding_model, category: :embeddings, provider:, assume_model_exists:,
+                            context:, owner:,
+                            report: lambda { |event, result|
+                              event[:result] = result
+                              event[:response_model] = result.model
+                              event[:tokens] = result.tokens
+                              event[:cost] = result.cost
+                              event[:embedding_dimensions] = vector_dimensions(result.vectors)
+                              event[:embedding_count] = embedding_count(result.vectors)
+                            }
+      ).run(input: text, dimensions:, task_type:, title:, attachment_count: Attachment.wrap(with).size,
+            provider_options:, metadata:) do |provider_instance, model|
+        provider_instance.embed(text, model:, dimensions:, task_type:, title:, with:, provider_options:)
       end
     end
 

data/lib/ruby_llm/embedding_request.rb

@@ -10,7 +10,7 @@ module RubyLLM
   #   batch = RubyLLM.batch(requests)
   #   # later, once batch.refresh.complete?
   #   batch.results
-  #   requests.first.result.vectors
+  #   requests.first.result.vector
   #
   class EmbeddingRequest
     include Support::Inspectable