llm_cost_tracker 0.13.0 → 0.14.0

data/lib/llm_cost_tracker/pricing/backfill.rb

@@ -4,6 +4,7 @@ require_relative "../pricing"
 require_relative "../charges/line_item"
 require_relative "../ledger/rollups"
 require_relative "../usage/token_usage"
+require_relative "../budget/per_tag"
 
 module LlmCostTracker
   module Pricing
@@ -30,7 +31,7 @@ module LlmCostTracker
                 rollup_events << rollup_event_for(call, calculation)
                 recomputed += 1
               end
-              Ledger::Rollups.increment!(rollup_events) if rollup_events.any?
+              Ledger::Rollups.increment!(rollup_events)
             end
           end
 
@@ -61,6 +62,7 @@ module LlmCostTracker
             pricing_snapshot: calculation.snapshot,
             cost_status: calculation.cost_status
           )
+          resync_tag_costs(call, calculation.cost.total)
           token_priced = calculation.priced_line_items.select(&:token?).index_by { |item| dimension_key(item) }
           service_priced = calculation.priced_line_items.reject(&:token?)
           token_records, service_records = call.line_items.partition { |record| record.unit == "token" }
@@ -69,6 +71,14 @@ module LlmCostTracker
           service_records.sort_by(&:position).zip(service_priced).each { |record, priced| apply_rate(record, priced) }
         end
 
+        def resync_tag_costs(call, total_cost)
+          return unless LlmCostTracker::Budget::PerTag.columns?
+
+          LlmCostTracker::CallTag
+            .where(llm_cost_tracker_call_id: call.id)
+            .update_all(total_cost: total_cost)
+        end
+
         def apply_rate(record, priced)
           return unless priced
 

data/lib/llm_cost_tracker/pricing/calculation.rb

@@ -187,16 +187,16 @@ module LlmCostTracker
         price = effective[dimension.key]
         return line_item.with(cost_status: Charges::CostStatus::UNKNOWN) if price.nil?
 
-        line_item.with_rate(token_rate(dimension, price))
+        line_item.with_rate(token_rate(price))
       end
 
-      def token_rate(dimension, price)
+      def token_rate(price)
         Pricing::Rate.new(
-          amount: price.to_d,
+          amount: price.amount.to_d,
           quantity: RATE_DENOMINATOR_TOKENS.to_d,
           currency: match.source.currency,
           source: match.source.name,
-          source_key: dimension.key,
+          source_key: price.key,
           source_version: match.source.version
         )
       end

data/lib/llm_cost_tracker/pricing/effective_prices.rb

@@ -8,38 +8,49 @@ require_relative "price_key"
 module LlmCostTracker
   module Pricing
     module EffectivePrices
+      Resolved = Data.define(:amount, :key)
+
       class << self
         def call(usage:, quantities:, prices:, pricing_mode:)
           context_tier = context_tier?(usage: usage, prices: prices)
           orderings = pricing_mode && Mode.permutations_for(pricing_mode)
 
           quantities.to_h do |price_key, tokens|
-            price = if tokens.positive?
-                      price_for(
-                        prices: prices,
-                        key: price_key,
-                        orderings: orderings,
-                        context_tier: context_tier
-                      )
-                    else
-                      BigDecimal("0")
-                    end
-            [price_key, price]
+            resolved = if tokens.positive?
+                         price_for(
+                           prices: prices,
+                           key: price_key,
+                           orderings: orderings,
+                           context_tier: context_tier
+                         )
+                       else
+                         Resolved.new(amount: BigDecimal("0"), key: price_key)
+                       end
+            [price_key, resolved]
           end
         end
 
         private
 
         def price_for(prices:, key:, orderings:, context_tier:)
-          return prices[PriceKey.build(key, above_context: context_tier)] unless orderings
+          unless orderings
+            standard = PriceKey.build(key, above_context: context_tier)
+            return resolve(prices[standard], standard)
+          end
 
           orderings.each do |mode|
-            direct = prices[PriceKey.build(key, mode: mode, above_context: context_tier)]
-            return direct if direct
+            table_key = PriceKey.build(key, mode: mode, above_context: context_tier)
+            direct = prices[table_key]
+            return resolve(direct, table_key) if direct
           end
           return nil if %w[input output].include?(key)
 
-          derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
+          derived = derived_mode_price(prices: prices, key: key, modes: orderings, context_tier: context_tier)
+          resolve(derived, nil)
+        end
+
+        def resolve(amount, key)
+          amount && Resolved.new(amount: amount, key: key)
         end
 
         def derived_mode_price(prices:, key:, modes:, context_tier:)

data/lib/llm_cost_tracker/pricing/matcher.rb

@@ -27,6 +27,13 @@ module LlmCostTracker
           @cache[key] = lookup_match(sources, provider_name, model_name)
         end
 
+        def modifier_priced?(provider:, model:, modifier:)
+          prices = lookup(provider: provider, model: model)&.prices
+          return false unless prices
+
+          prices.any? { |key, _| key.to_s.include?(modifier) }
+        end
+
         private
 
         def reset_cache(sources)

data/lib/llm_cost_tracker/pricing/rate.rb

@@ -9,8 +9,7 @@ module LlmCostTracker
       "per_1k_requests" => 1_000,
       "per_session" => 1,
       "per_hour" => 1,
-      "per_minute" => 1,
-      "per_image" => 1
+      "per_minute" => 1
     }.freeze
 
     Rate = Data.define(:amount, :quantity, :currency, :source, :source_key, :source_version)

data/lib/llm_cost_tracker/pricing/registry.rb

@@ -101,7 +101,7 @@ module LlmCostTracker
         end
 
         def prices_file_mtime_iso
-          path = LlmCostTracker.configuration.prices_file
+          path = LlmCostTracker.configuration.pricing.file
           return nil unless path && File.exist?(path)
 
           @prices_file_mtime_iso ||= File.mtime(path).utc.iso8601
@@ -113,16 +113,16 @@ module LlmCostTracker
             [
               Source.new(
                 name: "pricing_overrides",
-                prices: config.pricing_overrides,
+                prices: config.pricing.overrides,
                 rates: {},
                 currency: upcased_currency(nil),
                 version: "configuration"
               ),
               Source.new(
                 name: "prices_file",
-                prices: file_prices(config.prices_file),
-                rates: file_rates(config.prices_file),
-                currency: upcased_currency(file_metadata(config.prices_file)["currency"]),
+                prices: file_prices(config.pricing.file),
+                rates: file_rates(config.pricing.file),
+                currency: upcased_currency(file_metadata(config.pricing.file)["currency"]),
                 version: prices_file_mtime_iso
               ),
               Source.new(

data/lib/llm_cost_tracker/pricing/sync.rb

@@ -26,7 +26,7 @@ module LlmCostTracker
           output = env["OUTPUT"].to_s.strip.presence
           return output if output
 
-          prices_file = config.prices_file
+          prices_file = config.pricing.file
           return prices_file.to_s if prices_file
 
           Rails.root.join(DEFAULT_OUTPUT_PATH).to_s

data/lib/llm_cost_tracker/pricing/unknown.rb

@@ -9,14 +9,14 @@ module LlmCostTracker
       WARN_CACHE_LIMIT = 1024
 
       class << self
-        def process(model)
+        def process(model, pricing_mode: nil)
           model = model.to_s.presence || Event::UNKNOWN_MODEL
 
-          case LlmCostTracker.configuration.unknown_pricing_behavior
+          case LlmCostTracker.configuration.pricing.unknown_model_behavior
           when :ignore
             nil
           when :warn
-            warn_missing(model)
+            warn_missing(model, pricing_mode.to_s.presence)
           when :raise
             raise UnknownPricingError.new(model: model)
           end
@@ -24,19 +24,22 @@ module LlmCostTracker
 
         private
 
-        def warn_missing(model)
+        def warn_missing(model, pricing_mode)
+          key = [model, pricing_mode].freeze
           should_warn = MUTEX.synchronize do
             @warned_models ||= Set.new
-            next false if @warned_models.size >= WARN_CACHE_LIMIT && !@warned_models.include?(model)
+            next false if @warned_models.size >= WARN_CACHE_LIMIT && !@warned_models.include?(key)
 
-            @warned_models.add?(model)
+            @warned_models.add?(key)
           end
           return unless should_warn
 
+          subject = "model #{model.inspect}"
+          subject += " at pricing_mode #{pricing_mode.inspect}" if pricing_mode
           Logging.warn(
-            "No pricing configured for model #{model.inspect}. " \
+            "No pricing configured for #{subject}. " \
             "Cost and budget guardrails will be skipped for this event. " \
-            "Add a pricing_overrides entry or set unknown_pricing_behavior."
+            "Add a pricing.overrides entry or set pricing.unknown_model_behavior."
           )
         end
       end

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

@@ -22,12 +22,13 @@ module LlmCostTracker
             output_tokens: output,
             cache_read_input_tokens: cache_read,
             cache_write_input_tokens: cache_write,
-            cache_write_extended_input_tokens: cache_write_extended
+            cache_write_extended_input_tokens: cache_write_extended,
+            hidden_output_tokens: usage.dig(:output_tokens_details, :thinking_tokens).to_i
           )
         end
 
         def self.pricing_mode(request:, usage:)
-          speed = request&.dig(:speed)
+          speed = usage&.dig(:speed) || request&.dig(:speed)
           service_tier = usage&.dig(:service_tier) || request&.dig(:service_tier)
           geo = (usage&.dig(:inference_geo) || request&.dig(:inference_geo)).to_s.downcase
 

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

@@ -4,9 +4,6 @@ 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/
@@ -19,10 +16,6 @@ module LlmCostTracker
         NON_REASONING_GPT5_PATTERN = /\Agpt-5(?:\.\d+)?-chat\b/i
 
         CHAT_COMPLETIONS_SEARCH_MODEL_PATTERN = /-search-(?:preview|api)\b/i
-        def self.data_residency?(model)
-          model.to_s.match?(DATA_RESIDENCY_MODEL_PATTERN)
-        end
-
         def self.image_output?(model)
           model.to_s.match?(IMAGE_OUTPUT_MODEL_PATTERN)
         end

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

@@ -16,7 +16,10 @@ module LlmCostTracker
         class << self
           def combined_pricing_mode(host:, model:, service_tier:)
             modes = [Pricing::Mode.normalize(service_tier)]
-            modes << "data_residency" if Hosts.data_residency?(host) && ModelFamilies.data_residency?(model)
+            if Hosts.data_residency?(host) &&
+               Pricing::Matcher.modifier_priced?(provider: "openai", model: model, modifier: "data_residency")
+              modes << "data_residency"
+            end
             Pricing::Mode.compose(modes)
           end
 
@@ -26,7 +29,7 @@ module LlmCostTracker
 
             model = response["model"] || request["model"]
             service_line_items =
-              ServiceCharges.service_line_items_for(response, request: request, model: response["model"]) +
+              ServiceCharges.service_line_items_for(response, request: request, model: model) +
               ServiceCharges.transcription_line_items(usage)
             Event.build(
               provider: provider,

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

@@ -12,6 +12,7 @@ module LlmCostTracker
           input_tokens = (usage[:input_tokens] || usage[:prompt_tokens]).to_i
           output_tokens = (usage[:output_tokens] || usage[:completion_tokens]).to_i
           cache_read = cache_read_input_tokens(usage)
+          cache_write = cache_write_input_tokens(usage)
           audio_input = audio_input_tokens(usage)
           audio_output = audio_output_tokens(usage)
           image_input = image_input_tokens(usage)
@@ -24,10 +25,11 @@ module LlmCostTracker
           )
 
           Usage::TokenUsage.build(
-            input_tokens: [input_tokens - cache_read - audio_input - image_input, 0].max,
+            input_tokens: [input_tokens - cache_read - cache_write - audio_input - image_input, 0].max,
             output_tokens: regular_output,
             total_tokens: usage[:total_tokens],
             cache_read_input_tokens: cache_read,
+            cache_write_input_tokens: cache_write,
             audio_input_tokens: audio_input,
             audio_output_tokens: audio_output,
             image_input_tokens: image_input,
@@ -46,12 +48,11 @@ module LlmCostTracker
             return default_to_image ? [remainder, 0] : [0, remainder]
           end
 
-          text_output = text_output_details
-          text_output = [output_tokens - image_output_details - audio_output, 0].max if text_output.zero?
-          [image_output_details, text_output]
+          [image_output_details, [output_tokens - image_output_details - audio_output, 0].max]
         end
 
         def self.cache_read_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens)
+        def self.cache_write_input_tokens(usage) = detail(usage, INPUT_DETAIL_KEYS, :cache_write_tokens)
         def self.hidden_output_tokens(usage)    = detail(usage, OUTPUT_DETAIL_KEYS, :reasoning_tokens)
         def self.audio_input_tokens(usage)      = detail(usage, INPUT_DETAIL_KEYS, :audio_tokens)
         def self.audio_output_tokens(usage)     = detail(usage, OUTPUT_DETAIL_KEYS, :audio_tokens)

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

@@ -14,7 +14,7 @@ module LlmCostTracker
           end
 
           def provider_names
-            custom = LlmCostTracker.configuration.openai_compatible_providers.each_value.map do |provider|
+            custom = LlmCostTracker.configuration.capture.openai_compatible_providers.each_value.map do |provider|
               provider.to_s.downcase
             end
             ["openai_compatible", *custom].uniq
@@ -23,7 +23,7 @@ module LlmCostTracker
           def provider_for_uri(uri)
             return nil unless uri
 
-            LlmCostTracker.configuration.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
+            LlmCostTracker.configuration.capture.openai_compatible_providers[uri.host.to_s.downcase]&.to_s
           end
         end
 

data/lib/llm_cost_tracker/railtie.rb

@@ -8,14 +8,10 @@ module LlmCostTracker
       app.config.eager_load_paths << models_path unless app.config.eager_load_paths.include?(models_path)
     end
 
+    GENERATOR_FILES = File.expand_path("generators/llm_cost_tracker/*_generator.rb", __dir__)
+
     generators do
-      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/async_ingestion_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"
+      Dir[GENERATOR_FILES].each { |path| require path }
     end
   end
 end

data/lib/llm_cost_tracker/report/data.rb

@@ -34,7 +34,7 @@ module LlmCostTracker
         end
         from = now - days.days
         scope = LlmCostTracker::Call.where(tracked_at: from..now)
-        tag_breakdowns ||= LlmCostTracker.configuration.report_tag_breakdowns || []
+        tag_breakdowns ||= LlmCostTracker.configuration.tags.report_breakdown_keys || []
         aggregate = totals(scope)
 
         new(
@@ -55,7 +55,7 @@ module LlmCostTracker
       def self.totals(scope)
         scope
           .select(
-            "COALESCE(SUM(total_cost), 0) AS total_cost, " \
+            "COALESCE(SUM(#{LlmCostTracker::Call.qualified(:total_cost)}), 0) AS total_cost, " \
             "COUNT(*) AS requests_count, " \
             "AVG(latency_ms) AS average_latency_ms, " \
             "COALESCE(SUM(CASE WHEN #{Charges::CostStatus.unknown_pricing_sql} " \

data/lib/llm_cost_tracker/retention.rb

@@ -3,6 +3,8 @@
 module LlmCostTracker
   module Retention
     DEFAULT_BATCH_SIZE = 5_000
+    ROLLUP_COLUMNS = %i[tracked_at total_cost pricing_snapshot provider].freeze
+    private_constant :ROLLUP_COLUMNS
 
     class << self
       def prune(older_than:, batch_size: DEFAULT_BATCH_SIZE, now: Time.now.utc)
@@ -26,11 +28,23 @@ module LlmCostTracker
         require_relative "ingestion"
         return 0 unless LlmCostTracker::Ingestion::InboxEntry.table_exists?
 
-        LlmCostTracker::Ingestion::InboxEntry.where(tracked_at: ...cutoff).delete_all
+        scope = LlmCostTracker::Ingestion::InboxEntry.where(tracked_at: ...cutoff)
+        warn_undrained(scope.pending)
+        scope.delete_all
       end
 
       private
 
+      def warn_undrained(scope)
+        count, cost = scope.pick(Arel.sql("COUNT(*)"), Arel.sql("COALESCE(SUM(total_cost), 0)"))
+        return if count.to_i.zero?
+
+        Logging.warn(
+          "Retention.prune_inbox is deleting #{count} inbox row(s) worth #{cost} that were never drained " \
+          "into the ledger. Their spend is lost. Drain the inbox before pruning, or raise the retention window."
+        )
+      end
+
       def resolve_cutoff(older_than, now)
         cutoff = case older_than
                  when Time, DateTime then older_than.utc
@@ -58,22 +72,20 @@ module LlmCostTracker
 
       def prune_batch(cutoff, batch_size)
         LlmCostTracker::Call.transaction do
-          cache_rollups = LlmCostTracker.configuration.cache_rollups
-          rows = prunable_rows(cutoff, batch_size, with_rollup_columns: cache_rollups)
+          rows = prunable_rows(cutoff, batch_size)
           next 0 if rows.empty?
 
-          ids = cache_rollups ? rows.map(&:id) : rows
-          deleted = LlmCostTracker::Call.where(id: ids).delete_all
-          LlmCostTracker::Ledger::Rollups.decrement!(rows) if cache_rollups && deleted.positive?
+          deleted = LlmCostTracker::Call.where(id: rows.map(&:id)).delete_all
+          LlmCostTracker::Ledger::Rollups.decrement!(rows) if deleted.positive?
           deleted
         end
       end
 
-      def prunable_rows(cutoff, batch_size, with_rollup_columns:)
+      def prunable_rows(cutoff, batch_size)
         relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
-        return relation.pluck(:id) unless with_rollup_columns
-
-        relation.select(:id, :tracked_at, :total_cost, :pricing_snapshot, :provider).to_a
+        columns = [:id]
+        columns += ROLLUP_COLUMNS if LlmCostTracker::Ledger::Rollups.cache_active?
+        relation.select(*columns).to_a
       end
     end
   end

data/lib/llm_cost_tracker/tags/context.rb

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

data/lib/llm_cost_tracker/tags/sanitizer.rb

@@ -23,9 +23,9 @@ module LlmCostTracker
       class << self
         def call(tags, config: LlmCostTracker.configuration)
           tags = (tags || {}).to_h
-          redacted = config.normalized_redacted_tag_keys
-          limit = [config.max_tag_value_bytesize.to_i, 0].max
-          max_count = [config.max_tag_count.to_i, 0].max
+          redacted = config.tags.normalized_redacted_keys
+          limit = [config.tags.max_value_bytesize.to_i, 0].max
+          max_count = [config.tags.max_count.to_i, 0].max
           tags.to_a.last(max_count).each_with_object({}) do |(key, value), sanitized|
             next unless valid_key?(key)
 
@@ -43,7 +43,7 @@ module LlmCostTracker
 
         def cap(tags, config: LlmCostTracker.configuration)
           tags = (tags || {}).to_h
-          max_count = [config.max_tag_count.to_i, 0].max
+          max_count = [config.tags.max_count.to_i, 0].max
           return tags if tags.size <= max_count
 
           tags.to_a.last(max_count).to_h

data/lib/llm_cost_tracker/tracker.rb

@@ -25,25 +25,14 @@ module LlmCostTracker
           usage_source: event.usage_source
         )
 
-        if enforce_budget
-          Budget.enforce!(provider: event.provider,
-                          model: event.model,
-                          estimate: calculation.cost&.total,
-                          force: true)
-        end
+        tags = build_tags(context_tags: context_tags, metadata: metadata)
 
         if calculation.token_cost.nil? && event.token_usage.total_tokens.positive? &&
            calculation.priced_line_items.none?(&:priced?)
-          Pricing::Unknown.process(event.model)
+          Pricing::Unknown.process(event.model, pricing_mode: calculation.mode)
         end
 
-        event = build_event(
-          event: event,
-          calculation: calculation,
-          metadata: metadata,
-          latency_ms: latency_ms,
-          context_tags: context_tags
-        )
+        event = build_event(event: event, calculation: calculation, tags: tags, latency_ms: latency_ms)
 
         if Ingestion.async?
           Ingestion::Inbox.save(event)
@@ -54,11 +43,19 @@ module LlmCostTracker
 
         yield if block_given?
         notify_subscribers(event)
-        Budget.check!(event)
+        behavior_override = :raise if enforce_budget
+        Budget.check!(event, behavior_override: behavior_override)
+        Budget.check_persisted!([event], behavior_override: behavior_override) unless Ingestion.async?
 
         event
       end
 
+      def build_tags(context_tags:, metadata:)
+        resolved = (context_tags || LlmCostTracker::Tags::Context.tags).to_h
+        sanitized_metadata = LlmCostTracker::Tags::Sanitizer.call(metadata.to_h)
+        LlmCostTracker::Tags::Sanitizer.cap(resolved.merge(sanitized_metadata)).freeze
+      end
+
       private
 
       def notify_subscribers(event)
@@ -69,13 +66,12 @@ module LlmCostTracker
         Logging.warn("Subscriber raised on #{EVENT_NAME}: #{e.class}: #{e.message}")
       end
 
-      def build_event(event:, calculation:, metadata:, latency_ms:, context_tags:)
-        context_tags = (context_tags || LlmCostTracker::Tags::Context.tags).to_h
+      def build_event(event:, calculation:, tags:, latency_ms:)
         event.with(
           event_id: SecureRandom.uuid,
           pricing_mode: calculation.mode,
           cost: calculation.cost,
-          tags: build_tags(context_tags: context_tags, metadata: metadata),
+          tags: tags,
           latency_ms: finite_latency_ms(latency_ms),
           tracked_at: Time.now.utc,
           cost_status: calculation.cost_status,
@@ -84,11 +80,6 @@ module LlmCostTracker
         )
       end
 
-      def build_tags(context_tags:, metadata:)
-        sanitized_metadata = LlmCostTracker::Tags::Sanitizer.call(metadata.to_h)
-        LlmCostTracker::Tags::Sanitizer.cap(context_tags.merge(sanitized_metadata)).freeze
-      end
-
       def finite_latency_ms(latency_ms)
         return nil if latency_ms.nil?
 

data/lib/llm_cost_tracker/usage/catalog.rb

@@ -16,8 +16,7 @@ module LlmCostTracker
         "request" => "per_request",
         "session" => "per_session",
         "hour" => "per_hour",
-        "minute" => "per_minute",
-        "image" => "per_image"
+        "minute" => "per_minute"
       }.freeze
 
       class << self

data/lib/llm_cost_tracker/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module LlmCostTracker
-  VERSION = "0.13.0"
+  VERSION = "0.14.0"
 end

data/lib/llm_cost_tracker.rb

@@ -110,7 +110,12 @@ module LlmCostTracker
                      provider_workspace_id: nil,
                      pricing_mode: nil)
       require_relative "llm_cost_tracker/capture/stream_collector"
-      Budget.enforce!(provider: provider, model: model, force: true) if enforce_budget
+      if enforce_budget
+        Budget.enforce!(provider: provider,
+                        model: model,
+                        force: true,
+                        tags: Tracker.build_tags(context_tags: nil, metadata: tags))
+      end
       collector = Capture::StreamCollector.new(
         provider: provider.to_s,
         model: model,