llm_cost_tracker 0.14.1 → 0.14.2

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

@@ -27,39 +27,19 @@ module LlmCostTracker
           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
+          return [] unless response["choices"] && chat_completions_search_model?(model)
 
           [{ "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"].to_s == "url_citation"
-            end
-          end
+             "provider_field" => "request.model" }]
         end
 
         def billable?(item)
           return false unless item.is_a?(Hash)
 
-          dimension = output_dimension(item["type"])
+          dimension = item_dimension(item)
           return false unless dimension
+          return item["status"] == "completed" if dimension == "image_generation_call"
           return true unless dimension == "web_search_request"
 
           action_type = item.dig("action", "type")
@@ -69,11 +49,11 @@ module LlmCostTracker
         def store_output_item(output_items, item)
           return unless item.is_a?(Hash)
 
-          dimension = output_dimension(item["type"])
+          dimension = item_dimension(item)
           return unless dimension
 
-          key = if dimension == "container_session" && item["container_id"]
-                  "#{dimension}:#{item['container_id']}"
+          key = if dimension == "container_session" && container_id(item)
+                  "#{dimension}:#{container_id(item)}"
                 else
                   item["id"] || "#{item['type']}:#{output_items.length}"
                 end
@@ -87,7 +67,7 @@ module LlmCostTracker
           return nil unless dimension_key
 
           provider_item_id = if dimension_key == "container_session"
-                               item["container_id"] || item["id"]
+                               container_id(item) || item["id"]
                              else
                                item["id"]
                              end
@@ -103,13 +83,28 @@ module LlmCostTracker
         end
 
         def dimension_key_for(item, request:, model:)
-          dimension = output_dimension(item["type"])
+          dimension = item_dimension(item)
           return dimension unless dimension == "web_search_request"
           return dimension 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 item_dimension(item)
+          return "container_session" if item["type"] == "shell_call" && shell_container_id(item)
+
+          output_dimension(item["type"])
+        end
+
+        def container_id(item)
+          item["container_id"] || shell_container_id(item)
+        end
+
+        def shell_container_id(item)
+          environment = item["environment"]
+          environment["container_id"] if environment.is_a?(Hash) && environment["type"] == "container_reference"
+        end
+
         def output_dimension(type)
           key = RESPONSE_OUTPUT_RENAMES[type] || type
           dimension = Usage::Catalog[key]
@@ -144,19 +139,10 @@ module LlmCostTracker
           {
             status: item["status"],
             action_type: item.dig("action", "type"),
-            container_id: item["container_id"]
+            container_id: container_id(item)
           }.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
-
         def transcription_line_items(usage)
           return [] unless usage
 
@@ -168,13 +154,44 @@ module LlmCostTracker
 
           [Charges::LineItem.build(
             dimension_key: "transcription_minute",
-            quantity: (seconds / 60.0).ceil,
+            quantity: BigDecimal(seconds.to_s) / 60,
             cost_status: Charges::CostStatus::UNKNOWN,
             pricing_basis: "provider_usage",
             provider_field: "usage.seconds",
             details: { seconds: seconds }
           )]
         end
+
+        def speech_line_items(request)
+          input = request["input"]
+          return [] unless input.is_a?(String) && ModelFamilies.character_billed_tts?(request["model"])
+
+          [Charges::LineItem.build(
+            dimension_key: "text_to_speech_character",
+            quantity: input.length,
+            cost_status: Charges::CostStatus::UNKNOWN,
+            pricing_basis: "provider_usage",
+            provider_field: "request.input"
+          )]
+        end
+
+        # OpenRouter bills BYOK inference to the user's own provider key and puts only its fee in usage.cost.
+        def billed_line_items(usage)
+          amounts = [usage[:cost]]
+          amounts << usage.dig(:cost_details, :upstream_inference_cost) if usage[:is_byok]
+          return [] unless amounts.all?(Numeric)
+
+          amount = amounts.sum { |value| BigDecimal(value.to_s) }
+          [Charges::LineItem.build(
+            dimension_key: "billed_request",
+            quantity: 1,
+            rate_amount: amount,
+            cost: amount,
+            pricing_basis: "provider_usage",
+            price_source: "provider_response",
+            provider_field: "usage.cost"
+          )]
+        end
       end
     end
   end

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

@@ -8,9 +8,15 @@ module LlmCostTracker
       module UsageExtractor
         INPUT_DETAIL_KEYS = %i[input_tokens_details input_token_details prompt_tokens_details].freeze
         OUTPUT_DETAIL_KEYS = %i[output_tokens_details output_token_details completion_tokens_details].freeze
+        CACHED_MODALITY_DIMENSIONS = {
+          audio_tokens: "audio_cache_read_input", image_tokens: "image_cache_read_input"
+        }.freeze
+
         def self.token_usage(usage, model: nil)
           input_tokens = (usage[:input_tokens] || usage[:prompt_tokens]).to_i
           output_tokens = (usage[:output_tokens] || usage[:completion_tokens]).to_i
+          reasoning = hidden_output_tokens(usage)
+          output_tokens += reasoning if usage[:total_tokens].to_i == input_tokens + output_tokens + reasoning
           cache_read = cache_read_input_tokens(usage)
           cache_write = cache_write_input_tokens(usage)
           uncached_input = [input_tokens - cache_read - cache_write, 0].max
@@ -35,10 +41,17 @@ module LlmCostTracker
             audio_output_tokens: audio_output,
             image_input_tokens: image_input,
             image_output_tokens: image_output,
-            hidden_output_tokens: hidden_output_tokens(usage)
+            hidden_output_tokens: reasoning
           )
         end
 
+        def self.cache_read_line_items(usage)
+          CACHED_MODALITY_DIMENSIONS.filter_map do |detail_key, dimension_key|
+            quantity = detail(usage, INPUT_DETAIL_KEYS, :cached_tokens_details, detail_key)
+            Charges::LineItem.build(dimension_key: dimension_key, quantity: quantity) if quantity.positive?
+          end
+        end
+
         def self.split_output(output_tokens:,
                               image_output_details:,
                               text_output_details:,

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

@@ -10,7 +10,9 @@ module LlmCostTracker
 
         class << self
           def match?(url)
-            match_uri?(url, path_suffixes: TRACKED_PATH_SUFFIXES) { |uri| provider_for_uri(uri) }
+            uri_matches?(url) do |uri|
+              TRACKED_PATH_SUFFIXES.any? { |suffix| uri.path.to_s.end_with?(suffix) } && !provider_for_uri(uri).nil?
+            end
           end
 
           def provider_names

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.tags.report_breakdown_keys || []
+        tag_breakdowns ||= LlmCostTracker.configuration.tags.report_breakdown_keys
         aggregate = totals(scope)
 
         new(

data/lib/llm_cost_tracker/retention.rb

@@ -3,8 +3,6 @@
 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)
@@ -84,7 +82,7 @@ module LlmCostTracker
       def prunable_rows(cutoff, batch_size)
         relation = LlmCostTracker::Call.where(tracked_at: ...cutoff).order(:id).limit(batch_size).lock
         columns = [:id]
-        columns += ROLLUP_COLUMNS if LlmCostTracker::Ledger::Rollups.cache_active?
+        columns += LlmCostTracker::Ledger::Rollups::SOURCE_COLUMNS if LlmCostTracker::Ledger::Rollups.cache_active?
         relation.select(*columns).to_a
       end
     end

data/lib/llm_cost_tracker/tracker.rb

@@ -27,9 +27,6 @@ module LlmCostTracker
 
         tags = build_tags(context_tags: context_tags, metadata: metadata)
 
-        unpriced = calculation.token_cost.nil? && event.token_usage.total_tokens.positive? &&
-                   calculation.priced_line_items.none?(&:priced?)
-
         event = build_event(event: event, calculation: calculation, tags: tags, latency_ms: latency_ms)
 
         if Ingestion.async?
@@ -41,22 +38,33 @@ module LlmCostTracker
 
         yield if block_given?
         notify_subscribers(event)
-        Pricing::Unknown.process(event.model, pricing_mode: calculation.mode) if unpriced
         behavior_override = :raise if enforce_budget
-        Budget.check!(event, behavior_override: behavior_override)
-        Budget.check_persisted!([event], behavior_override: behavior_override) unless Ingestion.async?
+        begin
+          signal_unpriced(event, calculation)
+        ensure
+          Budget.check!(event, behavior_override: behavior_override)
+        end
 
         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
+        merged = resolved.merge(LlmCostTracker::Tags::Sanitizer.call(metadata.to_h))
+        LlmCostTracker::Tags::Sanitizer.cap(merged.to_a.reverse.uniq { |key, _| key.to_s }.reverse.to_h).freeze
       end
 
       private
 
+      def signal_unpriced(event, calculation)
+        iterations, lines = calculation.priced_line_items.partition { |line| line.kind == "model_iteration" }
+        models = iterations.select(&:unpriced?).map { |line| line.details[:model] }
+        if calculation.token_cost.nil? && event.token_usage.total_tokens.positive? && lines.none?(&:priced?)
+          models.unshift(event.model)
+        end
+        models.each { |model| Pricing::Unknown.process(model, pricing_mode: calculation.mode) }
+      end
+
       def notify_subscribers(event)
         return unless ActiveSupport::Notifications.notifier.listening?(EVENT_NAME)
 
@@ -67,7 +75,7 @@ module LlmCostTracker
 
       def build_event(event:, calculation:, tags:, latency_ms:)
         event.with(
-          event_id: SecureRandom.uuid,
+          event_id: event.event_id || SecureRandom.uuid,
           pricing_mode: calculation.mode,
           cost: calculation.cost,
           tags: tags,

data/lib/llm_cost_tracker/usage/catalog.rb

@@ -27,7 +27,7 @@ module LlmCostTracker
         end
 
         def token_priced
-          @token_priced ||= all.select(&:token_key).freeze
+          @token_priced ||= all.select { |dimension| dimension.token_key && dimension.parent.nil? }.freeze
         end
 
         def find_by(kind:, direction:, modality:, cache_state:, unit:)
@@ -35,8 +35,17 @@ module LlmCostTracker
         end
 
         def token_priced_for(kind:, direction:, cache_state:)
-          token_priced.find do |dimension|
-            dimension.kind == kind && dimension.direction == direction && dimension.cache_state == cache_state
+          dimension = all.find do |candidate|
+            candidate.token? && candidate.kind == kind && candidate.direction == direction &&
+              candidate.cache_state == cache_state
+          end
+          dimension&.parent ? fetch(dimension.parent) : dimension
+        end
+
+        def costs_by_component(rows)
+          rows.each_with_object({}) do |(kind, direction, cache_state, cost), totals|
+            component = token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
+            totals[component.key] = totals.fetch(component.key, 0) + cost if component && cost
           end
         end
 
@@ -60,7 +69,7 @@ module LlmCostTracker
 
         def build(attributes)
           rate_basis = attributes[:rate_basis] || DEFAULT_RATE_BASIS_BY_UNIT.fetch(attributes.fetch(:unit))
-          Dimension.new(**attributes, rate_basis: rate_basis)
+          Dimension.new(parent: nil, **attributes, rate_basis: rate_basis)
         end
       end
     end

data/lib/llm_cost_tracker/usage/dimension.rb

@@ -3,7 +3,7 @@
 module LlmCostTracker
   module Usage
     Dimension = Data.define(
-      :key, :kind, :direction, :modality, :cache_state, :unit, :rate_basis
+      :key, :kind, :direction, :modality, :cache_state, :unit, :rate_basis, :parent
     ) do
       def token?
         unit == "token"

data/lib/llm_cost_tracker/usage/dimensions.yml

@@ -61,6 +61,30 @@
   cache_state: none
   unit: token
 
+- key: audio_cache_read_input
+  kind: audio_token
+  direction: input
+  modality: audio
+  cache_state: read
+  unit: token
+  parent: cache_read_input
+
+- key: image_cache_read_input
+  kind: image_token
+  direction: input
+  modality: image
+  cache_state: read
+  unit: token
+  parent: cache_read_input
+
+- key: video_input
+  kind: video_token
+  direction: input
+  modality: video
+  cache_state: none
+  unit: token
+  parent: input
+
 - key: web_search_request
   kind: web_search_request
   direction: neither
@@ -101,6 +125,13 @@
   unit: request
   rate_basis: per_1k_requests
 
+- key: image_generation_call
+  kind: image_generation_call
+  direction: output
+  modality: image
+  cache_state: none
+  unit: request
+
 - key: container_session
   kind: container_session
   direction: neither
@@ -125,6 +156,22 @@
   unit: request
   rate_basis: per_1k_requests
 
+- key: maps_grounding_request
+  kind: maps_grounding_request
+  direction: neither
+  modality: text
+  cache_state: none
+  unit: request
+  rate_basis: per_1k_requests
+
+- key: cache_storage_token_hour
+  kind: cache_storage_token_hour
+  direction: neither
+  modality: none
+  cache_state: none
+  unit: token_hour
+  rate_basis: per_million_token_hours
+
 - key: text_to_speech_character
   kind: text_to_speech_character
   direction: output
@@ -140,3 +187,17 @@
   cache_state: none
   unit: minute
   rate_basis: per_minute
+
+- key: billed_request
+  kind: billed_request
+  direction: neither
+  modality: none
+  cache_state: none
+  unit: request
+
+- key: model_iteration
+  kind: model_iteration
+  direction: neither
+  modality: none
+  cache_state: none
+  unit: request

data/lib/llm_cost_tracker/version.rb

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

data/lib/tasks/llm_cost_tracker.rake

@@ -16,7 +16,7 @@ end
 
 # rubocop:disable-next Metrics/BlockLength
 namespace :llm_cost_tracker do
-  desc "Install LLM Cost Tracker with dashboard and prices, migrate, and run doctor"
+  desc "Install LLM Cost Tracker with a local prices file, migrate, run doctor, and print dashboard mount steps"
   task :setup do
     Rails::Generators.invoke("llm_cost_tracker:install", %w[--dashboard --prices --skip])
     begin
@@ -54,7 +54,7 @@ namespace :llm_cost_tracker do
     puts LlmCostTracker::Report.generate(days: days)
   end
 
-  desc "Recompute total_cost for calls with unknown pricing using the current price registry. " \
+  desc "Recompute total_cost for calls with unknown or partial pricing using the current price registry. " \
        "Use BATCH_SIZE=N to tune."
   task backfill_unknown_pricing: :environment do
     require_relative "../llm_cost_tracker/pricing/backfill"
@@ -64,7 +64,22 @@ namespace :llm_cost_tracker do
          "still unknown #{result.still_unknown}"
   end
 
-  desc "Delete llm_cost_tracker_calls older than DAYS (default: 90). Use BATCH_SIZE=N to tune."
+  desc "Reprice calls tracked from FROM (and before TO, if set) at the current price registry, including " \
+       "calls already priced; rollups and per-tag costs move by the difference. Use BATCH_SIZE=N to tune."
+  task reprice: :environment do
+    require_relative "../llm_cost_tracker/pricing/backfill"
+    from = Time.zone.parse(ENV["FROM"].to_s)
+    abort("llm_cost_tracker: set FROM to the first day to reprice, e.g. FROM=2026-09-01") unless from
+    to_text = ENV["TO"].presence
+    to = to_text && Time.zone.parse(to_text)
+    abort("llm_cost_tracker: TO=#{to_text} is not a date, e.g. TO=2026-10-01") if to_text && !to
+    batch_size = (ENV["BATCH_SIZE"] || LlmCostTracker::Pricing::Backfill::DEFAULT_BATCH_SIZE).to_i
+    scope = LlmCostTracker::Pricing::Backfill.reprice_scope(from...to)
+    result = LlmCostTracker::Pricing::Backfill.call(scope: scope, batch_size: batch_size, reprice: true)
+    puts "llm_cost_tracker: examined #{result.examined} calls, repriced #{result.recomputed}"
+  end
+
+  desc "Delete llm_cost_tracker_calls and ingestion inbox rows older than DAYS (default: 90). Use BATCH_SIZE=N to tune."
   task prune: :environment do
     days = (ENV["DAYS"] || 90).to_i
     batch_size = (ENV["BATCH_SIZE"] || LlmCostTracker::Retention::DEFAULT_BATCH_SIZE).to_i
@@ -98,32 +113,20 @@ namespace :llm_cost_tracker do
   namespace :prices do
     desc(
       "Refresh the configured pricing file from the maintained LLM Cost Tracker price snapshot. " \
-      "Use PREVIEW=1 to preview, FORCE=1 to accept suspicious price changes, URL=... to override the source, " \
-      "or OUTPUT=path/to/file.json."
+      "Review changes first with llm_cost_tracker:prices:check. Use FORCE=1 to accept suspicious price changes, " \
+      "URL=... to override the source, or OUTPUT=path/to/file.json."
     )
     task :refresh do
       Rake::Task["environment"].invoke if Rake::Task.task_defined?("environment")
       require_relative "../llm_cost_tracker"
 
+      abort("llm_cost_tracker: PREVIEW is not supported; run llm_cost_tracker:prices:check") if ENV.key?("PREVIEW")
+
       output_path = LlmCostTrackerTasks.price_refresh_output_path
       source_url = LlmCostTracker::Pricing::Sync.configured_remote_url
-      preview = ENV["PREVIEW"] == "1"
-      result = LlmCostTracker::Pricing::Sync.refresh(
-        path: output_path,
-        url: source_url,
-        preview: preview,
-        force: ENV["FORCE"] == "1"
-      )
-
-      action = if preview
-                 "previewed"
-               elsif result.written
-                 "refreshed"
-               else
-                 "kept"
-               end
+      result = LlmCostTracker::Pricing::Sync.refresh(path: output_path, url: source_url, force: ENV["FORCE"] == "1")
 
-      puts "llm_cost_tracker: #{action} pricing file #{result.path}"
+      puts "llm_cost_tracker: #{result.written ? 'refreshed' : 'kept'} pricing file #{result.path}"
       puts "  source: #{result.source_url}"
       puts "  version: #{result.source_version.inspect}" if result.source_version
       LlmCostTracker::Pricing::Sync::ChangePrinter.call(result.changes, suspicious: result.suspicious)

data/llm_cost_tracker.gemspec

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+require_relative "lib/llm_cost_tracker/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "llm_cost_tracker"
+  spec.version       = LlmCostTracker::VERSION
+  spec.authors       = ["Sergii Khomenko"]
+  spec.email         = ["sergey@mm.st"]
+
+  spec.summary       = "LLM API cost tracking for Rails applications"
+  spec.description   = "Logs every call your Rails app makes to OpenAI, Anthropic, Gemini, RubyLLM, " \
+                       "or an OpenAI-compatible API: tokens, cost, latency, tags. Calls go straight " \
+                       "to the provider — no proxy. Includes price sync, budget guardrails, and a " \
+                       "mountable dashboard."
+  spec.homepage      = "https://github.com/sergey-homenko/llm_cost_tracker"
+  spec.license       = "MIT"
+
+  spec.required_ruby_version = ">= 3.3.0"
+
+  spec.metadata["bug_tracker_uri"] = "#{spec.homepage}/issues"
+  spec.metadata["changelog_uri"]   = "#{spec.homepage}/blob/main/CHANGELOG.md"
+  spec.metadata["source_code_uri"] = spec.homepage
+  spec.metadata["documentation_uri"] = "#{spec.homepage}#readme"
+  spec.metadata["rubygems_mfa_required"] = "true"
+
+  spec.files = Dir.chdir(__dir__) do
+    `git ls-files -z`.split("\x0").reject do |f|
+      (File.expand_path(f) == __FILE__) ||
+        f.start_with?("bin/",
+                      "test/",
+                      "spec/",
+                      "scripts/",
+                      "docs/",
+                      ".git",
+                      ".github",
+                      "gemfiles/",
+                      ".rubocop",
+                      "Gemfile") ||
+        f == "codecov.yml"
+    end
+  end
+
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "activerecord", ">= 8.0", "< 9.0"
+  spec.add_dependency "activesupport", ">= 8.0", "< 9.0"
+  spec.add_dependency "csv", "~> 3.0"
+  spec.add_dependency "faraday", ">= 2.0", "< 3.0"
+  spec.add_dependency "railties", ">= 8.0", "< 9.0"
+
+  spec.add_development_dependency "anthropic", "~> 1.61"
+  spec.add_development_dependency "nokogiri", "~> 1.19"
+  spec.add_development_dependency "openai", "~> 0.80"
+  spec.add_development_dependency "pg", "~> 1.6"
+  spec.add_development_dependency "rake", "~> 13.0"
+  spec.add_development_dependency "rspec", "~> 3.0"
+  spec.add_development_dependency "rubocop", "~> 1.0"
+  spec.add_development_dependency "ruby_llm", ">= 1.16", "< 3"
+  spec.add_development_dependency "simplecov", "~> 0.22"
+  spec.add_development_dependency "simplecov-lcov", "~> 0.8"
+  spec.add_development_dependency "webmock", "~> 3.0"
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.14.1
+  version: 0.14.2
 platform: ruby
 authors:
 - Sergii Khomenko
@@ -15,7 +15,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -25,7 +25,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -35,7 +35,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -45,7 +45,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -89,7 +89,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -99,7 +99,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '7.1'
+        version: '8.0'
     - - "<"
       - !ruby/object:Gem::Version
         version: '9.0'
@@ -482,6 +482,7 @@ files:
 - lib/llm_cost_tracker/usage/token_usage.rb
 - lib/llm_cost_tracker/version.rb
 - lib/tasks/llm_cost_tracker.rake
+- llm_cost_tracker.gemspec
 homepage: https://github.com/sergey-homenko/llm_cost_tracker
 licenses:
 - MIT