llm_cost_tracker 0.10.0 → 0.12.0

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -1,193 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "../providers/anthropic/tier_classification"
-
-module LlmCostTracker
-  module Parsers
-    class Anthropic < Base
-      HOSTS = %w[api.anthropic.com].freeze
-
-      class << self
-        def match?(url)
-          match_uri?(url, hosts: HOSTS, path_includes: "/v1/messages")
-        end
-
-        def provider_names
-          %w[anthropic]
-        end
-      end
-
-      def parse(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 = usage["cache_read_input_tokens"].to_i
-
-        Event.build(
-          provider: "anthropic",
-          provider_response_id: response["id"],
-          pricing_mode: pricing_mode(request: request, usage: usage),
-          model: response["model"] || request["model"],
-          token_usage: token_usage(usage: usage, cache_read: cache_read),
-          usage_source: :response,
-          service_line_items: service_line_items(usage)
-        )
-      end
-
-      def parse_stream(response_status:, request_body: nil, events: [], **)
-        return nil unless response_status == 200
-
-        request = safe_json_parse(request_body)
-        model = find_event_value(events) { |data| data.dig("message", "model") } || request["model"]
-        usage = stream_usage(events)
-        response_id = find_event_value(events) { |data| data.dig("message", "id") || data["id"] }
-
-        if usage
-          build_stream_result(
-            model: model,
-            usage: usage,
-            response_id: response_id,
-            pricing_mode: pricing_mode(request: request, usage: usage)
-          )
-        else
-          build_unknown_stream_usage(
-            provider: "anthropic",
-            model: model,
-            provider_response_id: response_id,
-            pricing_mode: pricing_mode(request: request, usage: usage)
-          )
-        end
-      end
-
-      def provider_for(_request_url)
-        "anthropic"
-      end
-
-      private
-
-      def stream_usage(events)
-        latest_delta = find_event_value(events, reverse: true) do |data|
-          data["usage"] if data["type"] == "message_delta" && data["usage"].is_a?(Hash)
-        end
-        return nil unless latest_delta
-
-        start_usage = find_event_value(events, reverse: true) do |data|
-          data.dig("message", "usage") if data["type"] == "message_start"
-        end
-
-        (start_usage || {}).merge(latest_delta) do |_key, start_val, delta_val|
-          delta_val || start_val
-        end
-      end
-
-      def build_stream_result(model:, usage:, response_id:, pricing_mode:)
-        cache_read = usage["cache_read_input_tokens"].to_i
-
-        Event.build(
-          provider: "anthropic",
-          provider_response_id: response_id,
-          pricing_mode: pricing_mode,
-          model: model,
-          token_usage: token_usage(usage: usage, cache_read: cache_read),
-          stream: true,
-          usage_source: :stream_final,
-          service_line_items: service_line_items(usage)
-        )
-      end
-
-      def service_line_items(usage)
-        server_tool_use = usage["server_tool_use"]
-        return [] unless server_tool_use.is_a?(Hash)
-
-        [
-          service_line_item(
-            component_key: :web_search_request,
-            quantity: server_tool_use["web_search_requests"],
-            provider_field: "usage.server_tool_use.web_search_requests"
-          ),
-          service_line_item(
-            component_key: :web_fetch_request,
-            quantity: server_tool_use["web_fetch_requests"],
-            provider_field: "usage.server_tool_use.web_fetch_requests"
-          ),
-          service_line_item(
-            component_key: :code_execution_request,
-            quantity: server_tool_use["code_execution_requests"],
-            provider_field: "usage.server_tool_use.code_execution_requests"
-          )
-        ].compact
-      end
-
-      def service_line_item(component_key:, quantity:, provider_field:)
-        quantity = quantity.to_i
-        return if quantity.zero?
-
-        Billing::LineItem.build(
-          component_key: component_key,
-          quantity: quantity,
-          cost_status: Billing::CostStatus::UNKNOWN,
-          pricing_basis: :provider_usage,
-          provider_field: provider_field
-        )
-      end
-
-      def token_usage(usage:, cache_read:)
-        input = usage["input_tokens"].to_i
-        output = usage["output_tokens"].to_i
-        cache_creation = usage["cache_creation"]
-        if cache_creation.is_a?(Hash)
-          cache_write = cache_creation["ephemeral_5m_input_tokens"].to_i
-          cache_write_extended = cache_creation["ephemeral_1h_input_tokens"].to_i
-        else
-          warn_unexpected_cache_creation(cache_creation, usage)
-          cache_write = usage["cache_creation_input_tokens"].to_i
-          cache_write_extended = 0
-        end
-        hidden_output = (
-          usage["thinking_tokens"] || usage["thinking_output_tokens"] ||
-            usage.dig("output_tokens_details", "reasoning_tokens")
-        ).to_i
-
-        TokenUsage.build(
-          input_tokens: input,
-          output_tokens: output,
-          total_tokens: input + output + cache_read + cache_write + cache_write_extended,
-          cache_read_input_tokens: cache_read,
-          cache_write_input_tokens: cache_write,
-          cache_write_extended_input_tokens: cache_write_extended,
-          hidden_output_tokens: hidden_output
-        )
-      end
-
-      def warn_unexpected_cache_creation(cache_creation, usage)
-        return if cache_creation.nil? || usage.key?("cache_creation_input_tokens")
-
-        Logging.warn("Anthropic usage.cache_creation has unexpected shape: #{cache_creation.class}")
-      end
-
-      def pricing_mode(request:, usage:)
-        modes = []
-        speed = usage&.fetch("speed", nil) || request["speed"]
-        service_tier = usage&.fetch("service_tier", nil) || request["service_tier"]
-        service_tier = nil if Providers::Anthropic::TierClassification.standard_equivalent_tier?(service_tier)
-
-        modes << Pricing.normalize_mode(speed)
-        modes << Pricing.normalize_mode(service_tier)
-        geo = inference_geo(request: request, usage: usage).downcase
-        modes << "data_residency" if Providers::Anthropic::TierClassification.data_residency_geo?(geo)
-
-        modes = modes.compact.uniq
-        modes.empty? ? nil : modes.join("_")
-      end
-
-      def inference_geo(request:, usage:)
-        (usage&.fetch("inference_geo", nil) || request["inference_geo"]).to_s
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/parsers/azure.rb

@@ -1,46 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "openai_usage"
-require_relative "../providers/azure/hosts"
-
-module LlmCostTracker
-  module Parsers
-    class Azure < Base
-      include OpenaiUsage
-
-      TRACKED_ENDPOINTS = %w[
-        chat/completions completions embeddings moderations responses
-        audio/transcriptions audio/translations audio/speech
-        images/generations images/edits images/variations
-      ].freeze
-
-      PATH_PATTERN = %r{\A/openai/(?:deployments/[^/]+|v1)/(?:#{TRACKED_ENDPOINTS.join('|')})\z}
-
-      class << self
-        def match?(url)
-          uri_matches?(url) do |uri|
-            LlmCostTracker::Providers::Azure::Hosts.openai?(uri.host) && uri.path.to_s.match?(PATH_PATTERN)
-          end
-        end
-
-        def provider_names
-          %w[azure_openai]
-        end
-      end
-
-      def provider_for(_request_url)
-        "azure_openai"
-      end
-
-      def model_for(request_url, request_parsed)
-        body_model = super
-        return body_model if body_model
-
-        uri = parsed_uri(request_url)
-        match = uri&.path&.match(%r{/openai/deployments/([^/]+)/})
-        match && match[1]
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/parsers/base.rb

@@ -1,131 +0,0 @@
-# frozen_string_literal: true
-
-require "active_support/core_ext/object/blank"
-require "json"
-require "uri"
-
-module LlmCostTracker
-  module Parsers
-    module UrlMatchers
-      def match_uri?(url, hosts: nil, exact_paths: nil, path_includes: nil, path_suffixes: nil, path_pattern: nil)
-        uri_matches?(url) do |uri|
-          host_match = hosts.nil? || hosts.include?(uri.host.to_s.downcase)
-          path_match = path_matches?(
-            uri,
-            exact_paths: exact_paths,
-            path_includes: path_includes,
-            path_suffixes: path_suffixes,
-            path_pattern: path_pattern
-          )
-          extra_match = block_given? ? yield(uri) : true
-
-          next false unless host_match && path_match
-          next false unless extra_match
-
-          true
-        end
-      end
-
-      def uri_matches?(url)
-        uri = parsed_uri(url)
-        uri ? yield(uri) : false
-      end
-
-      def parsed_uri(url)
-        URI.parse(url.to_s)
-      rescue URI::InvalidURIError
-        nil
-      end
-
-      def path_matches?(uri, exact_paths: nil, path_includes: nil, path_suffixes: nil, path_pattern: nil)
-        path = uri.path.to_s
-        matches = true
-
-        matches &&= exact_paths.include?(path) if exact_paths
-        matches &&= Array(path_includes).all? { |fragment| path.include?(fragment) } if path_includes
-        matches &&= path.match?(path_pattern) if path_pattern
-
-        matches &&= path_suffixes.any? { |suffix| path == suffix || path.end_with?(suffix) } if path_suffixes
-
-        matches
-      end
-    end
-
-    class Base
-      extend UrlMatchers
-      include UrlMatchers
-
-      class << self
-        def match?(_url)
-          raise NotImplementedError
-        end
-
-        def provider_names
-          []
-        end
-      end
-
-      def parse(**)
-        raise NotImplementedError
-      end
-
-      def streaming_request?(_request_url, request_parsed)
-        request_parsed.is_a?(Hash) && request_parsed["stream"] == true
-      end
-
-      def model_for(_request_url, request_parsed)
-        request_parsed["model"] if request_parsed.is_a?(Hash)
-      end
-
-      def parse_stream(**)
-        nil
-      end
-
-      def auto_enable_stream_usage?(_request_url)
-        false
-      end
-
-      def safe_json_parse(body)
-        return {} if body.blank?
-
-        JSON.parse(body)
-      rescue JSON::ParserError
-        {}
-      end
-
-      private
-
-      def each_event_data(events, reverse: false)
-        enumerator = reverse ? events.reverse_each : events.each
-
-        enumerator.each do |event|
-          data = event[:data]
-          yield data if data.is_a?(Hash)
-        end
-      end
-
-      def find_event_value(events, reverse: false)
-        each_event_data(events, reverse:) do |data|
-          value = yield(data)
-          return value if value.present?
-        end
-
-        nil
-      end
-
-      def build_unknown_stream_usage(provider:, model:, provider_response_id:, pricing_mode: nil,
-                                     service_line_items: nil)
-        Event.build(
-          provider: provider,
-          provider_response_id: provider_response_id,
-          pricing_mode: pricing_mode,
-          model: model || Event::UNKNOWN_MODEL,
-          token_usage: TokenUsage.build(input_tokens: 0, output_tokens: 0, total_tokens: 0),
-          stream: true,
-          usage_source: :unknown,
-          service_line_items: service_line_items
-        )
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -1,232 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../billing/line_item"
-require_relative "base"
-require_relative "../providers/gemini/model_families"
-
-module LlmCostTracker
-  module Parsers
-    class Gemini < Base
-      HOSTS = %w[generativelanguage.googleapis.com].freeze
-      TRACKED_PATH_PATTERN = %r{/models/[^/:]+:(?:generateContent|streamGenerateContent)\z}
-      STREAM_PATH_PATTERN  = /:streamGenerateContent\z/
-
-      class << self
-        def match?(url)
-          match_uri?(url, hosts: HOSTS, path_pattern: TRACKED_PATH_PATTERN)
-        end
-
-        def provider_names
-          %w[gemini]
-        end
-      end
-
-      def streaming_request?(request_url, request_parsed)
-        return true if match_uri?(request_url, path_pattern: STREAM_PATH_PATTERN)
-
-        super
-      end
-
-      def parse(request_url:, request_body:, response_status:, response_body:, response_headers: nil)
-        return nil unless response_status == 200
-
-        response = safe_json_parse(response_body)
-        usage    = response["usageMetadata"]
-        return nil unless usage
-
-        request = safe_json_parse(request_body)
-        model = extract_model_from_url(request_url)
-        build_event(
-          request_url: request_url,
-          usage: usage,
-          usage_source: :response,
-          provider_response_id: response["responseId"],
-          pricing_mode: pricing_mode(request: request, response_headers: response_headers),
-          service_line_items: grounding_line_items(grounding_request_count(response["candidates"]), model: model)
-        )
-      end
-
-      def parse_stream(response_status:, request_url: nil, request_body: nil, events: [], response_headers: nil)
-        return nil unless response_status == 200
-
-        request = safe_json_parse(request_body)
-        usage = merged_stream_usage(events)
-        model = extract_model_from_url(request_url)
-        response_id = stream_response_id(events)
-        mode = pricing_mode(request: request, response_headers: response_headers)
-        service_line_items = grounding_line_items_for_stream(events, model: model)
-
-        if usage
-          build_event(
-            request_url: request_url,
-            usage: usage,
-            stream: true,
-            usage_source: :stream_final,
-            provider_response_id: response_id,
-            pricing_mode: mode,
-            service_line_items: service_line_items
-          )
-        else
-          build_unknown_stream_usage(
-            provider: "gemini",
-            model: model,
-            provider_response_id: response_id,
-            pricing_mode: mode,
-            service_line_items: service_line_items
-          )
-        end
-      end
-
-      def model_for(request_url, _request_parsed)
-        extract_model_from_url(request_url)
-      end
-
-      def provider_for(_request_url)
-        "gemini"
-      end
-
-      private
-
-      def build_event(request_url:, usage:, usage_source:, stream: false, provider_response_id: nil,
-                      pricing_mode: nil, service_line_items: nil)
-        cache_read = usage["cachedContentTokenCount"].to_i
-        tool_use_prompt = usage["toolUsePromptTokenCount"].to_i
-        audio_input = audio_input_tokens(usage)
-        audio_output = audio_output_tokens(usage)
-
-        Event.build(
-          provider: "gemini",
-          model: extract_model_from_url(request_url),
-          pricing_mode: pricing_mode,
-          token_usage: TokenUsage.build(
-            input_tokens: regular_input_tokens(usage: usage, cache_read: cache_read, audio_input: audio_input) +
-                          tool_use_prompt,
-            output_tokens: regular_output_tokens(usage: usage, audio_output: audio_output),
-            total_tokens: usage["totalTokenCount"],
-            cache_read_input_tokens: cache_read,
-            audio_input_tokens: audio_input,
-            audio_output_tokens: audio_output,
-            hidden_output_tokens: usage["thoughtsTokenCount"]
-          ),
-          stream: stream,
-          usage_source: usage_source,
-          provider_response_id: provider_response_id,
-          service_line_items: service_line_items
-        )
-      end
-
-      def merged_stream_usage(events)
-        find_event_value(events, reverse: true) do |data|
-          meta = data["usageMetadata"]
-          meta if meta.is_a?(Hash)
-        end
-      end
-
-      def output_tokens(usage)
-        (usage["candidatesTokenCount"] || usage["responseTokenCount"]).to_i + usage["thoughtsTokenCount"].to_i
-      end
-
-      def regular_input_tokens(usage:, cache_read:, audio_input:)
-        [usage["promptTokenCount"].to_i - cache_read - audio_input, 0].max
-      end
-
-      def regular_output_tokens(usage:, audio_output:)
-        [output_tokens(usage) - audio_output, 0].max
-      end
-
-      def audio_input_tokens(usage)
-        prompt_audio = modality_tokens(usage["promptTokensDetails"] || usage["prompt_tokens_details"], "AUDIO")
-        cache_audio = modality_tokens(usage["cacheTokensDetails"] || usage["cache_tokens_details"], "AUDIO")
-        [prompt_audio - cache_audio, 0].max
-      end
-
-      def audio_output_tokens(usage)
-        modality_tokens(
-          usage["candidatesTokensDetails"] ||
-            usage["candidates_tokens_details"] ||
-            usage["responseTokensDetails"] ||
-            usage["response_tokens_details"],
-          "AUDIO"
-        )
-      end
-
-      def modality_tokens(details, modality)
-        Array(details).sum do |detail|
-          next 0 unless detail.is_a?(Hash)
-
-          next 0 unless detail["modality"] == modality
-
-          (detail["tokenCount"] || detail["token_count"]).to_i
-        end
-      end
-
-      def stream_response_id(events)
-        find_event_value(events) { |data| data["responseId"] }
-      end
-
-      def extract_model_from_url(url)
-        uri = parsed_uri(url)
-        return nil unless uri
-
-        match = uri.path.match(%r{/models/([^/:]+)})
-        match && match[1]
-      end
-
-      def pricing_mode(request:, response_headers:)
-        response_tier = response_header(response_headers, "x-gemini-service-tier")
-        response_mode = Pricing.normalize_mode(response_tier)
-        return response_mode if response_mode
-
-        request_mode = Pricing.normalize_mode(
-          request["service_tier"] ||
-          request["serviceTier"] ||
-          request.dig("config", "service_tier") ||
-          request.dig("config", "serviceTier")
-        )
-        request_mode == :flex ? request_mode : nil
-      end
-
-      def response_header(headers, name)
-        headers.to_h.find { |key, _value| key.to_s.downcase == name }&.last
-      end
-
-      def grounding_line_items_for_stream(events, model:)
-        quantity = find_event_value(events, reverse: true) do |data|
-          count = grounding_request_count(data["candidates"])
-          count if count.positive?
-        end
-        grounding_line_items(quantity || 0, model: model)
-      end
-
-      def grounding_request_count(candidates)
-        Array(candidates).sum do |candidate|
-          next 0 unless candidate.is_a?(Hash)
-
-          metadata = candidate["groundingMetadata"] || candidate["grounding_metadata"] || {}
-          queries = metadata["webSearchQueries"] || metadata["web_search_queries"] || []
-          Array(queries).size
-        end
-      end
-
-      def grounding_line_items(query_count, model:)
-        return [] unless query_count.positive?
-
-        billed_quantity = grounding_billed_quantity(query_count, model: model)
-        [
-          Billing::LineItem.build(
-            component_key: :grounding_request,
-            quantity: billed_quantity,
-            cost_status: Billing::CostStatus::UNKNOWN,
-            pricing_basis: :provider_usage,
-            provider_field: "response.candidates.groundingMetadata.webSearchQueries",
-            details: { web_search_queries: query_count }
-          )
-        ]
-      end
-
-      def grounding_billed_quantity(query_count, model:)
-        LlmCostTracker::Providers::Gemini::ModelFamilies.per_query_grounding?(model) ? query_count : 1
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/parsers/openai.rb

@@ -1,41 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "openai_usage"
-require_relative "../providers/openai/hosts"
-
-module LlmCostTracker
-  module Parsers
-    class Openai < Base
-      include OpenaiUsage
-
-      TRACKED_PATHS = %w[
-        /v1/chat/completions
-        /v1/completions
-        /v1/embeddings
-        /v1/responses
-        /v1/images/generations
-        /v1/images/edits
-        /v1/images/variations
-        /v1/audio/transcriptions
-        /v1/audio/translations
-        /v1/audio/speech
-        /v1/moderations
-      ].freeze
-
-      class << self
-        def match?(url)
-          match_uri?(url, hosts: Providers::Openai::Hosts::API_HOSTS, exact_paths: TRACKED_PATHS)
-        end
-
-        def provider_names
-          %w[openai]
-        end
-      end
-
-      def provider_for(_request_url)
-        "openai"
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -1,51 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "base"
-require_relative "openai_usage"
-
-module LlmCostTracker
-  module Parsers
-    class OpenaiCompatible < Base
-      include OpenaiUsage
-
-      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
-          providers = LlmCostTracker.configuration.openai_compatible_providers
-          cached = @provider_names
-          return cached if cached && @provider_names_providers.equal?(providers)
-
-          names = [
-            "openai_compatible",
-            *providers.each_value.map { |provider| provider.to_s.downcase }
-          ].uniq.freeze
-          return names unless providers.frozen?
-
-          @provider_names_providers = providers
-          @provider_names = names
-        end
-
-        def provider_for(request_url)
-          provider_for_uri(parsed_uri(request_url)) || "openai_compatible"
-        end
-
-        private
-
-        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(request_url)
-      end
-    end
-  end
-end