Skip to content

A platform for community discussion. Free, open, simple.

2.4 KB
Raw Blame
# frozen_string_literal: true

module DiscourseAi
  module Completions
    class TokenUsageTracker
      def initialize(base_total: nil, base_request: nil, base_response: nil, base_preparation: 0)
        @mutex = Mutex.new
        @preparation_tokens = base_preparation.to_i
        if base_request.nil? && base_response.nil?
          total = base_total.to_i
          initial_request = total / 2
          @request = initial_request
          @response = total - initial_request
        else
          if !base_total.nil?
            raise ArgumentError, "base_total cannot be combined with base_request/base_response"
          end
          if base_request.nil? || base_response.nil?
            raise ArgumentError, "base_request and base_response must both be provided"
          end

          @request = base_request.to_i
          @response = base_response.to_i
        end
      end

      def add_from_audit_log(log, preparation: false)
        # request_tokens = non-cached input (already excludes cached)
        # cache_write_tokens = newly cached (full cost)
        # cache_read_tokens = served from cache (1/10 cost)
        request =
          log.request_tokens.to_i + log.cache_write_tokens.to_i +
            (log.cache_read_tokens.to_i * 0.1).to_i
        response = log.response_tokens.to_i

        request = estimate_tokens(raw_payload(log, :raw_request_payload)) if request <= 0
        response = estimate_tokens(raw_payload(log, :raw_response_payload)) if response <= 0

        add_effective(request: request, response: response, preparation: preparation)
      end

      def raw_payload(log, name)
        log.public_send(name) if log.respond_to?(name)
      end

      def estimate_tokens(payload)
        return 0 if payload.blank?

        (payload.to_s.bytesize / 3.0).ceil
      end

      def add_effective(request:, response:, preparation: false)
        @mutex.synchronize do
          @request += request.to_i
          @response += response.to_i
          @preparation_tokens += request.to_i + response.to_i if preparation
        end
      end

      def request
        @mutex.synchronize { @request }
      end

      def response
        @mutex.synchronize { @response }
      end

      def preparation_tokens
        @mutex.synchronize { @preparation_tokens }
      end

      def total
        @mutex.synchronize { @request + @response }
      end
    end
  end
end