truffler 0.1.0

data/lib/truffler/clients/base.rb

@@ -0,0 +1,49 @@
+module Truffler
+  module Clients
+    # Every adapter answers `ask(state:, questions:, model:, priority:)` with
+    # Truffler::Answers. Subclasses implement `perform(state:, questions:,
+    # model:)`, returning the parsed TypeSafe body: {"answers", "model",
+    # "usage" => {"input_tokens"}}. Only "answers" is required; missing token
+    # counts are estimated from the request size and flagged.
+    class Base
+      def ask(state:, questions:, model: nil, priority: nil)
+        model ||= Truffler.config.model
+        started = Instrumentation.monotonic_ms
+        payload = { priority: priority, question_count: questions.size, model: model }
+
+        response = normalize(perform(state: state, questions: questions, model: model))
+        usage = usage_for(response, state, questions)
+        answers = Answers.new(response["answers"], requested: questions.keys, model: response["model"] || model, usage: usage)
+        payload.merge!(model: answers.model, input_tokens: usage.input_tokens, tokens_estimated: usage.estimated, cost: usage.cost)
+        answers
+      rescue Truffler::Error => error
+        payload[:error_class] = error.class.name
+        raise
+      rescue StandardError => error
+        wrapped = ClientError.from(error)
+        payload.merge!(error_class: wrapped.error_class, status: wrapped.status)
+        raise wrapped, cause: nil
+      ensure
+        Instrumentation.instrument(:jev_call, payload.merge(latency_ms: Instrumentation.monotonic_ms - started))
+      end
+
+      def perform(state:, questions:, model:)
+        raise NotImplementedError, "#{self.class.name}#perform"
+      end
+
+      private
+
+      def normalize(response)
+        response = response.to_h.deep_stringify_keys
+        response.key?("answers") ? response : { "answers" => response }
+      end
+
+      def usage_for(response, state, questions)
+        tokens = response.dig("usage", "input_tokens")
+        return Usage.new(input_tokens: tokens.to_i, estimated: false) if tokens
+
+        Usage.new(input_tokens: Tokens.estimate({ state: state, questions: questions }), estimated: true)
+      end
+    end
+  end
+end

data/lib/truffler/clients/callable.rb

@@ -0,0 +1,26 @@
+module Truffler
+  module Clients
+    # Wraps a host client that responds to `evaluate(state:, schema:)`, such as
+    # Cora's TypeSafeClient. The schema is the question hash in wire shape. The
+    # pinned model is passed only when the host's method accepts `model:`.
+    class Callable < Base
+      def initialize(host)
+        @host = host
+      end
+
+      def perform(state:, questions:, model:)
+        if accepts_model?
+          @host.evaluate(state: state, schema: questions, model: model)
+        else
+          @host.evaluate(state: state, schema: questions)
+        end
+      end
+
+      private
+
+      def accepts_model?
+        @host.method(:evaluate).parameters.any? { |kind, name| name == :model || kind == :keyrest }
+      end
+    end
+  end
+end

data/lib/truffler/clients/cassette.rb

@@ -0,0 +1,44 @@
+require "fileutils"
+
+module Truffler
+  module Clients
+    # Records or replays any adapter's responses, keyed by the SHA-256 of the
+    # canonical request JSON ({model, state, questions}). A recording stores
+    # only the answers, the answering model, and usage, never the request.
+    #
+    # Modes: :replay (a miss raises CassetteMiss), :record (always calls the
+    # inner client), :auto (replays hits, records misses).
+    class Cassette < Base
+      MODES = %i[replay record auto].freeze
+
+      def initialize(inner, dir:, mode: :replay)
+        raise ArgumentError, "cassette mode must be one of #{MODES.join(', ')}" unless MODES.include?(mode.to_sym)
+
+        @inner = inner
+        @dir = dir.to_s
+        @mode = mode.to_sym
+      end
+
+      def perform(state:, questions:, model:)
+        hash = Canonical.digest(model: model, state: state, questions: questions)
+        path = File.join(@dir, "#{hash}.json")
+        return JSON.parse(File.read(path)) if @mode != :record && File.exist?(path)
+        raise CassetteMiss, "no recording #{hash} in #{@dir}" if @mode == :replay || @inner.nil?
+
+        record(path, hash, @inner.perform(state: state, questions: questions, model: model))
+      end
+
+      private
+
+      def record(path, hash, response)
+        response = normalize(response)
+        stored = response.slice("answers", "model", "usage").merge("request_hash" => hash)
+        FileUtils.mkdir_p(@dir)
+        temp = "#{path}.#{Process.pid}.tmp"
+        File.write(temp, "#{Canonical.json(stored)}\n")
+        File.rename(temp, path)
+        stored
+      end
+    end
+  end
+end

data/lib/truffler/clients/fake.rb

@@ -0,0 +1,85 @@
+module Truffler
+  module Clients
+    # Deterministic scripted answers for tests and benchmarks. Script by exact
+    # question id or by label suffix (`:spam` matches `r001__spam`):
+    #
+    #   fake.answer(:spam, 0.9)                         # noul probability
+    #   fake.answer(:tone, "angry")                     # choice option
+    #   fake.answer(:tone, { "calm" => 0.2, "angry" => 0.8 })
+    #   fake.answer(:urgency, 2)                        # score level
+    #   fake.answer(:spam) { |tag, state| state.dig("records", tag, "body").include?("$$$") ? 0.9 : 0.1 }
+    #
+    # Unscripted questions answer no, the first option, or the lowest level.
+    class Fake < Base
+      attr_reader :calls
+
+      def initialize(model: nil, &default)
+        @model = model
+        @default = default
+        @scripts = {}
+        @omitted = []
+        @error = nil
+        @calls = []
+      end
+
+      def answer(key, value = nil, &block)
+        @scripts[key.to_s] = block || value
+        self
+      end
+
+      def answer_without(*ids)
+        @omitted = ids.map(&:to_s)
+        self
+      end
+
+      def fail_with(error)
+        @error = error
+        self
+      end
+
+      def perform(state:, questions:, model:)
+        @calls << { state: state, questions: questions, model: model }
+        raise @error if @error
+
+        answers = questions.except(*@omitted).to_h { |id, question| [ id, answer_for(id, question, state) ] }
+        { "answers" => answers, "model" => @model || model }
+      end
+
+      private
+
+      def answer_for(id, question, state)
+        tag, label = Questions.split_id(id)
+        script = @scripts.fetch(id) { @scripts[label] if label }
+        script = @default if script.nil?
+        value = script.respond_to?(:call) ? script.call(tag, state.deep_stringify_keys, id) : script
+        shape(question, value)
+      end
+
+      def shape(question, value)
+        case question["type"]
+        when "noul" then { "type" => "noul", "noul" => value.to_f }
+        when "choice" then choice(question["criteria"].keys, value)
+        when "score" then score(question["criteria"].size, value.to_f)
+        end
+      end
+
+      def choice(options, value)
+        probabilities = options.to_h { |option| [ option, 0.0 ] }
+        case value
+        when Hash then probabilities.merge!(value.transform_keys(&:to_s).transform_values(&:to_f))
+        when nil then probabilities[options.first] = 1.0
+        else probabilities[value.to_s] = 1.0
+        end
+        pick, confidence = probabilities.max_by { |_, probability| probability }
+        { "type" => "choice", "choice" => pick, "probabilities" => probabilities, "confidence" => confidence }
+      end
+
+      def score(levels, level)
+        legend = Array.new(levels) { |index| [ index.to_s, index.to_s ] }.to_h
+        probabilities = legend.keys.to_h { |key| [ key, key.to_i == level.round ? 1.0 : 0.0 ] }
+        { "type" => "score", "score" => level, "legend" => legend, "probabilities" => probabilities,
+          "confidence" => 1.0 }
+      end
+    end
+  end
+end

data/lib/truffler/clients/ruby_llm_typesafe.rb

@@ -0,0 +1,32 @@
+require "ruby_llm"
+require "ruby_llm-typesafe"
+
+module Truffler
+  module Clients
+    # The default adapter: TypeSafe through RubyLLM 2 and ruby_llm-typesafe.
+    # Neither gem is a truffler dependency; this file loads only when the
+    # adapter is selected.
+    class RubyLLMTypeSafe < Base
+      def perform(state:, questions:, model:)
+        message = chat(model: model, provider: :typesafe).with_schema(schema_for(questions)).ask(JSON.generate(state))
+        { "answers" => message.parsed, "model" => message.model, "usage" => { "input_tokens" => message.tokens&.input } }
+      end
+
+      private
+
+      def chat(**options)
+        RubyLLM.chat(**options)
+      end
+
+      def schema_for(questions)
+        RubyLLM::Providers::TypeSafe::Schema.new do |schema|
+          questions.each do |id, question|
+            options = { instructions: question["instructions"] }
+            options[:criteria] = question["criteria"] if question.key?("criteria")
+            schema.public_send(question["type"], id, **options)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/truffler/configuration.rb

@@ -0,0 +1,89 @@
+module Truffler
+  class Configuration
+    DEFAULT_REQUESTS_PER_MINUTE = 1_200
+    DEFAULT_PRIORITY_CEILINGS = { live: 1.0, encode: 0.9, rerank: 0.75, backfill: 0.5 }.freeze
+    DEFAULT_USER_CAPS = { encode: 30, rerank: 10 }.freeze
+
+    attr_accessor :model, :cost_per_million_tokens, :requests_per_minute, :headroom, :priority_ceilings,
+      :user_caps, :tenant_live_cap, :max_wait, :batch_size, :grouping_window, :max_attempts,
+      :max_field_chars, :request_token_budget, :max_questions_per_request, :queue_name,
+      :embedder, :encryptor, :backfill_spend_cap, :resume_pending_after
+    attr_writer :client, :cache_store, :logger
+    attr_accessor :miss_retention, :miss_min_distinct_users
+    attr_writer :secret_key_base
+    attr_accessor :vector_store, :embedding_cost_per_million_tokens
+    attr_accessor :encoding_prefetch
+    attr_reader :lenses
+    attr_accessor :encoding_deadline, :rerank_depth, :rerank_chunk_size, :rerank_max_field_chars, :smart_thresholds,
+      :smart_run_ttl, :smart_candidate_pool, :broadcaster
+
+    def initialize(env: ENV)
+      @model = "jev-latest"
+      @cost_per_million_tokens = 0.042
+      @requests_per_minute = Integer(env["TYPESAFE_REQUESTS_PER_MINUTE"].presence || DEFAULT_REQUESTS_PER_MINUTE)
+      @headroom = 0.25
+      @priority_ceilings = DEFAULT_PRIORITY_CEILINGS.dup
+      @user_caps = DEFAULT_USER_CAPS.dup
+      @tenant_live_cap = 120
+      @max_wait = 5.0
+      @batch_size = 10
+      @grouping_window = 0
+      @max_attempts = 5
+      @max_field_chars = 4_000
+      @request_token_budget = 48_000
+      @max_questions_per_request = 200
+      @queue_name = :default
+      @miss_retention = 30.days
+      @miss_min_distinct_users = 5
+      @backfill_spend_cap = nil
+      @resume_pending_after = 5.minutes
+      @vector_store = :auto
+      @embedding_cost_per_million_tokens = 0.02
+      @lenses = Lenses::Settings.new
+      @encoding_prefetch = QueryEncoding::Prefetch.new
+      @encoding_deadline = 1.0
+      @rerank_depth = 30
+      @rerank_chunk_size = 10
+      @rerank_max_field_chars = 1_200
+      @smart_thresholds = { strong: 0.70, possible: 0.35 }
+      @smart_run_ttl = 15.minutes
+      @smart_candidate_pool = 200
+      @broadcaster = nil
+    end
+
+    def client
+      @client ||= Clients::RubyLLMTypeSafe.new
+    end
+
+    def cache_store
+      @cache_store || rails_cache || (@fallback_cache ||= ActiveSupport::Cache::MemoryStore.new)
+    end
+
+    def logger
+      @logger || rails_logger || (@fallback_logger ||= ActiveSupport::Logger.new(nil))
+    end
+
+    def cost_for(tokens)
+      tokens.to_i * cost_per_million_tokens / 1_000_000.0
+    end
+
+    def secret_key_base
+      @secret_key_base.presence || rails_secret_key_base.presence ||
+        raise(Error, "Truffler needs config.secret_key_base (or a Rails secret_key_base) to digest query misses")
+    end
+
+    private
+
+    def rails_cache
+      Rails.cache if defined?(Rails) && Rails.respond_to?(:cache)
+    end
+
+    def rails_logger
+      Rails.logger if defined?(Rails) && Rails.respond_to?(:logger)
+    end
+
+    def rails_secret_key_base
+      Rails.application&.secret_key_base if defined?(Rails) && Rails.respond_to?(:application)
+    end
+  end
+end

data/lib/truffler/definition.rb

@@ -0,0 +1,176 @@
+module Truffler
+  # Everything a model declares in its `truffler do ... end` block.
+  class Definition
+    EXPLICIT_ACTIONS = %i[enter key row].freeze
+    DEFAULT_EMBEDDINGS = { model: "text-embedding-3-small", dimensions: 256 }.freeze
+
+    attr_reader :model, :fields, :labels, :exact_sources, :providers, :surfaces
+    attr_accessor :tenant_column, :keyword, :embeddings, :order, :arrived_at_column
+
+    def initialize(model)
+      @model = model
+      @fields = []
+      @labels = {}
+      @exact_sources = {}
+      @providers = {}
+      @surfaces = {}
+      @arrived_at_column = "created_at"
+    end
+
+    def add_label(label)
+      raise DefinitionError, "label #{label.key} is declared twice" if labels.key?(label.key)
+
+      labels[label.key] = label
+    end
+
+    def label(key)
+      labels.fetch(key.to_s)
+    end
+
+    def label_keys
+      labels.keys
+    end
+
+    def scoped?
+      tenant_column.present?
+    end
+
+    def supplied_labels
+      labels.values.select(&:supplied?)
+    end
+
+    def per_tenant_vocabulary?
+      labels.each_value.any?(&:per_tenant?)
+    end
+
+    def vocabulary
+      Vocabulary.new(self)
+    end
+
+    def tenant_key_for(record)
+      record.public_send(tenant_column)&.to_s if scoped?
+    end
+
+    def field_values(record)
+      fields.index_with { |field| record.public_send(field) }
+    end
+
+    # Field values as Jev request state: strings cut to max_chars so one long
+    # record cannot crowd out a batch, everything else as JSON.
+    def request_fields(record, max_chars:)
+      field_values(record).transform_values { |value| value.is_a?(String) ? value[0, max_chars] : value.as_json }
+    end
+
+    # Newest first: by arrival when the table has that column, then by primary key.
+    def arrival_order
+      order = model.column_names.include?(arrived_at_column) ? { arrived_at_column => :desc } : {}
+      order.merge(model.primary_key => :desc)
+    end
+
+    def encrypted_fields
+      Array(model.try(:encrypted_attributes)).map(&:to_s) & fields
+    end
+
+    def validate!
+      raise DefinitionError, "#{model.name}: declare the fields Jev reads with `reads`" if fields.empty?
+
+      check_columns([ tenant_column, *fields, *Array(keyword).grep(String), *supplied_labels.flat_map(&:watch) ].compact.uniq)
+      check_embeddings if embeddings
+    end
+
+    DEFAULT_RANKING = { label: 1.0, text: 1.0, keyword: 0.5, exact: 1.0, min_similarity: 0.0 }.freeze
+    DEFAULT_WEAK_BELOW = 3
+
+    attr_writer :ranking, :weak_below
+
+    # KTD20 blend weights for keystroke scoring, tuned by the benchmark (R36).
+    def ranking
+      DEFAULT_RANKING.merge(@ranking || {})
+    end
+
+    # Fewer keystroke results than this count as weak (R19, R21).
+    def weak_below
+      @weak_below || DEFAULT_WEAK_BELOW
+    end
+
+    private
+
+    def check_columns(names)
+      columns = model.attribute_names
+      missing = names.reject { |name| columns.include?(name) || model.method_defined?(name) }
+      raise DefinitionError, "#{model.name}: unknown attributes #{missing.join(', ')}" if missing.any?
+    rescue ActiveRecord::ActiveRecordError
+      nil
+    end
+
+    def check_embeddings
+      return if embeddings.key?(:column) || embeddings[:allow_encrypted] || encrypted_fields.empty?
+
+      raise DefinitionError, "#{model.name}: embeddings would send encrypted fields #{encrypted_fields.join(', ')} " \
+        "to the embedding provider; pass allow_encrypted: true to opt in"
+    end
+
+    # The block API inside `truffler do ... end`.
+    class DSL
+      def initialize(definition)
+        @definition = definition
+      end
+
+      def tenant(column)
+        @definition.tenant_column = column.to_s
+      end
+
+      def reads(*fields)
+        @definition.fields.concat(fields.map(&:to_s))
+      end
+
+      def label(key, type, **options)
+        @definition.add_label(LabelDefinition.new(key, type, **options))
+      end
+
+      def keyword(*columns_or_callable)
+        callable = columns_or_callable.first if columns_or_callable.one? && columns_or_callable.first.respond_to?(:call)
+        @definition.keyword = callable || columns_or_callable.map(&:to_s)
+      end
+
+      def exact(name, callable)
+        @definition.exact_sources[name.to_s] = callable
+      end
+
+      def embeddings(column: nil, **options)
+        @definition.embeddings = column ? { column: column.to_s } : DEFAULT_EMBEDDINGS.merge(options)
+      end
+
+      def provider(name, label:, search:)
+        @definition.providers[name.to_s] = { label: label, search: search }
+      end
+
+      def order(column, direction = :desc)
+        @definition.order = [ column.to_s, direction.to_sym ]
+      end
+
+      def surface(name, explicit_action: :enter)
+        unless EXPLICIT_ACTIONS.include?(explicit_action)
+          raise DefinitionError, "surface #{name}: explicit_action must be one of #{EXPLICIT_ACTIONS.join(', ')}"
+        end
+
+        @definition.surfaces[name.to_s] = { explicit_action: explicit_action }
+      end
+
+      def arrived_at(column)
+        @definition.arrived_at_column = column.to_s
+      end
+
+      def ranking(**weights)
+        unknown = weights.keys - DEFAULT_RANKING.keys
+        raise DefinitionError, "ranking: unknown weights #{unknown.join(', ')}" if unknown.any?
+
+        @definition.ranking = weights.transform_values { |weight| Float(weight) }
+      end
+
+      def weak_below(count)
+        @definition.weak_below = Integer(count)
+      end
+    end
+  end
+end

data/lib/truffler/embeddings/backfill.rb

@@ -0,0 +1,48 @@
+module Truffler
+  module Embeddings
+    # Finds records whose embedding is missing or was made under another
+    # fingerprint (model, width, or fields changed) and enqueues EmbedJob for
+    # them, newest first, `batch_size` jobs at a time behind an id cursor.
+    # ResumeJob runs a bounded pass on every sweep; hosts call `enqueue` with
+    # no limit after enabling embeddings or changing the model, width, or
+    # fields.
+    class Backfill
+      BATCH_SIZE = 1_000
+
+      attr_reader :model
+
+      def initialize(model)
+        @model = model
+      end
+
+      def stale_ids(limit: nil, before: nil)
+        definition = model.truffler_definition
+        return [] unless Embeddings.managed?(definition)
+
+        current = Records::RecordState.for_model(model).where(embedding_fingerprint: Embeddings.fingerprint(definition))
+          .where.not(embedded_at: nil).select(:record_id)
+        scope = model.where.not(model.primary_key => current)
+        scope = scope.where(model.primary_key => ...before) if before
+        scope.order(model.primary_key => :desc).limit(limit).pluck(model.primary_key)
+      end
+
+      def enqueue(limit: nil, batch_size: BATCH_SIZE)
+        count = 0
+        cursor = nil
+        loop do
+          take = limit ? [ batch_size, limit - count ].min : batch_size
+          break unless take.positive?
+
+          ids = stale_ids(limit: take, before: cursor)
+          break if ids.empty?
+
+          ActiveJob.perform_all_later(ids.map { |id| Jobs::EmbedJob.new(model.polymorphic_name, id) })
+          count += ids.size
+          cursor = ids.last
+          break if ids.size < take
+        end
+        count
+      end
+    end
+  end
+end

data/lib/truffler/embeddings/column_store.rb

@@ -0,0 +1,65 @@
+module Truffler
+  module Embeddings
+    # Searches a vector column the host already maintains (R11). The gem never
+    # writes it and never calls the embedder for it. Similarity runs in SQL
+    # when the column is pgvector or sqlite-vec is loaded, and otherwise as
+    # exact cosine in Ruby over the tenant's rows (arrays, JSON text, or
+    # float32 blobs).
+    class ColumnStore < VectorStore
+      attr_reader :column
+
+      def initialize(column)
+        @column = column.to_s
+      end
+
+      def write(model, *)
+        raise Error, "#{model.name} searches its own #{column} column; truffler does not write it"
+      end
+
+      def nearest(model, tenant_key:, vector:, k: DEFAULT_K)
+        scope = records(model, tenant_key)
+        if (dialect = dialect(model))
+          distance = NeighborStore.distance_sql(dialect, model.connection, column_sql(model), vector)
+          scope.order(Arel.sql(distance)).limit(k).pluck(model.primary_key, Arel.sql("1 - #{distance}"))
+            .map { |id, similarity| [ id, similarity.to_f ] }
+        else
+          scope.pluck(model.primary_key, column).filter_map do |id, value|
+            stored = Records::Embedding.unpack(value)
+            [ id, self.class.cosine(vector, stored) ] if stored.size == vector.size
+          end.max_by(k) { |_, similarity| similarity }
+        end
+      end
+
+      def similarity_sql(model, tenant_key:, vector:, k: DEFAULT_K)
+        dialect = dialect(model)
+        return super unless dialect
+
+        check_tenant!(model, tenant_key)
+        Arel.sql("COALESCE(1 - #{NeighborStore.distance_sql(dialect, model.connection, column_sql(model), vector)}, 0.0)")
+      end
+
+      def inline_sql?(model)
+        !dialect(model).nil?
+      end
+
+      private
+
+      def records(model, tenant_key)
+        check_tenant!(model, tenant_key)
+        definition = model.truffler_definition
+        scope = model.where.not(column => nil)
+        definition.scoped? ? scope.where(definition.tenant_column => tenant_key) : scope
+      end
+
+      def dialect(model)
+        return @dialect if defined?(@dialect)
+
+        @dialect = NeighborStore.dialect(model.connection, table: model.table_name, column: column)
+      end
+
+      def column_sql(model)
+        "#{model.connection.quote_table_name(model.table_name)}.#{model.connection.quote_column_name(column)}"
+      end
+    end
+  end
+end

data/lib/truffler/embeddings/embedder.rb

@@ -0,0 +1,53 @@
+module Truffler
+  module Embeddings
+    # The embedder seam. `embed(texts, model:, dimensions:)` returns one vector
+    # per text plus usage, and emits `truffler.embed_call` with tokens, cost,
+    # and latency but never the texts. Subclasses implement `perform`,
+    # returning {vectors:, model:, input_tokens:}; a missing token count is
+    # estimated and flagged.
+    class Embedder
+      Result = Data.define(:vectors, :model, :input_tokens, :tokens_estimated, :cost)
+
+      def embed(texts, model:, dimensions:)
+        texts = Array(texts)
+        started = Instrumentation.monotonic_ms
+        payload = { model: model, record_count: texts.size }
+
+        response = perform(texts, model: model, dimensions: dimensions)
+        result = result_for(response, texts, model)
+        payload.merge!(model: result.model, input_tokens: result.input_tokens, tokens_estimated: result.tokens_estimated,
+          cost: result.cost)
+        result
+      rescue Truffler::Error => error
+        payload[:error_class] = error.class.name
+        raise
+      rescue StandardError => error
+        wrapped = ClientError.from(error)
+        payload.merge!(error_class: wrapped.error_class, status: wrapped.status)
+        raise wrapped, cause: nil
+      ensure
+        Instrumentation.instrument(:embed_call, payload.merge(latency_ms: Instrumentation.monotonic_ms - started))
+      end
+
+      def perform(texts, model:, dimensions:)
+        raise NotImplementedError, "#{self.class.name}#perform"
+      end
+
+      private
+
+      def result_for(response, texts, model)
+        vectors = response.fetch(:vectors)
+        unless vectors.size == texts.size
+          raise IncompleteAnswers, "embedder returned #{vectors.size} vectors for #{texts.size} texts"
+        end
+
+        tokens = response[:input_tokens]
+        estimated = tokens.nil?
+        tokens = estimated ? texts.sum { |text| Tokens.estimate(text) } : tokens.to_i
+        cost = tokens * Truffler.config.embedding_cost_per_million_tokens / 1_000_000.0
+        Result.new(vectors: vectors.map { |vector| vector.map(&:to_f) }, model: response[:model] || model,
+          input_tokens: tokens, tokens_estimated: estimated, cost: cost)
+      end
+    end
+  end
+end