llm_cost_tracker 0.10.0 → 0.12.0

data/lib/llm_cost_tracker/providers/openai/service_charges.rb

@@ -0,0 +1,181 @@
+# frozen_string_literal: true
+
+require_relative "model_families"
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module ServiceCharges
+        RESPONSE_OUTPUT_RENAMES = {
+          "web_search_call" => "web_search_request",
+          "code_interpreter_call" => "container_session"
+        }.freeze
+
+        module_function
+
+        def line_items_from_output(output_items, request: nil, model: nil)
+          deduped = {}
+          Array(output_items).each { |item| store_output_item(deduped, item) }
+          deduped.values
+                 .select { |item| billable?(item) }
+                 .filter_map { |item| build_line_item(item, request: request, model: model) }
+        end
+
+        def service_line_items_for(response, request: nil, model: nil)
+          output_items = Array(response["output"])
+          output_items += chat_completions_web_search_items(response, model: model) if output_items.empty?
+          line_items_from_output(output_items, request: request, model: model)
+        end
+
+        CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD = "choices.message.annotations.url_citation"
+        CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD = "request.model"
+
+        def chat_completions_web_search_items(response, model: nil)
+          return [] unless response["choices"]
+
+          provider_field = chat_completions_search_provider_field(response["choices"], model)
+          return [] unless provider_field
+
+          [{ "type" => "web_search_call", "id" => response["id"], "action" => { "type" => "search" },
+             "provider_field" => provider_field }]
+        end
+
+        def chat_completions_search_provider_field(choices, model)
+          return CHAT_COMPLETIONS_ANNOTATION_PROVIDER_FIELD if chat_completions_used_web_search?(choices)
+          return CHAT_COMPLETIONS_SEARCH_MODEL_PROVIDER_FIELD if chat_completions_search_model?(model)
+
+          nil
+        end
+
+        def chat_completions_used_web_search?(choices)
+          Array(choices).any? do |choice|
+            Array(choice.dig("message", "annotations")).any? do |annotation|
+              annotation.is_a?(Hash) && annotation["type"].to_s == "url_citation"
+            end
+          end
+        end
+
+        def billable?(item)
+          return false unless item.is_a?(Hash)
+
+          dimension = output_dimension(item["type"])
+          return false unless dimension
+          return true unless dimension == "web_search_request"
+
+          action_type = item.dig("action", "type")
+          action_type.nil? || action_type == "search"
+        end
+
+        def store_output_item(output_items, item)
+          return unless item.is_a?(Hash)
+
+          dimension = output_dimension(item["type"])
+          return unless dimension
+
+          key = if dimension == "container_session" && item["container_id"]
+                  "#{dimension}:#{item['container_id']}"
+                else
+                  item["id"] || "#{item['type']}:#{output_items.length}"
+                end
+          output_items[key] = item
+        end
+
+        def build_line_item(item, request: nil, model: nil)
+          return nil unless item.is_a?(Hash)
+
+          dimension_key = dimension_key_for(item, request: request, model: model)
+          return nil unless dimension_key
+
+          provider_item_id = if dimension_key == "container_session"
+                               item["container_id"] || item["id"]
+                             else
+                               item["id"]
+                             end
+          Charges::LineItem.build(
+            dimension_key: dimension_key,
+            quantity: 1,
+            cost_status: Charges::CostStatus::UNKNOWN,
+            pricing_basis: "provider_usage",
+            provider_field: item["provider_field"] || "response.output.#{item['type']}",
+            provider_item_id: provider_item_id,
+            details: line_item_details(item)
+          )
+        end
+
+        def dimension_key_for(item, request:, model:)
+          dimension = output_dimension(item["type"])
+          return dimension unless dimension == "web_search_request"
+          return dimension unless web_search_preview_used?(request) || chat_completions_search_model?(model)
+
+          reasoning_model?(model) ? "web_search_preview_request_reasoning" : "web_search_preview_request_non_reasoning"
+        end
+
+        def output_dimension(type)
+          key = RESPONSE_OUTPUT_RENAMES[type] || type
+          dimension = Usage::Catalog[key]
+          key if dimension && dimension.token_key.nil?
+        end
+
+        def web_search_preview_used?(request)
+          tools = request && (request[:tools] || request["tools"])
+          Array(tools).any? do |tool|
+            type = tool.is_a?(Hash) ? (tool[:type] || tool["type"]) : tool
+            type.to_s.include?("web_search_preview")
+          end
+        end
+
+        def chat_completions_search_model?(model)
+          name = local_model_name(model)
+          name && ModelFamilies.chat_completions_search?(name)
+        end
+
+        def reasoning_model?(model)
+          name = local_model_name(model)
+          name && ModelFamilies.reasoning?(name)
+        end
+
+        def local_model_name(model)
+          return nil unless model
+
+          model.to_s.split("/", 2).last
+        end
+
+        def line_item_details(item)
+          {
+            status: item["status"],
+            action_type: item.dig("action", "type"),
+            container_id: item["container_id"]
+          }.compact
+        end
+
+        def openai_stream_service_line_items(events, request: nil, model: nil)
+          output_items = []
+          each_event_data(events) do |data|
+            output_items.concat(Array(data.dig("response", "output")))
+            output_items << data["item"] if data["item"]
+          end
+          line_items_from_output(output_items, request: request, model: model)
+        end
+
+        def transcription_line_items(usage)
+          return [] unless usage
+
+          type = (usage[:type] || usage["type"]).to_s
+          return [] unless type == "duration"
+
+          seconds = (usage[:seconds] || usage["seconds"]).to_f
+          return [] unless seconds.positive?
+
+          [Charges::LineItem.build(
+            dimension_key: "transcription_minute",
+            quantity: (seconds / 60.0).ceil,
+            cost_status: Charges::CostStatus::UNKNOWN,
+            pricing_basis: "provider_usage",
+            provider_field: "usage.seconds",
+            details: { seconds: seconds }
+          )]
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/openai/usage_extractor.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require_relative "model_families"
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module UsageExtractor
+        INPUT_DETAIL_KEYS = %i[input_tokens_details input_token_details prompt_tokens_details].freeze
+        OUTPUT_DETAIL_KEYS = %i[output_tokens_details output_token_details completion_tokens_details].freeze
+        def self.token_usage(usage, model: nil)
+          input_tokens = (usage[:input_tokens] || usage[:prompt_tokens]).to_i
+          output_tokens = (usage[:output_tokens] || usage[:completion_tokens]).to_i
+          cache_read = cache_read_input_tokens(usage)
+          audio_input = audio_input_tokens(usage)
+          audio_output = audio_output_tokens(usage)
+          image_input = image_input_tokens(usage)
+          image_output, regular_output = split_output(
+            output_tokens: output_tokens,
+            image_output_details: image_output_tokens(usage),
+            text_output_details: text_output_tokens(usage),
+            audio_output: audio_output,
+            default_to_image: ModelFamilies.image_output?(model)
+          )
+
+          Usage::TokenUsage.build(
+            input_tokens: [input_tokens - cache_read - audio_input - image_input, 0].max,
+            output_tokens: regular_output,
+            total_tokens: usage[:total_tokens],
+            cache_read_input_tokens: cache_read,
+            audio_input_tokens: audio_input,
+            audio_output_tokens: audio_output,
+            image_input_tokens: image_input,
+            image_output_tokens: image_output,
+            hidden_output_tokens: hidden_output_tokens(usage)
+          )
+        end
+
+        def self.split_output(output_tokens:,
+                              image_output_details:,
+                              text_output_details:,
+                              audio_output:,
+                              default_to_image: false)
+          if image_output_details.zero? && text_output_details.zero?
+            remainder = [output_tokens - audio_output, 0].max
+            return default_to_image ? [remainder, 0] : [0, remainder]
+          end
+
+          text_output = text_output_details
+          text_output = [output_tokens - image_output_details - audio_output, 0].max if text_output.zero?
+          [image_output_details, text_output]
+        end
+
+        def self.cache_read_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens)
+        def self.hidden_output_tokens(usage)    = detail(usage, OUTPUT_DETAIL_KEYS, :reasoning_tokens)
+        def self.audio_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :audio_tokens)
+        def self.audio_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :audio_tokens)
+        def self.image_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :image_tokens)
+        def self.image_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :image_tokens)
+        def self.text_output_tokens(usage)      = detail(usage, OUTPUT_DETAIL_KEYS, :text_tokens)
+
+        def self.detail(usage, containers, key)
+          containers.each do |container|
+            value = usage.dig(container, key)
+            return value.to_i if value
+          end
+          0
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/openai_compatible/parser.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module OpenaiCompatible
+      class Parser < LlmCostTracker::Parsers::Base
+        include Openai::ResponseParser
+
+        TRACKED_PATH_SUFFIXES = %w[/chat/completions /completions /embeddings /responses].freeze
+
+        class << self
+          def match?(url)
+            match_uri?(url, path_suffixes: TRACKED_PATH_SUFFIXES) { |uri| provider_for_uri(uri) }
+          end
+
+          def provider_names
+            custom = LlmCostTracker.configuration.openai_compatible_providers.each_value.map do |provider|
+              provider.to_s.downcase
+            end
+            ["openai_compatible", *custom].uniq
+          end
+
+          def provider_for_uri(uri)
+            return nil unless uri
+
+            LlmCostTracker.configuration.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
+          end
+        end
+
+        def provider_for(request_url)
+          self.class.provider_for_uri(parsed_uri(request_url)) || "openai_compatible"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers.rb

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      autoload :Parser, "llm_cost_tracker/providers/anthropic/parser"
+      autoload :UsageExtractor, "llm_cost_tracker/providers/anthropic/usage_extractor"
+      autoload :ResponseParser, "llm_cost_tracker/providers/anthropic/response_parser"
+    end
+
+    module Azure
+      autoload :Hosts, "llm_cost_tracker/providers/azure/hosts"
+      autoload :Parser, "llm_cost_tracker/providers/azure/parser"
+    end
+
+    module Gemini
+      autoload :ModelFamilies, "llm_cost_tracker/providers/gemini/model_families"
+      autoload :Parser, "llm_cost_tracker/providers/gemini/parser"
+      autoload :UsageExtractor, "llm_cost_tracker/providers/gemini/usage_extractor"
+    end
+
+    module Openai
+      autoload :Hosts, "llm_cost_tracker/providers/openai/hosts"
+      autoload :ModelFamilies, "llm_cost_tracker/providers/openai/model_families"
+      autoload :Parser, "llm_cost_tracker/providers/openai/parser"
+      autoload :ServiceCharges, "llm_cost_tracker/providers/openai/service_charges"
+      autoload :UsageExtractor, "llm_cost_tracker/providers/openai/usage_extractor"
+      autoload :ResponseParser, "llm_cost_tracker/providers/openai/response_parser"
+    end
+
+    module OpenaiCompatible
+      autoload :Parser, "llm_cost_tracker/providers/openai_compatible/parser"
+    end
+  end
+end

data/lib/llm_cost_tracker/railtie.rb

@@ -13,16 +13,9 @@ module LlmCostTracker
       require_relative "generators/llm_cost_tracker/prices_generator"
       require_relative "generators/llm_cost_tracker/call_rollups_generator"
       require_relative "generators/llm_cost_tracker/async_ingestion_generator"
-      require_relative "generators/llm_cost_tracker/reconciliation_generator"
       require_relative "generators/llm_cost_tracker/upgrade_call_rollups_provider_generator"
       require_relative "generators/llm_cost_tracker/upgrade_image_tokens_generator"
       require_relative "generators/llm_cost_tracker/upgrade_call_tags_key_value_index_generator"
-      require_relative "generators/llm_cost_tracker/upgrade_provider_invoice_imports_provider_generator"
-      require_relative "generators/llm_cost_tracker/upgrade_provider_invoices_metadata_index_generator"
-    end
-
-    rake_tasks do
-      load File.expand_path("../tasks/llm_cost_tracker.rake", __dir__)
     end
   end
 end

data/lib/llm_cost_tracker/report/data.rb

@@ -2,11 +2,11 @@
 
 require "active_support/core_ext/integer/time"
 
-require_relative "../billing/cost_status"
+require_relative "../charges/cost_status"
 require_relative "../ledger"
 
 module LlmCostTracker
-  class Report
+  module Report
     Data = ::Data.define(
       :days,
       :from_time,
@@ -58,8 +58,7 @@ module LlmCostTracker
             "COALESCE(SUM(total_cost), 0) AS total_cost, " \
             "COUNT(*) AS requests_count, " \
             "AVG(latency_ms) AS average_latency_ms, " \
-            "COALESCE(SUM(CASE WHEN total_cost IS NULL " \
-            "OR cost_status IN ('#{Billing::CostStatus::UNKNOWN}', '#{Billing::CostStatus::PARTIAL}') " \
+            "COALESCE(SUM(CASE WHEN #{Charges::CostStatus.unknown_pricing_sql} " \
             "THEN 1 ELSE 0 END), 0) AS unknown_pricing_count"
           )
           .take

data/lib/llm_cost_tracker/report/formatter.rb

@@ -1,21 +1,21 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  class Report
+  module Report
     class Formatter
       TOP_LIMIT = 5
-      NAME_COLUMN_WIDTH = 28
-      TOP_CALL_COLUMN_WIDTH = 32
+      MIN_COLUMN_WIDTH = 28
 
-      def initialize(data)
+      def initialize(data, color: $stdout.tty?)
         @data = data
+        @color = color
       end
 
       def to_s
-        lines = ["LLM Cost Report (last #{@data.days} days)", ""]
+        lines = [bold("LLM Cost Report (last #{@data.days} days)"), ""]
         append_summary(lines)
-        append_cost_section(lines, "By provider", @data.cost_by_provider)
-        append_cost_section(lines, "By model", @data.cost_by_model)
+        append_cost_section(lines, "By provider", @data.cost_by_provider) { |row| row.name.to_s }
+        append_cost_section(lines, "By model", @data.cost_by_model) { |row| row.name.to_s }
         append_tag_sections(lines)
         append_top_calls(lines)
         lines.join("\n")
@@ -27,36 +27,37 @@ module LlmCostTracker
         lines << "Total cost: #{money(@data.total_cost)}"
         lines << "Requests: #{@data.requests_count}"
         lines << "Avg latency: #{average_latency}"
-        lines << "Unknown pricing: #{@data.unknown_pricing_count}"
+        lines << "Unknown pricing: #{colored_unknown_pricing(@data.unknown_pricing_count)}"
       end
 
-      def append_cost_section(lines, title, rows)
+      def append_cost_section(lines, title, rows, &name_for)
         lines << ""
-        lines << "#{title}:"
+        lines << bold("#{title}:")
         return lines << "  none" if rows.empty?
 
-        rows.first(TOP_LIMIT).each do |row|
-          lines << "  #{row.name.to_s.ljust(NAME_COLUMN_WIDTH)} #{money(row.total_cost)}"
+        visible = rows.first(TOP_LIMIT)
+        width = column_width(visible, &name_for)
+        visible.each do |row|
+          lines << "  #{name_for.call(row).ljust(width)} #{money(row.total_cost)}"
         end
       end
 
       def append_tag_sections(lines)
         @data.cost_by_tags.each do |tag_key, rows|
-          append_cost_section(lines, "By tag (#{tag_key})", rows)
+          append_cost_section(lines, "By tag (#{tag_key})", rows) { |row| row.name.to_s }
         end
       end
 
       def append_top_calls(lines)
-        lines << ""
-        lines << "Top expensive calls:"
-        return lines << "  none" if @data.top_calls.empty?
-
-        @data.top_calls.first(TOP_LIMIT).each do |call|
-          label = "#{call.provider}/#{call.model}"
-          lines << "  #{label.ljust(TOP_CALL_COLUMN_WIDTH)} #{money(call.total_cost)}"
+        append_cost_section(lines, "Top expensive calls", @data.top_calls) do |call|
+          "#{call.provider}/#{call.model}"
         end
       end
 
+      def column_width(rows, &name_for)
+        [MIN_COLUMN_WIDTH, rows.map { |row| name_for.call(row).length }.max.to_i].max
+      end
+
       def average_latency
         @data.average_latency_ms ? "#{@data.average_latency_ms.round}ms" : "n/a"
       end
@@ -64,6 +65,18 @@ module LlmCostTracker
       def money(value)
         "$#{format('%.6f', value.to_f)}"
       end
+
+      def colored_unknown_pricing(count)
+        return count.to_s unless @color
+
+        count.to_i.positive? ? "\e[33m#{count}\e[0m" : "\e[32m#{count}\e[0m"
+      end
+
+      def bold(text)
+        return text unless @color
+
+        "\e[1m#{text}\e[0m"
+      end
     end
   end
 end

data/lib/llm_cost_tracker/report.rb

@@ -4,7 +4,7 @@ require_relative "report/data"
 require_relative "report/formatter"
 
 module LlmCostTracker
-  class Report
+  module Report
     class << self
       def generate(days: Data::DEFAULT_DAYS, now: Time.now.utc, tag_breakdowns: nil)
         report_data = Data.build(

data/lib/llm_cost_tracker/retention.rb

@@ -21,17 +21,6 @@ module LlmCostTracker
         deleted
       end
 
-      def prune_invoice_imports(older_than:, now: Time.now.utc)
-        cutoff = resolve_cutoff(older_than, now)
-        require_relative "ledger"
-        return 0 unless LlmCostTracker::ProviderInvoiceImport.table_exists?
-
-        LlmCostTracker::ProviderInvoiceImport
-          .where(state: %w[completed failed])
-          .where(finished_at: ...cutoff)
-          .delete_all
-      end
-
       def prune_inbox(older_than:, now: Time.now.utc)
         cutoff = resolve_cutoff(older_than, now)
         require_relative "ingestion"
@@ -70,23 +59,21 @@ module LlmCostTracker
       def prune_batch(cutoff, batch_size)
         LlmCostTracker::Call.transaction do
           cache_rollups = LlmCostTracker.configuration.cache_rollups
-          rows = pluck_prunable(cutoff, batch_size, with_rollup_columns: cache_rollups)
+          rows = prunable_rows(cutoff, batch_size, with_rollup_columns: cache_rollups)
           next 0 if rows.empty?
 
-          ids = cache_rollups ? rows.map(&:first) : rows
+          ids = cache_rollups ? rows.map(&:id) : rows
           deleted = LlmCostTracker::Call.where(id: ids).delete_all
           LlmCostTracker::Ledger::Rollups.decrement!(rows) if cache_rollups && deleted.positive?
           deleted
         end
       end
 
-      def pluck_prunable(cutoff, batch_size, with_rollup_columns:)
+      def prunable_rows(cutoff, batch_size, with_rollup_columns:)
         relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
-        if with_rollup_columns
-          relation.pluck(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider)
-        else
-          relation.pluck(:id)
-        end
+        return relation.pluck(:id) unless with_rollup_columns
+
+        relation.select(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider).to_a
       end
     end
   end

data/lib/llm_cost_tracker/tags/context.rb

@@ -17,14 +17,17 @@ module LlmCostTracker
         end
 
         def tags
-          default_tags = LlmCostTracker.configuration.default_tags
-          default_tags = default_tags.call if default_tags.respond_to?(:call)
-
-          Sanitizer.call(default_tags.to_h).merge(*Array(ActiveSupport::IsolatedExecutionState[KEY]))
+          config = LlmCostTracker.configuration
+          base = config.static_sanitized_default_tags ||
+                 Sanitizer.call(call_default_tags(config.default_tags).to_h)
+          base.merge(*Array(ActiveSupport::IsolatedExecutionState[KEY]))
         end
 
-        def clear!
-          ActiveSupport::IsolatedExecutionState[KEY] = []
+        def call_default_tags(proc_or_lambda)
+          proc_or_lambda.call
+        rescue StandardError => e
+          Logging.warn("LlmCostTracker default_tags proc raised: #{e.class}: #{e.message}; using empty default tags")
+          {}
         end
       end
     end

data/lib/llm_cost_tracker/tags/sanitizer.rb

@@ -27,10 +27,20 @@ module LlmCostTracker
           limit = [config.max_tag_value_bytesize.to_i, 0].max
           max_count = [config.max_tag_count.to_i, 0].max
           tags.to_a.last(max_count).each_with_object({}) do |(key, value), sanitized|
+            next unless valid_key?(key)
+
             sanitized[key] = sanitized_value(key, value, redacted, limit)
           end
         end
 
+        def valid_key?(key)
+          Tags::Key.validate!(key)
+          true
+        rescue ArgumentError => e
+          Logging.warn("LlmCostTracker tag key invalid: #{e.message}; skipping")
+          false
+        end
+
         def cap(tags, config: LlmCostTracker.configuration)
           tags = (tags || {}).to_h
           max_count = [config.max_tag_count.to_i, 0].max

data/lib/llm_cost_tracker/timing.rb

@@ -2,13 +2,11 @@
 
 module LlmCostTracker
   module Timing
-    module_function
-
-    def now_monotonic
+    def self.now_monotonic
       Process.clock_gettime(Process::CLOCK_MONOTONIC)
     end
 
-    def elapsed_ms(started_at)
+    def self.elapsed_ms(started_at)
       ((now_monotonic - started_at) * 1000).round
     end
   end