llm_cost_tracker 0.11.0 → 0.12.0

data/lib/llm_cost_tracker/{billing → charges}/line_item.rb

@@ -2,11 +2,12 @@
 
 require "bigdecimal"
 
-require_relative "components"
+require_relative "../currency"
+require_relative "../usage/catalog"
 require_relative "cost_status"
 
 module LlmCostTracker
-  module Billing
+  module Charges
     LineItem = Data.define(
       :kind,
       :direction,
@@ -29,26 +30,24 @@ module LlmCostTracker
     )
 
     class LineItem
-      USD = "USD"
-
       def self.build(attributes)
         attributes = attributes.to_h
-        component = component_for(attributes)
+        dimension = dimension_for(attributes)
         new(
-          kind: symbol_or_nil(attributes[:kind]) || component&.kind,
-          direction: symbol_or_nil(attributes[:direction]) || component&.direction,
-          modality: symbol_or_nil(attributes[:modality]) || component&.modality,
-          cache_state: symbol_or_nil(attributes[:cache_state]) || component&.cache_state,
-          quantity: decimal_or_zero(attributes[:quantity]),
-          unit: symbol_or_nil(attributes[:unit]) || component&.unit,
+          kind: attributes[:kind]&.to_s || dimension&.kind,
+          direction: attributes[:direction]&.to_s || dimension&.direction,
+          modality: attributes[:modality]&.to_s || dimension&.modality,
+          cache_state: attributes[:cache_state]&.to_s || dimension&.cache_state || "none",
+          quantity: decimal_or_nil(attributes[:quantity]) || BigDecimal("0"),
+          unit: attributes[:unit]&.to_s || dimension&.unit,
           rate_amount: decimal_or_nil(attributes[:rate_amount]),
           rate_quantity: decimal_or_nil(attributes[:rate_quantity]) || BigDecimal("1"),
           cost: decimal_or_nil(attributes[:cost]),
-          currency: attributes[:currency] || USD,
+          currency: canonical_currency(attributes[:currency]),
           cost_status: cost_status_for(attributes),
-          pricing_basis: symbol_or_nil(attributes[:pricing_basis]),
-          price_key: attributes[:price_key],
-          price_source: symbol_or_nil(attributes[:price_source]),
+          pricing_basis: attributes[:pricing_basis]&.to_s,
+          price_key: attributes[:price_key]&.to_s,
+          price_source: attributes[:price_source]&.to_s,
           price_source_version: attributes[:price_source_version],
           provider_field: attributes[:provider_field],
           provider_item_id: attributes[:provider_item_id],
@@ -62,14 +61,14 @@ module LlmCostTracker
         token_usage.priced_quantities.filter_map do |key, quantity|
           next unless quantity.positive?
 
-          component = Components::BY_KEY.fetch(key)
+          dimension = Usage::Catalog.fetch(key)
           build(
-            kind: component.kind,
-            direction: component.direction,
-            modality: component.modality,
-            cache_state: component.cache_state,
+            kind: dimension.kind,
+            direction: dimension.direction,
+            modality: dimension.modality,
+            cache_state: dimension.cache_state,
             quantity: quantity,
-            unit: component.unit
+            unit: dimension.unit
           )
         end
       end
@@ -84,17 +83,11 @@ module LlmCostTracker
         cost.zero? ? CostStatus::FREE : CostStatus::COMPLETE
       end
 
-      def self.component_for(attributes)
-        component_key = attributes[:component_key] || attributes[:price_key]
-        return nil unless component_key
-
-        Components::BY_KEY[component_key.to_sym]
-      end
-
-      def self.symbol_or_nil(value)
-        return nil if value.nil?
+      def self.dimension_for(attributes)
+        dimension_key = attributes[:dimension_key] || attributes[:price_key]
+        return nil unless dimension_key
 
-        value.to_s.to_sym
+        Usage::Catalog[dimension_key.to_s]
       end
 
       def self.decimal_or_nil(value)
@@ -103,11 +96,11 @@ module LlmCostTracker
         BigDecimal(value.to_s)
       end
 
-      def self.decimal_or_zero(value)
-        decimal_or_nil(value) || BigDecimal("0")
+      def self.canonical_currency(value)
+        (value || LlmCostTracker::DEFAULT_CURRENCY).to_s.upcase
       end
 
-      private_class_method :cost_status_for, :component_for, :symbol_or_nil, :decimal_or_nil, :decimal_or_zero
+      private_class_method :cost_status_for, :dimension_for, :decimal_or_nil, :canonical_currency
 
       def billable?
         quantity.positive?
@@ -122,7 +115,12 @@ module LlmCostTracker
       end
 
       def token?
-        unit == :token
+        unit == "token"
+      end
+
+      def dimension
+        Usage::Catalog[price_key] ||
+          Usage::Catalog.token_priced_for(kind: kind, direction: direction, cache_state: cache_state)
       end
 
       def cost_value
@@ -130,18 +128,16 @@ module LlmCostTracker
       end
 
       def with_rate(rate)
-        rate_amount = rate.fetch(:amount)
-        rate_quantity = rate.fetch(:quantity)
-        applied_cost = (quantity / rate_quantity) * rate_amount
+        applied_cost = (quantity / rate.quantity) * rate.amount
         with(
-          rate_amount: rate_amount,
-          rate_quantity: rate_quantity,
+          rate_amount: rate.amount,
+          rate_quantity: rate.quantity,
           cost: applied_cost,
-          currency: rate.fetch(:currency),
+          currency: rate.currency.upcase,
           cost_status: applied_cost.zero? ? CostStatus::FREE : CostStatus::COMPLETE,
-          price_key: rate.fetch(:source_key),
-          price_source: rate.fetch(:source),
-          price_source_version: rate.fetch(:source_version)
+          price_key: rate.source_key,
+          price_source: rate.source,
+          price_source_version: rate.source_version
         )
       end
 

data/lib/llm_cost_tracker/check.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  Check = Data.define(:status, :name, :message)
+end

data/lib/llm_cost_tracker/configuration.rb

@@ -17,8 +17,7 @@ module LlmCostTracker
     INGESTION_MODES = %i[inline async].freeze
     SCALAR_ATTRIBUTES = %i[enabled default_tags on_budget_exceeded monthly_budget daily_budget per_call_budget
                            log_level prices_file max_tag_count max_tag_value_bytesize
-                           ingestion_pool_size auto_enable_stream_usage cache_rollups
-                           reconciliation_enabled].freeze
+                           ingestion_pool_size auto_enable_stream_usage cache_rollups].freeze
     ENUM_ATTRIBUTES = {
       budget_exceeded_behavior: [BUDGET_EXCEEDED_BEHAVIORS, :notify],
       unknown_pricing_behavior: [UNKNOWN_PRICING_BEHAVIORS, :warn],
@@ -35,8 +34,7 @@ module LlmCostTracker
       :report_tag_breakdowns,
       :redacted_tag_keys,
       :unknown_pricing_behavior,
-      :openai_compatible_providers,
-      :reconciliation_importers
+      :openai_compatible_providers
     )
 
     def initialize
@@ -58,36 +56,12 @@ module LlmCostTracker
       @report_tag_breakdowns = []
       @redacted_tag_keys = DEFAULT_REDACTED_TAG_KEYS.dup
       self.openai_compatible_providers = OPENAI_COMPATIBLE_PROVIDERS
-      @reconciliation_importers = {}
-      @reconciliation_enabled = false
       @auto_enable_stream_usage = true
       self.ingestion = :inline
       @cache_rollups = false
       @finalized = false
     end
 
-    def reconciliation_importers=(importers)
-      ensure_mutable!
-      raise Error, RECONCILIATION_DISABLED_MESSAGE unless @reconciliation_enabled
-
-      @reconciliation_importers = (importers || {}).to_h do |source, importer|
-        raise Error, "reconciliation_importers[#{source}] must respond to call" unless importer.respond_to?(:call)
-
-        [source.to_sym, importer]
-      end
-    end
-
-    def register_reconciliation_importer(source, &block)
-      ensure_mutable!
-      raise Error, RECONCILIATION_DISABLED_MESSAGE unless @reconciliation_enabled
-      raise Error, "register_reconciliation_importer requires a block" unless block
-
-      @reconciliation_importers[source.to_sym] = block
-    end
-
-    RECONCILIATION_DISABLED_MESSAGE = "reconciliation is disabled; set config.reconciliation_enabled = true first"
-    private_constant :RECONCILIATION_DISABLED_MESSAGE
-
     def openai_compatible_providers=(providers)
       ensure_mutable!
       @openai_compatible_providers = normalize_openai_compatible_providers(providers)
@@ -95,8 +69,8 @@ module LlmCostTracker
 
     def pricing_overrides=(value)
       ensure_mutable!
-      @pricing_overrides = Pricing::Registry.normalize_price_table(value || {})
-    rescue ArgumentError => e
+      @pricing_overrides = Pricing::Registry.normalize_price_entries(value || {}, context: "pricing_overrides")
+    rescue ArgumentError, TypeError => e
       raise Error, "invalid pricing_overrides: #{e.message}"
     end
 
@@ -112,7 +86,9 @@ module LlmCostTracker
 
     def instrument(*names)
       ensure_mutable!
-      @instrumented_integrations.merge(normalize_instrumentation_names(names))
+      names = names.flatten
+      names = Integrations.names if names == [:all]
+      @instrumented_integrations.merge(names)
     end
 
     def instrumented?(name)
@@ -150,6 +126,12 @@ module LlmCostTracker
         Array(@redacted_tag_keys).map { |key| Tags::Sanitizer.normalized_key(key) }.freeze
     end
 
+    def static_sanitized_default_tags
+      return nil if @default_tags.respond_to?(:call)
+
+      @static_sanitized_default_tags ||= Tags::Sanitizer.call((@default_tags || {}).to_h).freeze
+    end
+
     def finalized?
       @finalized
     end
@@ -169,19 +151,6 @@ module LlmCostTracker
       end
     end
 
-    def normalize_instrumentation_names(names)
-      names = names.flatten
-      integrations = Integrations.names
-      return integrations if names == [:all]
-
-      names.each do |name|
-        next if integrations.include?(name)
-
-        raise Error, "Unknown integration: #{name.inspect}. Use one of: #{integrations.join(', ')}"
-      end
-      names
-    end
-
     def ensure_mutable!
       return unless finalized?
 

data/lib/llm_cost_tracker/currency.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  DEFAULT_CURRENCY = "USD"
+end

data/lib/llm_cost_tracker/doctor/ingestion_check.rb

@@ -1,39 +1,18 @@
 # frozen_string_literal: true
 
-require_relative "check"
+require_relative "../check"
 require_relative "probe"
 require_relative "../ingestion"
 
 module LlmCostTracker
   class Doctor
     class IngestionCheck
-      PENDING_AGE_WARNING_SECONDS = 60
-
       def call
         return unless Probe.table_exists?("llm_cost_tracker_calls")
         return inline_check unless LlmCostTracker::Ingestion.async?
 
         missing = missing_parts
-        if missing.empty?
-          inbox = inbox_snapshot
-          quarantined = inbox.try(:quarantined_count).to_i
-          if quarantined.positive?
-            return Check.new(:warn, "async ingestion", "#{quarantined} inbox entries quarantined after retries")
-          end
-
-          pending_count = inbox.try(:pending_count).to_i
-          oldest_pending_at = inbox.try(:oldest_pending_at)&.to_time&.utc
-          pending_age = oldest_pending_at && (Time.now.utc - oldest_pending_at)
-          if pending_count.positive? && pending_age && pending_age >= PENDING_AGE_WARNING_SECONDS
-            return Check.new(
-              :warn,
-              "async ingestion",
-              "#{pending_count} inbox entries pending; oldest pending age #{pending_age.round}s"
-            )
-          end
-
-          return Check.new(:ok, "async ingestion", "inbox and ingestion lease tables available")
-        end
+        return async_ok if missing.empty?
 
         Check.new(
           :error,
@@ -44,14 +23,16 @@ module LlmCostTracker
 
       private
 
+      def async_ok
+        Check.new(:ok, "async ingestion", "inbox and ingestion lease tables available")
+      end
+
       def inline_check
         leftovers = inline_leftover_tables
         if leftovers.empty?
-          return Check.new(
-            :ok,
-            "inline ingestion",
-            "config.ingestion = :inline; events write directly to the ledger"
-          )
+          return Check.new(:ok,
+                           "inline ingestion",
+                           "config.ingestion = :inline; events write directly to the ledger")
         end
 
         Check.new(
@@ -63,33 +44,18 @@ module LlmCostTracker
       end
 
       def inline_leftover_tables
-        [
-          LlmCostTracker::Ingestion::InboxEntry.table_name,
-          LlmCostTracker::Ingestion::Lease.table_name
-        ].select { |table| Probe.table_exists?(table) }
+        async_tables.select { |table| Probe.table_exists?(table) }
       end
 
       def missing_parts
+        async_tables.reject { |table| Probe.table_exists?(table) }
+      end
+
+      def async_tables
         [
           LlmCostTracker::Ingestion::InboxEntry.table_name,
           LlmCostTracker::Ingestion::Lease.table_name
-        ].reject { |table| Probe.table_exists?(table) }
-      end
-
-      def inbox_snapshot
-        max_attempts = LlmCostTracker::Ingestion::InboxEntry::MAX_ATTEMPTS_BEFORE_QUARANTINE
-        LlmCostTracker::Ingestion::InboxEntry
-          .select(
-            "COALESCE(SUM(CASE WHEN attempts >= #{max_attempts} " \
-            "THEN 1 ELSE 0 END), 0) AS quarantined_count, " \
-            "COALESCE(SUM(CASE WHEN attempts < #{max_attempts} " \
-            "THEN 1 ELSE 0 END), 0) AS pending_count, " \
-            "MIN(CASE WHEN attempts < #{max_attempts} " \
-            "THEN created_at ELSE NULL END) AS oldest_pending_at"
-          )
-          .take
-      rescue StandardError
-        nil
+        ]
       end
     end
   end

data/lib/llm_cost_tracker/doctor/price_check.rb

@@ -2,7 +2,7 @@
 
 require "date"
 
-require_relative "check"
+require_relative "../check"
 
 module LlmCostTracker
   class Doctor

data/lib/llm_cost_tracker/doctor/probe.rb

@@ -5,11 +5,10 @@ require_relative "../ledger"
 module LlmCostTracker
   class Doctor
     module Probe
-      module_function
-
-      def table_exists?(name)
+      def self.table_exists?(name)
         LlmCostTracker::Call.connection.data_source_exists?(name)
-      rescue StandardError
+      rescue ActiveRecord::ConnectionNotEstablished, ActiveRecord::NoDatabaseError,
+             ActiveRecord::ConnectionFailed, ActiveRecord::StatementInvalid
         false
       end
     end

data/lib/llm_cost_tracker/doctor/schema_check.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
-require_relative "check"
+require_relative "../check"
 require_relative "probe"
 require_relative "../ledger"
 
 module LlmCostTracker
   class Doctor
     class SchemaCheck
-      def initialize(name:, schema:, table:, optional: false, install_command: "llm_cost_tracker:install")
+      def initialize(name:, schema:, table:)
         @name = name
         @schema = schema
         @table = table
-        @optional = optional
-        @install_command = install_command
       end
 
       def call
         return unless Probe.table_exists?("llm_cost_tracker_calls")
-        return if @optional && !Probe.table_exists?(@table)
 
         errors = @schema.current_schema_errors
         return Check.new(:ok, @name, "#{@table} exists") if errors.empty?
@@ -26,7 +23,7 @@ module LlmCostTracker
           :error,
           @name,
           "current schema required; #{errors.join('; ')}; " \
-          "run bin/rails generate #{@install_command} && bin/rails db:migrate"
+          "run bin/rails generate llm_cost_tracker:install && bin/rails db:migrate"
         )
       end
     end

data/lib/llm_cost_tracker/doctor.rb

@@ -1,25 +1,18 @@
 # frozen_string_literal: true
 
 require_relative "ledger"
-require_relative "doctor/check"
+require_relative "check"
 require_relative "doctor/probe"
 require_relative "doctor/ingestion_check"
-require_relative "doctor/legacy_audit_check"
-require_relative "doctor/legacy_billing_status_check"
 require_relative "doctor/price_check"
 require_relative "doctor/schema_check"
-require_relative "doctor/cost_drift_check"
-require_relative "doctor/pricing_snapshot_drift_check"
 
 module LlmCostTracker
   class Doctor
-    autoload :InvoiceReconciliationCheck, "llm_cost_tracker/doctor/invoice_reconciliation_check"
-    autoload :CaptureVerifier,            "llm_cost_tracker/doctor/capture_verifier"
-
     STATUS_GLYPHS = { ok: "✓", warn: "!", error: "x" }.freeze
     STATUS_COLORS = { ok: 32, warn: 33, error: 31 }.freeze
 
-    SECTIONS = ["Setup", "Schema", "Data integrity", "Operations"].freeze
+    SECTIONS = %w[Setup Schema Operations].freeze
 
     SECTION_FOR_CHECK = {
       "configuration" => "Setup",
@@ -29,13 +22,6 @@ module LlmCostTracker
       "llm_cost_tracker_calls columns" => "Schema",
       "call line items" => "Schema",
       "call tags" => "Schema",
-      "provider invoices" => "Schema",
-      "provider invoice imports" => "Schema",
-      "cost drift" => "Data integrity",
-      "pricing snapshot drift" => "Data integrity",
-      "pricing snapshot audit" => "Data integrity",
-      "cost status" => "Data integrity",
-      "invoice reconciliation" => "Data integrity",
       "call rollups" => "Operations",
       "inline ingestion" => "Operations",
       "async ingestion" => "Operations",
@@ -103,12 +89,6 @@ module LlmCostTracker
         table_check,
         column_check,
         *dependent_core_schema_checks,
-        *reconciliation_schema_checks,
-        CostDriftCheck.new.call,
-        PricingSnapshotDriftCheck.new.call,
-        *reconciliation_invoice_check,
-        LegacyBillingStatusCheck.new.call,
-        LegacyAuditCheck.new.call,
         call_rollups_check,
         IngestionCheck.new.call,
         PriceCheck.new.call,
@@ -121,26 +101,11 @@ module LlmCostTracker
     def dependent_core_schema_checks
       Ledger::Schema::CORE_SCHEMAS.reject { |schema, _| schema == Ledger::Schema::Calls }.map do |schema, table|
         SchemaCheck.new(name: table.delete_prefix("llm_cost_tracker_").tr("_", " "),
-                        schema: schema, table: table).call
+                        schema: schema,
+                        table: table).call
       end
     end
 
-    def reconciliation_schema_checks
-      return [] unless LlmCostTracker.reconciliation_enabled?
-
-      Reconciliation::SCHEMA_TABLES.map do |schema, table|
-        SchemaCheck.new(name: table.delete_prefix("llm_cost_tracker_").tr("_", " "),
-                        schema: schema, table: table,
-                        optional: false, install_command: "llm_cost_tracker:reconciliation").call
-      end.compact
-    end
-
-    def reconciliation_invoice_check
-      return [] unless LlmCostTracker.reconciliation_enabled?
-
-      Array(InvoiceReconciliationCheck.new.call)
-    end
-
     def configuration_check
       config = LlmCostTracker.configuration
       Check.new(:ok, "configuration", "active_record ledger enabled=#{config.enabled}")
@@ -202,7 +167,7 @@ module LlmCostTracker
       return live_rollups_check unless LlmCostTracker.configuration.cache_rollups
 
       errors = LlmCostTracker::Ledger::Schema::CallRollups.current_schema_errors
-      return rollups_drift_check if errors.empty?
+      return Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists") if errors.empty?
 
       Check.new(
         :error,
@@ -211,35 +176,6 @@ module LlmCostTracker
       )
     end
 
-    ROLLUPS_DRIFT_TOLERANCE_PERCENT = 1.0
-    private_constant :ROLLUPS_DRIFT_TOLERANCE_PERCENT
-
-    def rollups_drift_check
-      drift_window = Time.now.utc.beginning_of_day
-      calls_total = LlmCostTracker::Call
-                    .where(tracked_at: drift_window..)
-                    .where.not(total_cost: nil)
-                    .sum(:total_cost)
-      rollup_total = LlmCostTracker::CallRollup
-                     .where(period: "day", period_start: drift_window.to_date)
-                     .sum(:total_cost)
-      return Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists") if calls_total.zero?
-
-      drift_percent = ((calls_total - rollup_total).abs * 100.0 / calls_total)
-      if drift_percent > ROLLUPS_DRIFT_TOLERANCE_PERCENT
-        return Check.new(
-          :warn, "call rollups",
-          "rollups drift detected: today's calls SUM=#{calls_total} vs rollups SUM=#{rollup_total} " \
-          "(#{drift_percent.round(2)}% > #{ROLLUPS_DRIFT_TOLERANCE_PERCENT}% threshold). " \
-          "Cached budget reads may understate spend until a rebuild."
-        )
-      end
-
-      Check.new(:ok, "call rollups", "llm_cost_tracker_call_rollups exists")
-    rescue StandardError => e
-      Check.new(:warn, "call rollups", "rollups drift check failed: #{e.class}: #{e.message}")
-    end
-
     def live_rollups_check
       if Probe.table_exists?("llm_cost_tracker_call_rollups")
         Check.new(

data/lib/llm_cost_tracker/engine.rb

@@ -9,12 +9,12 @@ module LlmCostTracker
   class Engine < ::Rails::Engine
     isolate_namespace LlmCostTracker
 
-    initializer "llm_cost_tracker.filter_parameters" do |app|
-      app.config.filter_parameters += %i[tag tag_value]
-    end
-
     initializer "llm_cost_tracker.dashboard_setup_state" do |app|
       app.reloader.to_prepare { LlmCostTracker::Dashboard::SetupState.reset! }
     end
+
+    initializer "llm_cost_tracker.pricing_cache" do |app|
+      app.reloader.to_prepare { LlmCostTracker::Pricing::Registry.reset! }
+    end
   end
 end

data/lib/llm_cost_tracker/event.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "pricing/mode"
-require_relative "billing/line_item"
-
 module LlmCostTracker
   Event = Data.define(
     :event_id,
@@ -19,38 +16,30 @@ module LlmCostTracker
     :provider_project_id,
     :provider_api_key_id,
     :provider_workspace_id,
-    :batch,
     :tracked_at,
     :cost_status,
     :pricing_snapshot,
     :line_items
   ) do
-    def self.batch_from_pricing_mode?(pricing_mode)
-      pricing_mode.to_s.split("_").include?("batch")
-    end
-
     def self.build(**attributes)
-      pricing_mode = Pricing::Mode.normalize(attributes[:pricing_mode])
       token_usage = attributes.fetch(:token_usage)
-      batch = attributes[:batch].nil? ? batch_from_pricing_mode?(pricing_mode) : attributes[:batch]
-      line_items = attributes[:line_items] || resolve_line_items(attributes[:service_line_items], token_usage)
+      line_items = attributes[:line_items] || resolve_line_items(attributes[:service_line_items])
 
       new(
         event_id: attributes[:event_id],
         provider: attributes.fetch(:provider).to_s,
         model: attributes.fetch(:model).to_s.strip.presence || Event::UNKNOWN_MODEL,
         token_usage: token_usage,
-        pricing_mode: pricing_mode,
+        pricing_mode: attributes[:pricing_mode],
         cost: attributes[:cost],
         tags: attributes[:tags],
         latency_ms: attributes[:latency_ms],
         stream: attributes[:stream] || false,
-        usage_source: attributes[:usage_source],
+        usage_source: attributes[:usage_source]&.to_s,
         provider_response_id: attributes[:provider_response_id].to_s.strip.presence,
         provider_project_id: attributes[:provider_project_id].to_s.strip.presence,
         provider_api_key_id: attributes[:provider_api_key_id].to_s.strip.presence,
         provider_workspace_id: attributes[:provider_workspace_id].to_s.strip.presence,
-        batch: batch,
         tracked_at: attributes[:tracked_at],
         cost_status: attributes[:cost_status],
         pricing_snapshot: attributes[:pricing_snapshot],
@@ -58,21 +47,24 @@ module LlmCostTracker
       )
     end
 
-    def self.resolve_line_items(service_items, token_usage)
-      service_line_items = Array(service_items).map do |item|
-        item.is_a?(Billing::LineItem) ? item : Billing::LineItem.build(item)
+    def batch?
+      pricing_mode.to_s.split("_").include?("batch")
+    end
+
+    def self.resolve_line_items(service_items)
+      Array(service_items).map do |item|
+        item.is_a?(Charges::LineItem) ? item : Charges::LineItem.build(item)
       end
-      Billing::LineItem.from_token_usage(token_usage) + service_line_items
     end
 
     def total_cost
-      cost&.fetch(:total_cost, nil)
+      cost&.total
     end
 
     def to_h
       super.merge(
         token_usage: token_usage.to_h,
-        cost: cost && cost.to_h.transform_values { |v| v.is_a?(BigDecimal) ? v.to_f : v },
+        cost: cost&.to_h,
         tags: tags ? tags.to_h : {},
         line_items: (line_items || []).map(&:to_h)
       )

data/lib/llm_cost_tracker/generators/llm_cost_tracker/install_generator.rb

@@ -2,10 +2,9 @@
 
 require "rails/generators"
 require "rails/generators/active_record"
-require "llm_cost_tracker/billing/components"
-require "llm_cost_tracker/billing/cost_status"
+require "llm_cost_tracker/charges/cost_status"
 require "llm_cost_tracker/pricing"
-require "llm_cost_tracker/token_usage"
+require "llm_cost_tracker/usage/token_usage"
 
 module LlmCostTracker
   module Generators