llm_cost_tracker 0.9.0 → 0.11.0

data/lib/llm_cost_tracker/pricing.rb

@@ -1,36 +1,30 @@
 # frozen_string_literal: true
 
 require "active_support/core_ext/object/blank"
+require "bigdecimal"
 require "time"
 
 require_relative "version"
+require_relative "logging"
 require_relative "token_usage"
 require_relative "billing/components"
+require_relative "billing/line_item"
 require_relative "pricing/mode"
 require_relative "pricing/registry"
 require_relative "pricing/lookup"
 require_relative "pricing/effective_prices"
 require_relative "pricing/explainer"
 require_relative "pricing/service_charges"
+require_relative "pricing/estimator"
 
 module LlmCostTracker
   module Pricing # rubocop:disable Metrics/ModuleLength
     extend ServiceCharges
 
-    STANDARD_MODE_VALUES = %i[auto default standard standard_only].freeze
     RATE_DENOMINATOR_TOKENS = 1_000_000
-    private_constant :STANDARD_MODE_VALUES, :RATE_DENOMINATOR_TOKENS
+    private_constant :RATE_DENOMINATOR_TOKENS
 
     class << self
-      def normalize_mode(value)
-        return nil if value.nil?
-
-        mode = normalize_string_mode(value.to_s)
-        return nil unless mode
-
-        STANDARD_MODE_VALUES.include?(mode) ? nil : mode
-      end
-
       def cost_for(provider:, model:, tokens:, pricing_mode: nil)
         calculation = calculation_for(
           provider: provider,
@@ -92,13 +86,47 @@ module LlmCostTracker
         value ? { total_cost: value } : {}
       end
 
+      def combine_with_service_lines(cost_data, line_items)
+        priced_services = line_items.reject(&:token?).select(&:priced?)
+        return cost_data if priced_services.empty?
+
+        base_currency = base_currency_for(cost_data, priced_services)
+        matching, mismatched = priced_services.partition { |line| line.currency.to_s == base_currency.to_s }
+        warn_currency_mismatch(mismatched, base_currency) if mismatched.any?
+
+        cost = cost_data ? cost_data.dup : {}
+        cost[:currency] ||= base_currency.to_s
+        return cost if matching.empty?
+
+        service_total = matching.sum(BigDecimal("0"), &:cost_value)
+        base_total = BigDecimal(cost.fetch(:total_cost, 0).to_s)
+        cost[:total_cost] = (base_total + service_total).round(8)
+        cost
+      end
+
+      def token_pricing_partial?(token_usage, cost_data)
+        return false unless cost_data
+
+        token_usage.priced_quantities.any? do |key, quantity|
+          next false unless quantity.positive?
+
+          cost_data[Billing::Components::BY_KEY.fetch(key).cost_key].nil?
+        end
+      end
+
       private
 
-      def normalize_string_mode(value)
-        normalized = value.strip
-        return nil if normalized.empty?
+      def base_currency_for(cost_data, priced_services)
+        (cost_data && cost_data[:currency]) || priced_services.first.currency || Billing::LineItem::USD
+      end
 
-        normalized.downcase.tr("-", "_").to_sym
+      def warn_currency_mismatch(lines, base_currency)
+        currencies = lines.map { |line| line.currency.to_s }.uniq.sort
+        Logging.warn(
+          "Service line currency mismatch: header is #{base_currency}, dropping " \
+          "#{lines.size} priced line(s) in #{currencies.join(', ')} from header total. " \
+          "Per-line costs are still recorded; header total reflects #{base_currency} only."
+        )
       end
 
       def cost_from(calculation)
@@ -108,22 +136,18 @@ module LlmCostTracker
           result[component.cost_key] = cost.round(8) unless cost.nil?
         end
         values[:total_cost] = costs.values.compact.sum(BigDecimal("0")).round(8)
+        values[:currency] = calculation[:match].currency
         values
       end
 
       def snapshot_from(calculation)
         match = calculation[:match]
         effective = calculation[:effective]
-        token_usage = calculation[:token_usage]
-        rates = Billing::Components::TOKEN_PRICED.each_with_object({}) do |component, values|
-          quantity = token_usage.public_send(component.token_key)
-          price = effective[component.key]
+        rates = calculation[:quantities].each_with_object({}) do |(key, quantity), values|
+          price = effective[key]
           next if quantity.zero? || price.nil?
 
-          values[component.key] = {
-            amount: price,
-            quantity: RATE_DENOMINATOR_TOKENS
-          }
+          values[key] = { amount: price, quantity: RATE_DENOMINATOR_TOKENS }
         end
 
         {
@@ -132,7 +156,7 @@ module LlmCostTracker
           source_key: match.key,
           source_version: source_version_for(match.source),
           matched_by: match.matched_by,
-          currency: "USD",
+          currency: match.currency,
           rates: rates
         }
       end
@@ -142,23 +166,29 @@ module LlmCostTracker
         return nil unless match
 
         token_usage = TokenUsage.build_from_tokens(tokens)
-        mode = normalize_mode(pricing_mode)
-        effective = EffectivePrices.call(usage: token_usage, prices: match.prices, pricing_mode: mode)
-        return nil unless any_billable_priced?(token_usage, effective)
-
-        { match: match, effective: effective, token_usage: token_usage, costs: costs_for(token_usage, effective) }
+        quantities = token_usage.priced_quantities
+        mode = Mode.normalize(pricing_mode)
+        effective = EffectivePrices.call(usage: token_usage, quantities: quantities, prices: match.prices,
+                                         pricing_mode: mode)
+        return nil unless any_billable_priced?(quantities, effective)
+
+        { match: match, effective: effective, token_usage: token_usage, quantities: quantities,
+          costs: costs_for(quantities, effective) }
       end
 
-      def any_billable_priced?(token_usage, effective)
-        billable = Billing::Components::TOKEN_PRICED.select { |c| token_usage.public_send(c.token_key).positive? }
-        billable.empty? || billable.any? { |c| effective[c.key] }
-      end
+      def any_billable_priced?(quantities, effective)
+        any_billable = false
+        quantities.each_pair do |key, quantity|
+          next unless quantity.positive?
+          return true if effective[key]
 
-      def costs_for(usage, effective)
-        Billing::Components::TOKEN_PRICED.to_h do |component|
-          tokens = usage.public_send(component.token_key)
-          [component.key, token_cost(tokens, effective[component.key])]
+          any_billable = true
         end
+        !any_billable
+      end
+
+      def costs_for(quantities, effective)
+        quantities.to_h { |key, tokens| [key, token_cost(tokens, effective[key])] }
       end
 
       def apply_calculation_to_line_items(line_items, calculation, provider:, pricing_mode:)
@@ -197,6 +227,7 @@ module LlmCostTracker
           rate_amount: BigDecimal(effective_price.to_s),
           rate_quantity: BigDecimal(RATE_DENOMINATOR_TOKENS),
           cost: cost,
+          currency: match.currency,
           cost_status: cost.zero? ? Billing::CostStatus::FREE : Billing::CostStatus::COMPLETE,
           price_key: component.key,
           price_source: match.source,
@@ -212,7 +243,7 @@ module LlmCostTracker
                charge_rate(provider: provider, component: line_item.kind, pricing_mode: pricing_mode)
         return line_item unless rate
 
-        line_item.apply_rate(rate)
+        line_item.with_rate(rate)
       end
 
       def model_rate_for(line_item, calculation)
@@ -226,7 +257,7 @@ module LlmCostTracker
         {
           amount: BigDecimal(amount.to_s),
           quantity: BigDecimal(Billing::RATE_BASIS_QUANTITIES.fetch(component.rate_basis).to_s),
-          currency: "USD",
+          currency: match.currency,
           source: match.source,
           source_key: "#{match.key}.#{line_item.kind}",
           source_version: source_version_for(match.source)
@@ -248,13 +279,10 @@ module LlmCostTracker
         when :bundled
           LlmCostTracker::VERSION
         when :prices_file
-          path = LlmCostTracker.configuration.prices_file
-          path ? File.mtime(path).utc.iso8601 : nil
+          Lookup.prices_file_mtime_iso
         when :pricing_overrides
           "configuration"
         end
-      rescue Errno::ENOENT
-        nil
       end
 
       def token_cost(tokens, per_million_price)

data/lib/llm_cost_tracker/providers/anthropic/server_tools.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      module ServerTools
+        LINE_ITEMS = {
+          web_search_request: :web_search_requests,
+          web_fetch_request: :web_fetch_requests,
+          code_execution_request: :code_execution_requests
+        }.freeze
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/anthropic/tier_classification.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Anthropic
+      module TierClassification
+        DATA_RESIDENCY_GEOS = %w[us].freeze
+        STANDARD_EQUIVALENT_SERVICE_TIERS = %w[standard standard_only priority].freeze
+
+        module_function
+
+        def data_residency_geo?(geo)
+          DATA_RESIDENCY_GEOS.include?(geo.to_s.downcase)
+        end
+
+        def standard_equivalent_tier?(service_tier)
+          STANDARD_EQUIVALENT_SERVICE_TIERS.include?(service_tier.to_s)
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/azure/hosts.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Azure
+      module Hosts
+        OPENAI_HOST_PATTERN = /\A[a-z0-9][a-z0-9-]*\.(?:openai\.azure\.com|services\.ai\.azure\.com)\z/i
+
+        module_function
+
+        def openai?(host)
+          host.to_s.match?(OPENAI_HOST_PATTERN)
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/providers/gemini/model_families.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Gemini
+      module ModelFamilies
+        PER_QUERY_GROUNDING_MODEL_PATTERN = /\bgemini-(?:[3-9]|[1-9]\d)\b/i
+
+        module_function
+
+        def per_query_grounding?(model)
+          model.to_s.match?(PER_QUERY_GROUNDING_MODEL_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module Hosts
+        API_HOSTS = %w[
+          api.openai.com
+          us.api.openai.com
+          eu.api.openai.com
+          au.api.openai.com
+          ca.api.openai.com
+          jp.api.openai.com
+          in.api.openai.com
+          sg.api.openai.com
+          kr.api.openai.com
+          gb.api.openai.com
+          ae.api.openai.com
+        ].freeze
+
+        DATA_RESIDENCY_HOST_PATTERN = /\A[a-z]{2,3}\.api\.openai\.com\z/
+
+        module_function
+
+        def api?(host)
+          API_HOSTS.include?(host.to_s.downcase)
+        end
+
+        def data_residency?(host)
+          host.to_s.downcase.match?(DATA_RESIDENCY_HOST_PATTERN)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module ModelFamilies
+        DATA_RESIDENCY_MODEL_PATTERN =
+          /\Agpt-5\.(?:4|5)(?:-(?:mini|nano|pro|codex(?:-mini|-max)?))?(?:-\d{4}-\d{2}-\d{2})?\z/
+
+        IMAGE_OUTPUT_MODEL_PATTERN = /\Agpt-image-/i
+
+        CHARACTER_BILLED_TTS_MODEL_PATTERN = /\Atts-1(-hd)?\z/
+
+        REASONING_MODEL_PATTERNS = [
+          /\Agpt-5(\b|[\d.-])/i,
+          /\Ao\d+(\b|[\d.-])/i
+        ].freeze
+
+        NON_REASONING_GPT5_PATTERN = /\Agpt-5(?:\.\d+)?-chat\b/i
+
+        CHAT_COMPLETIONS_SEARCH_MODEL_PATTERN = /-search-(?:preview|api)\b/i
+
+        module_function
+
+        def data_residency?(model)
+          model.to_s.match?(DATA_RESIDENCY_MODEL_PATTERN)
+        end
+
+        def image_output?(model)
+          model.to_s.match?(IMAGE_OUTPUT_MODEL_PATTERN)
+        end
+
+        def character_billed_tts?(model)
+          model.to_s.match?(CHARACTER_BILLED_TTS_MODEL_PATTERN)
+        end
+
+        def chat_completions_search?(model)
+          model.to_s.match?(CHAT_COMPLETIONS_SEARCH_MODEL_PATTERN)
+        end
+
+        def reasoning?(model)
+          name = model.to_s
+          return false if name.empty?
+          return false if NON_REASONING_GPT5_PATTERN.match?(name)
+
+          REASONING_MODEL_PATTERNS.any? { |pattern| pattern.match?(name) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "../../billing/line_item"
+require_relative "model_families"
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module ServiceCharges
+        RESPONSE_OUTPUT_COMPONENTS = {
+          "web_search_call" => :web_search_request,
+          "file_search_call" => :file_search_call,
+          "code_interpreter_call" => :container_session,
+          "mcp_call" => :mcp_call
+        }.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"] == "url_citation"
+            end
+          end
+        end
+
+        def billable?(item)
+          return false unless item.is_a?(Hash)
+
+          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+          return false unless component
+          return true unless component == :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) && RESPONSE_OUTPUT_COMPONENTS.key?(item["type"])
+
+          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+          key = if component == :container_session && item["container_id"]
+                  "#{component}:#{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)
+
+          component_key = component_key_for(item, request: request, model: model)
+          return nil unless component_key
+
+          provider_item_id = if component_key == :container_session
+                               item["container_id"] || item["id"]
+                             else
+                               item["id"]
+                             end
+          Billing::LineItem.build(
+            component_key: component_key,
+            quantity: 1,
+            cost_status: Billing::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 component_key_for(item, request:, model:)
+          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+          return component unless component == :web_search_request
+          return component 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 web_search_preview_used?(request)
+          tools = request && (request[:tools] || request["tools"])
+          return false unless tools.respond_to?(:each)
+
+          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)
+          return false unless model
+
+          name = model.to_s.split("/", 2).last
+          ModelFamilies.chat_completions_search?(name)
+        end
+
+        def reasoning_model?(model)
+          return false unless model
+
+          name = model.to_s.split("/", 2).last
+          ModelFamilies.reasoning?(name)
+        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
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/railtie.rb

@@ -12,15 +12,13 @@ module LlmCostTracker
       require_relative "generators/llm_cost_tracker/install_generator"
       require_relative "generators/llm_cost_tracker/prices_generator"
       require_relative "generators/llm_cost_tracker/call_rollups_generator"
-      require_relative "generators/llm_cost_tracker/durable_ingestion_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"
-    end
-
-    rake_tasks do
-      load File.expand_path("../tasks/llm_cost_tracker.rake", __dir__)
+      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
   end
 end

data/lib/llm_cost_tracker/reconcile_tasks.rb

@@ -85,38 +85,35 @@ module LlmCostTracker
     end
 
     def print_unmatched_provider_rows(diff, output)
-      return if diff.unmatched_provider_rows.empty?
-
-      output.puts "  unmatched provider rows#{truncation_suffix(diff.unmatched_provider_rows.size,
-                                                                diff.unmatched_provider_rows_total)}:"
-      diff.unmatched_provider_rows.each do |row|
-        output.puts "    #{row[:external_id]} (#{row[:match_basis]}): " \
-                    "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
+      print_section(output, "unmatched provider rows",
+                    diff.unmatched_provider_rows, diff.unmatched_provider_rows_total) do |row|
+        "#{row[:external_id]} (#{row[:match_basis]}): " \
+          "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
       end
     end
 
     def print_unmatched_local_calls(diff, output)
-      return if diff.unmatched_local_calls.empty?
-
-      output.puts "  unmatched local calls#{truncation_suffix(diff.unmatched_local_calls.size,
-                                                              diff.unmatched_local_calls_total)}:"
-      diff.unmatched_local_calls.each do |row|
-        output.puts "    #{row[:count]} calls / #{row[:total_cost].to_s('F')} " \
-                    "#{format_attribution(row[:attribution])}"
+      print_section(output, "unmatched local calls",
+                    diff.unmatched_local_calls, diff.unmatched_local_calls_total) do |row|
+        "#{row[:count]} calls / #{row[:total_cost].to_s('F')} #{format_attribution(row[:attribution])}"
       end
     end
 
     def print_non_cost_rows(diff, output)
-      return if diff.non_cost_rows.empty?
-
-      output.puts "  non-cost evidence#{truncation_suffix(diff.non_cost_rows.size,
-                                                          diff.non_cost_rows_total)}:"
-      diff.non_cost_rows.each do |row|
-        output.puts "    [#{row[:row_type]}/#{row[:meter]}] #{format_amount(row[:billed_amount])} " \
-                    "#{format_attribution(row[:attribution])}"
+      print_section(output, "non-cost evidence",
+                    diff.non_cost_rows, diff.non_cost_rows_total) do |row|
+        "[#{row[:row_type]}/#{row[:meter]}] " \
+          "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
       end
     end
 
+    def print_section(output, label, rows, total)
+      return if rows.empty?
+
+      output.puts "  #{label}#{truncation_suffix(rows.size, total)}:"
+      rows.each { |row| output.puts "    #{yield(row)}" }
+    end
+
     def truncation_suffix(shown, total)
       return "" if shown >= total