llm_cost_tracker 0.11.0 → 0.12.0

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,230 +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) && 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::Mode.normalize(response_tier)
-        return response_mode if response_mode
-
-        request_mode = Pricing::Mode.normalize(
-          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,45 +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_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

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -1,228 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "../providers/openai/hosts"
-require_relative "../providers/openai/model_families"
-require_relative "../providers/openai/service_charges"
-
-module LlmCostTracker
-  module Parsers
-    module OpenaiUsage
-      include LlmCostTracker::Providers::Openai::ServiceCharges
-
-      class << self
-        def combined_pricing_mode(host:, model:, service_tier:)
-          modes = [Pricing::Mode.normalize(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