llm_cost_tracker 0.10.0 → 0.12.0

data/lib/llm_cost_tracker/parsers/openai_service_charges.rb

@@ -1,155 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../billing/line_item"
-require_relative "../providers/openai/model_families"
-
-module LlmCostTracker
-  module Parsers
-    module OpenaiServiceCharges
-      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
-        LlmCostTracker::Providers::Openai::ModelFamilies.chat_completions_search?(name)
-      end
-
-      def reasoning_model?(model)
-        return false unless model
-
-        name = model.to_s.split("/", 2).last
-        LlmCostTracker::Providers::Openai::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

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "openai_service_charges"
-require_relative "../providers/openai/hosts"
-require_relative "../providers/openai/model_families"
-
-module LlmCostTracker
-  module Parsers
-    module OpenaiUsage
-      include OpenaiServiceCharges
-
-      class << self
-        def combined_pricing_mode(host:, model:, service_tier:)
-          modes = [Pricing.normalize_mode(service_tier)]
-          modes << "data_residency" if regional_processing?(host: host, model: model)
-          modes = modes.compact.uniq
-          modes.empty? ? nil : modes.join("_")
-        end
-
-        def regional_processing?(host:, model:)
-          LlmCostTracker::Providers::Openai::Hosts.data_residency?(host) &&
-            LlmCostTracker::Providers::Openai::ModelFamilies.data_residency?(model)
-        end
-      end
-
-      def parse(request_url:, request_body:, response_status:, response_body:, **)
-        return nil unless response_status == 200
-
-        response = safe_json_parse(response_body)
-        usage = response["usage"]
-        return nil unless usage
-
-        request = safe_json_parse(request_body)
-        cache_read = cache_read_input_tokens(usage)
-
-        model = response["model"] || request["model"]
-
-        Event.build(
-          provider: provider_for(request_url),
-          provider_response_id: response["id"],
-          pricing_mode: pricing_mode(
-            request_url: request_url,
-            model: model,
-            service_tier: response["service_tier"] || request["service_tier"]
-          ),
-          model: model,
-          token_usage: token_usage(usage: usage, cache_read: cache_read, model: model),
-          usage_source: :response,
-          service_line_items: service_line_items_for(response, request: request, model: response["model"])
-        )
-      end
-
-      def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], **)
-        return nil unless response_status == 200
-
-        request = safe_json_parse(request_body)
-        usage = detect_stream_usage(events)
-        context = stream_capture_context(events: events, request: request, request_url: request_url)
-
-        return build_known_stream_usage(usage: usage, **context) if usage
-
-        warn_missing_stream_usage(request_url: request_url, request: request)
-        build_unknown_stream_usage(**context)
-      end
-
-      def auto_enable_stream_usage?(request_url)
-        openai_chat_completions_url?(request_url)
-      end
-
-      private
-
-      def stream_capture_context(events:, request:, request_url:)
-        model = find_event_value(events) do |data|
-          data["model"] || data.dig("response", "model") || data.dig("chunk", "model")
-        end || request["model"]
-        {
-          provider: provider_for(request_url),
-          model: model,
-          provider_response_id: find_event_value(events) do |data|
-            data["id"] || data.dig("response", "id") || data.dig("chunk", "id")
-          end,
-          pricing_mode: pricing_mode(
-            request_url: request_url,
-            model: model,
-            service_tier: stream_pricing_mode(events) || request["service_tier"]
-          ),
-          service_line_items: openai_stream_service_line_items(events, request: request, model: model)
-        }
-      end
-
-      def build_known_stream_usage(usage:, provider:, model:, provider_response_id:, pricing_mode:, service_line_items:)
-        cache_read = cache_read_input_tokens(usage)
-        Event.build(
-          provider: provider,
-          provider_response_id: provider_response_id,
-          pricing_mode: pricing_mode,
-          model: model,
-          token_usage: token_usage(usage: usage, cache_read: cache_read, model: model),
-          stream: true,
-          usage_source: :stream_final,
-          service_line_items: service_line_items
-        )
-      end
-
-      def warn_missing_stream_usage(request_url:, request:)
-        return unless request.is_a?(Hash) && request["stream"]
-        return unless openai_chat_completions_url?(request_url)
-        return if request.dig("stream_options", "include_usage")
-
-        Logging.warn(
-          "OpenAI-compatible chat-completions stream finished without a final usage chunk. " \
-          "Set `stream_options: { include_usage: true }` in your request body so the gem can " \
-          "record token counts. This call was stored with usage_source=unknown."
-        )
-      end
-
-      def openai_chat_completions_url?(request_url)
-        uri = parsed_uri(request_url)
-        uri && uri.path.to_s.end_with?("/chat/completions")
-      end
-
-      def detect_stream_usage(events)
-        find_event_value(events, reverse: true) do |data|
-          usage = data["usage"] || data.dig("response", "usage") || data.dig("chunk", "usage")
-          usage if usage.is_a?(Hash)
-        end
-      end
-
-      def stream_pricing_mode(events)
-        find_event_value(events, reverse: true) do |data|
-          data["service_tier"] || data.dig("response", "service_tier") || data.dig("chunk", "service_tier")
-        end
-      end
-
-      def pricing_mode(request_url:, model:, service_tier:)
-        OpenaiUsage.combined_pricing_mode(host: parsed_uri(request_url)&.host, model: model, service_tier: service_tier)
-      end
-
-      def token_usage(usage:, cache_read:, model: nil)
-        audio_input = audio_input_tokens(usage)
-        audio_output = audio_output_tokens(usage)
-        image_input = image_input_tokens(usage)
-        image_output_details = image_output_tokens(usage)
-        text_output_details = text_output_tokens(usage)
-        raw_output = (usage["completion_tokens"] || usage["output_tokens"]).to_i
-        image_output, regular_output_remainder = split_stream_image_output(
-          raw_output: raw_output, image_output_details: image_output_details,
-          text_output_details: text_output_details, audio_output: audio_output,
-          default_to_image: LlmCostTracker::Providers::Openai::ModelFamilies.image_output?(model)
-        )
-
-        TokenUsage.build(
-          input_tokens: regular_input_tokens(
-            usage: usage, cache_read: cache_read, audio_input: audio_input, image_input: image_input
-          ),
-          output_tokens: regular_output_remainder,
-          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 split_stream_image_output(raw_output:, image_output_details:, text_output_details:, audio_output:,
-                                    default_to_image: false)
-        if image_output_details.zero? && text_output_details.zero?
-          remainder = [raw_output - audio_output, 0].max
-          return default_to_image ? [remainder, 0] : [0, remainder]
-        end
-
-        text_output = text_output_details
-        text_output = [raw_output - image_output_details - audio_output, 0].max if text_output.zero?
-        [image_output_details, text_output]
-      end
-
-      def regular_input_tokens(usage:, cache_read:, audio_input:, image_input:)
-        raw = (usage["prompt_tokens"] || usage["input_tokens"]).to_i
-        [raw - cache_read - audio_input - image_input, 0].max
-      end
-
-      def cache_read_input_tokens(usage)
-        details = input_token_details(usage)
-        details["cached_tokens"].to_i
-      end
-
-      def audio_input_tokens(usage)
-        details = input_token_details(usage)
-        details["audio_tokens"].to_i
-      end
-
-      def hidden_output_tokens(usage)
-        details = output_token_details(usage)
-        details["reasoning_tokens"].to_i
-      end
-
-      def audio_output_tokens(usage)
-        details = output_token_details(usage)
-        details["audio_tokens"].to_i
-      end
-
-      def image_input_tokens(usage)
-        details = input_token_details(usage)
-        details["image_tokens"].to_i
-      end
-
-      def image_output_tokens(usage)
-        details = output_token_details(usage)
-        details["image_tokens"].to_i
-      end
-
-      def text_output_tokens(usage)
-        details = output_token_details(usage)
-        details["text_tokens"].to_i
-      end
-
-      def input_token_details(usage)
-        usage["prompt_tokens_details"] || usage["input_tokens_details"] || usage["input_token_details"] || {}
-      end
-
-      def output_token_details(usage)
-        usage["completion_tokens_details"] || usage["output_tokens_details"] || usage["output_token_details"] || {}
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/pricing/explainer.rb

@@ -1,74 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../token_usage"
-require_relative "effective_prices"
-
-module LlmCostTracker
-  module Pricing
-    Explanation = Data.define(
-      :provider,
-      :model,
-      :pricing_mode,
-      :source,
-      :matched_key,
-      :matched_by,
-      :prices,
-      :effective_prices,
-      :missing_price_keys
-    ) do
-      def matched?
-        !prices.nil?
-      end
-
-      def complete?
-        matched? && missing_price_keys.empty?
-      end
-
-      def message
-        return "No price entry matched #{provider}/#{model}" unless matched?
-        return "Matched #{matched_key} from #{source} via #{matched_by}" if complete?
-
-        "Matched #{matched_key} from #{source} via #{matched_by}, but missing #{missing_price_keys.join(', ')}"
-      end
-    end
-
-    module Explainer
-      class << self
-        def call(provider:, model:, tokens:, pricing_mode: nil)
-          match = Lookup.call(provider: provider, model: model)
-
-          explanation(
-            provider: provider,
-            model: model,
-            pricing_mode: pricing_mode,
-            match: match,
-            usage: TokenUsage.build_from_tokens(tokens)
-          )
-        end
-
-        private
-
-        def explanation(provider:, model:, pricing_mode:, match:, usage:)
-          prices = match&.prices
-          pricing_mode = Pricing.normalize_mode(pricing_mode)
-          effective = if prices
-                        EffectivePrices.call(usage: usage, quantities: usage.priced_quantities,
-                                             prices: prices, pricing_mode: pricing_mode)
-                      end
-
-          Explanation.new(
-            provider: provider.to_s,
-            model: model.to_s,
-            pricing_mode: pricing_mode,
-            source: match&.source,
-            matched_key: match&.key,
-            matched_by: match&.matched_by,
-            prices: prices,
-            effective_prices: effective || {},
-            missing_price_keys: effective ? effective.filter_map { |key, value| key if value.nil? } : []
-          )
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/pricing/lookup.rb

@@ -1,236 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module Pricing
-    module Lookup
-      Match = Data.define(:source, :key, :prices, :matched_by, :currency)
-      DEFAULT_CURRENCY = "USD"
-      MUTEX = Mutex.new
-      CACHE_MISS = Object.new.freeze
-      NO_MATCH = Object.new.freeze
-      LOOKUP_CACHE_LIMIT = 2_048
-      PRICE_FILE_RECHECK_INTERVAL = 1.0
-      private_constant :PRICE_FILE_RECHECK_INTERVAL
-
-      class << self
-        def call(provider:, model:)
-          provider_name = provider.to_s.presence
-          model_name = model.to_s
-          return nil if model_name.empty?
-
-          invalidate_cache_if_prices_file_changed!
-
-          cache_key = [provider_name, model_name]
-          cached = cached_lookup(cache_key)
-          return cached unless cached.equal?(CACHE_MISS)
-
-          match = lookup_match(provider_name: provider_name, model_name: model_name)
-          cache_lookup(cache_key, match)
-          match
-        end
-
-        def reset!
-          MUTEX.synchronize do
-            reset_prices_caches!(signature: nil)
-            @prices_file_last_check_at = nil
-          end
-        end
-
-        def prices_file_mtime_iso
-          invalidate_cache_if_prices_file_changed!
-          signature = @prices_file_signature
-          return nil unless signature
-
-          cached = @prices_file_iso_cache
-          return cached[:value] if cached && cached[:mtime] == signature
-
-          MUTEX.synchronize do
-            cached = @prices_file_iso_cache
-            return cached[:value] if cached && cached[:mtime] == signature
-
-            iso = signature.utc.iso8601
-            @prices_file_iso_cache = { mtime: signature, value: iso }.freeze
-            iso
-          end
-        end
-
-        private
-
-        def invalidate_cache_if_prices_file_changed!
-          path = LlmCostTracker.configuration.prices_file
-
-          unless path
-            return if @prices_file_signature.nil?
-
-            MUTEX.synchronize { reset_prices_caches!(signature: nil) unless @prices_file_signature.nil? }
-            return
-          end
-
-          now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          last_check = @prices_file_last_check_at
-          return if last_check && (now - last_check) < PRICE_FILE_RECHECK_INTERVAL
-
-          signature = File.exist?(path) ? File.mtime(path) : nil
-          MUTEX.synchronize do
-            @prices_file_last_check_at = now
-            reset_prices_caches!(signature: signature) if @prices_file_signature != signature
-          end
-        end
-
-        def reset_prices_caches!(signature:)
-          @prices_cache = nil
-          @lookup_cache = nil
-          @sorted_price_keys_cache = nil
-          @prices_file_iso_cache = nil
-          @prices_file_signature = signature
-        end
-
-        def lookup_match(provider_name:, model_name:)
-          provider_model = provider_name ? "#{provider_name}/#{model_name}" : model_name
-          normalized_model = normalize_model_name(model_name)
-          current = current_price_tables
-
-          ordered_table_lookups(current).each do |source, table|
-            match = explain_table(
-              table: table,
-              source: source,
-              provider_model: provider_model,
-              model_name: model_name,
-              normalized_model: normalized_model
-            )
-            return match if match
-          end
-          nil
-        end
-
-        def ordered_table_lookups(current)
-          [
-            [:pricing_overrides, current.fetch(:pricing_overrides)],
-            [:prices_file, current.fetch(:file_prices)],
-            [:bundled, Registry.builtin_prices]
-          ]
-        end
-
-        def current_price_tables
-          cached = @prices_cache
-          return cached if cached
-
-          MUTEX.synchronize do
-            cached = @prices_cache
-            return cached if cached
-
-            config = LlmCostTracker.configuration
-            file_prices = Registry.file_prices(config.prices_file)
-            value = { pricing_overrides: config.pricing_overrides, file_prices: file_prices }.freeze
-            @prices_cache = value
-            value
-          end
-        end
-
-        def cached_lookup(cache_key)
-          cached = @lookup_cache
-          return CACHE_MISS unless cached&.key?(cache_key)
-
-          match = cached.fetch(cache_key)
-          match.equal?(NO_MATCH) ? nil : match
-        end
-
-        def cache_lookup(cache_key, match)
-          MUTEX.synchronize do
-            values = (@lookup_cache || {}).dup
-            values.shift while values.size >= LOOKUP_CACHE_LIMIT
-            values[cache_key] = match || NO_MATCH
-            @lookup_cache = values.freeze
-          end
-        end
-
-        def explain_table(table:, source:, provider_model:, model_name:, normalized_model:)
-          return nil if table.empty?
-
-          direct_match(table: table, source: source, key: provider_model, matched_by: :provider_model) ||
-            direct_match(table: table, source: source, key: model_name, matched_by: :model) ||
-            direct_match(table: table, source: source, key: normalized_model, matched_by: :normalized_model) ||
-            unique_providerless_lookup(model: normalized_model, table: table, source: source) ||
-            fuzzy_match(model: provider_model, normalized_model: normalized_model, table: table, source: source) ||
-            unique_providerless_fuzzy_match(model: normalized_model, table: table, source: source)
-        end
-
-        def normalize_model_name(model)
-          model.to_s.split("/").last
-        end
-
-        def unique_providerless_lookup(model:, table:, source:)
-          matches = sorted_price_keys(table).select { |key| normalize_model_name(key) == model }
-          return unless matches.one?
-
-          match(table: table, source: source, key: matches.first, matched_by: :unique_providerless_model)
-        end
-
-        def fuzzy_match(model:, normalized_model:, table:, source:)
-          sorted_price_keys(table).each do |key|
-            if snapshot_variant?(model, key) || snapshot_variant?(normalized_model, key)
-              return match(table: table, source: source, key: key, matched_by: :dated_snapshot)
-            end
-          end
-
-          nil
-        end
-
-        def unique_providerless_fuzzy_match(model:, table:, source:)
-          matches = sorted_price_keys(table).select { |key| snapshot_variant?(model, normalize_model_name(key)) }
-          return unless matches.one?
-
-          match(table: table, source: source, key: matches.first, matched_by: :unique_providerless_dated_snapshot)
-        end
-
-        def direct_match(table:, source:, key:, matched_by:)
-          match(table: table, source: source, key: key, matched_by: matched_by) if table.key?(key)
-        end
-
-        def match(table:, source:, key:, matched_by:)
-          Match.new(
-            source: source,
-            key: key,
-            prices: table[key],
-            matched_by: matched_by,
-            currency: source_currency(source)
-          )
-        end
-
-        def source_currency(source)
-          case source
-          when :bundled then Registry.metadata["currency"] || DEFAULT_CURRENCY
-          when :prices_file
-            Registry.file_metadata(LlmCostTracker.configuration.prices_file)["currency"] || DEFAULT_CURRENCY
-          else DEFAULT_CURRENCY
-          end
-        end
-
-        def snapshot_variant?(model, key)
-          suffix = model.delete_prefix("#{key}-")
-          return false if suffix == model
-
-          suffix.match?(/\A(?:\d{4}-\d{2}-\d{2}|\d{8})\z/)
-        end
-
-        def sorted_price_keys(table)
-          cached = @sorted_price_keys_cache
-          existing = cached && cached[table]
-          return existing if existing
-
-          MUTEX.synchronize do
-            cached = @sorted_price_keys_cache
-            existing = cached && cached[table]
-            return existing if existing
-
-            keys = table.keys.sort_by { |key| -key.length }
-            next_cache = cached ? cached.dup : {}.compare_by_identity
-            next_cache[table] = keys
-            @sorted_price_keys_cache = next_cache.freeze
-            keys
-          end
-        end
-      end
-    end
-  end
-end