llm_cost_tracker 0.1.0 → 0.1.2

data/lib/llm_cost_tracker/parsers/openai.rb

@@ -1,16 +1,19 @@
 # frozen_string_literal: true
 
 require "json"
+require "uri"
+
+require_relative "base"
 
 module LlmCostTracker
   module Parsers
     class Openai < Base
       HOSTS = %w[api.openai.com].freeze
-      TRACKED_PATHS = %w[/v1/chat/completions /v1/completions /v1/embeddings].freeze
+      TRACKED_PATHS = %w[/v1/chat/completions /v1/completions /v1/embeddings /v1/responses].freeze
 
       def match?(url)
         uri = URI.parse(url.to_s)
-        HOSTS.include?(uri.host) && TRACKED_PATHS.any? { |p| uri.path.start_with?(p) }
+        HOSTS.include?(uri.host.to_s.downcase) && TRACKED_PATHS.include?(uri.path)
       rescue URI::InvalidURIError
         false
       end
@@ -25,12 +28,24 @@ module LlmCostTracker
         request = safe_json_parse(request_body)
 
         {
-          provider: "openai",
+          provider: provider_for(request_url),
           model: response["model"] || request["model"],
-          input_tokens: usage["prompt_tokens"] || 0,
-          output_tokens: usage["completion_tokens"] || 0,
-          total_tokens: usage["total_tokens"] || 0
-        }
+          input_tokens: usage["prompt_tokens"] || usage["input_tokens"] || 0,
+          output_tokens: usage["completion_tokens"] || usage["output_tokens"] || 0,
+          total_tokens: usage["total_tokens"] || 0,
+          cached_input_tokens: cached_input_tokens(usage)
+        }.compact
+      end
+
+      private
+
+      def provider_for(_request_url)
+        "openai"
+      end
+
+      def cached_input_tokens(usage)
+        details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
+        details["cached_tokens"]
       end
     end
   end

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require_relative "openai"
+
+module LlmCostTracker
+  module Parsers
+    class OpenaiCompatible < Openai
+      TRACKED_PATH_SUFFIXES = %w[/chat/completions /completions /embeddings /responses].freeze
+
+      def match?(url)
+        uri = URI.parse(url.to_s)
+        !provider_for_host(uri.host).nil? && tracked_path?(uri.path)
+      rescue URI::InvalidURIError
+        false
+      end
+
+      private
+
+      def provider_for(request_url)
+        uri = URI.parse(request_url.to_s)
+        provider_for_host(uri.host) || "openai_compatible"
+      rescue URI::InvalidURIError
+        "openai_compatible"
+      end
+
+      def provider_for_host(host)
+        host = host.to_s.downcase
+        provider_name = configured_providers[host] ||
+                        configured_providers.find do |configured_host, _provider|
+                          configured_host.to_s.downcase == host
+                        end&.last
+        provider_name&.to_s
+      end
+
+      def configured_providers
+        LlmCostTracker.configuration.openai_compatible_providers
+      end
+
+      def tracked_path?(path)
+        TRACKED_PATH_SUFFIXES.any? { |suffix| path == suffix || path.end_with?(suffix) }
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/parsers/registry.rb

@@ -4,16 +4,14 @@ module LlmCostTracker
   module Parsers
     class Registry
       class << self
+        PARSERS_MUTEX = Mutex.new
+
         def parsers
-          @parsers ||= [
-            Openai.new,
-            Anthropic.new,
-            Gemini.new
-          ]
+          @parsers || PARSERS_MUTEX.synchronize { @parsers ||= default_parsers }
         end
 
         def register(parser)
-          parsers.unshift(parser)
+          PARSERS_MUTEX.synchronize { parsers.unshift(parser) }
         end
 
         def find_for(url)
@@ -21,7 +19,18 @@ module LlmCostTracker
         end
 
         def reset!
-          @parsers = nil
+          PARSERS_MUTEX.synchronize { @parsers = nil }
+        end
+
+        private
+
+        def default_parsers
+          [
+            Openai.new,
+            OpenaiCompatible.new,
+            Anthropic.new,
+            Gemini.new
+          ]
         end
       end
     end

data/lib/llm_cost_tracker/price_registry.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+require "json"
+require "yaml"
+
+module LlmCostTracker
+  module PriceRegistry
+    DEFAULT_PRICES_PATH = File.expand_path("prices.json", __dir__)
+    PRICE_KEYS = %w[input cached_input output cache_read_input cache_creation_input].freeze
+    NORMALIZE_PRICE_ENTRY = lambda do |price|
+      (price || {}).each_with_object({}) do |(key, value), normalized|
+        key = key.to_s
+        normalized[key.to_sym] = Float(value) if PRICE_KEYS.include?(key)
+      end
+    end
+    NORMALIZE_PRICE_TABLE = lambda do |table|
+      (table || {}).each_with_object({}) do |(model, price), normalized|
+        normalized[model.to_s] = NORMALIZE_PRICE_ENTRY.call(price)
+      end
+    end
+    RAW_REGISTRY = JSON.parse(File.read(DEFAULT_PRICES_PATH)).freeze
+    PRICE_METADATA = RAW_REGISTRY.fetch("metadata", {}).freeze
+    BUILTIN_PRICES = NORMALIZE_PRICE_TABLE.call(RAW_REGISTRY.fetch("models", {})).freeze
+
+    class << self
+      def builtin_prices
+        BUILTIN_PRICES
+      end
+
+      def metadata
+        PRICE_METADATA
+      end
+
+      def normalize_price_table(table)
+        NORMALIZE_PRICE_TABLE.call(table)
+      end
+
+      def file_prices(path)
+        return {} unless path
+
+        path = path.to_s
+        cache_key = [path, File.mtime(path).to_f]
+        return @file_prices if @file_prices_cache_key == cache_key
+
+        @file_prices_cache_key = cache_key
+        @file_prices = normalize_price_table(price_file_models(load_price_file(path)))
+      rescue Errno::ENOENT, JSON::ParserError, Psych::Exception, ArgumentError, TypeError => e
+        raise Error, "Unable to load prices_file #{path.inspect}: #{e.message}"
+      end
+
+      private
+
+      def load_price_file(path)
+        contents = File.read(path)
+        return YAML.safe_load(contents, aliases: false) || {} if yaml_file?(path)
+
+        JSON.parse(contents)
+      end
+
+      def yaml_file?(path)
+        %w[.yaml .yml].include?(File.extname(path).downcase)
+      end
+
+      def price_file_models(registry)
+        registry.fetch("models", registry)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/prices.json

@@ -0,0 +1,51 @@
+{
+  "metadata": {
+    "updated_at": "2026-04-18",
+    "currency": "USD",
+    "unit": "1M tokens",
+    "source_urls": [
+      "https://openai.com/api/pricing",
+      "https://www.anthropic.com/pricing",
+      "https://ai.google.dev/gemini-api/docs/pricing"
+    ]
+  },
+  "models": {
+    "gpt-5.2": { "input": 1.75, "cached_input": 0.175, "output": 14.0 },
+    "gpt-5.1": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
+    "gpt-5": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
+    "gpt-5-mini": { "input": 0.25, "cached_input": 0.025, "output": 2.0 },
+    "gpt-5-nano": { "input": 0.05, "cached_input": 0.005, "output": 0.4 },
+    "gpt-4.1": { "input": 2.0, "cached_input": 0.5, "output": 8.0 },
+    "gpt-4.1-mini": { "input": 0.4, "cached_input": 0.1, "output": 1.6 },
+    "gpt-4.1-nano": { "input": 0.1, "cached_input": 0.025, "output": 0.4 },
+    "gpt-4o-2024-05-13": { "input": 5.0, "output": 15.0 },
+    "gpt-4o": { "input": 2.5, "cached_input": 1.25, "output": 10.0 },
+    "gpt-4o-mini": { "input": 0.15, "cached_input": 0.075, "output": 0.6 },
+    "gpt-4-turbo": { "input": 10.0, "output": 30.0 },
+    "gpt-4": { "input": 30.0, "output": 60.0 },
+    "gpt-3.5-turbo": { "input": 0.5, "output": 1.5 },
+    "o1": { "input": 15.0, "cached_input": 7.5, "output": 60.0 },
+    "o1-mini": { "input": 1.1, "cached_input": 0.55, "output": 4.4 },
+    "o3": { "input": 2.0, "cached_input": 0.5, "output": 8.0 },
+    "o3-mini": { "input": 1.1, "cached_input": 0.55, "output": 4.4 },
+    "o4-mini": { "input": 1.1, "cached_input": 0.275, "output": 4.4 },
+    "claude-sonnet-4-6": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-opus-4-6": { "input": 5.0, "output": 25.0, "cache_read_input": 0.5, "cache_creation_input": 6.25 },
+    "claude-opus-4-1": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
+    "claude-opus-4": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
+    "claude-sonnet-4-5": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-sonnet-4": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-haiku-4-5": { "input": 1.0, "output": 5.0, "cache_read_input": 0.1, "cache_creation_input": 1.25 },
+    "claude-3-7-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-3-5-sonnet": { "input": 3.0, "output": 15.0, "cache_read_input": 0.3, "cache_creation_input": 3.75 },
+    "claude-3-5-haiku": { "input": 0.8, "output": 4.0, "cache_read_input": 0.08, "cache_creation_input": 1.0 },
+    "claude-3-opus": { "input": 15.0, "output": 75.0, "cache_read_input": 1.5, "cache_creation_input": 18.75 },
+    "gemini-2.5-pro": { "input": 1.25, "cached_input": 0.125, "output": 10.0 },
+    "gemini-2.5-flash": { "input": 0.3, "cached_input": 0.03, "output": 2.5 },
+    "gemini-2.5-flash-lite": { "input": 0.1, "cached_input": 0.01, "output": 0.4 },
+    "gemini-2.0-flash": { "input": 0.1, "cached_input": 0.025, "output": 0.4 },
+    "gemini-2.0-flash-lite": { "input": 0.075, "output": 0.3 },
+    "gemini-1.5-pro": { "input": 1.25, "output": 5.0 },
+    "gemini-1.5-flash": { "input": 0.075, "output": 0.3 }
+  }
+}

data/lib/llm_cost_tracker/pricing.rb

@@ -2,72 +2,107 @@
 
 module LlmCostTracker
   # Prices per 1M tokens in USD.
-  # Updated: April 2026. Override via configuration.
   module Pricing
-    PRICES = {
-      # OpenAI
-      "gpt-4o"             => { input: 2.50,  output: 10.00 },
-      "gpt-4o-mini"        => { input: 0.15,  output: 0.60 },
-      "gpt-4-turbo"        => { input: 10.00, output: 30.00 },
-      "gpt-4"              => { input: 30.00, output: 60.00 },
-      "gpt-3.5-turbo"      => { input: 0.50,  output: 1.50 },
-      "o1"                 => { input: 15.00, output: 60.00 },
-      "o1-mini"            => { input: 3.00,  output: 12.00 },
-      "o3-mini"            => { input: 1.10,  output: 4.40 },
-
-      # Anthropic
-      "claude-sonnet-4-6"  => { input: 3.00,  output: 15.00 },
-      "claude-opus-4-6"    => { input: 15.00, output: 75.00 },
-      "claude-haiku-4-5"   => { input: 0.80,  output: 4.00 },
-      "claude-3-5-sonnet-20241022" => { input: 3.00,  output: 15.00 },
-      "claude-3-5-haiku-20241022"  => { input: 0.80,  output: 4.00 },
-      "claude-3-opus-20240229"     => { input: 15.00, output: 75.00 },
-
-      # Google Gemini
-      "gemini-2.5-pro"     => { input: 1.25,  output: 10.00 },
-      "gemini-2.5-flash"   => { input: 0.15,  output: 0.60 },
-      "gemini-2.0-flash"   => { input: 0.10,  output: 0.40 },
-      "gemini-1.5-pro"     => { input: 1.25,  output: 5.00 },
-      "gemini-1.5-flash"   => { input: 0.075, output: 0.30 },
-    }.freeze
+    PRICES = PriceRegistry.builtin_prices
 
     class << self
-      def cost_for(model:, input_tokens:, output_tokens:)
+      def cost_for(model:, input_tokens:, output_tokens:, cached_input_tokens: 0,
+                   cache_read_input_tokens: 0, cache_creation_input_tokens: 0)
         prices = lookup(model)
         return nil unless prices
 
-        input_cost  = (input_tokens.to_f / 1_000_000) * prices[:input]
-        output_cost = (output_tokens.to_f / 1_000_000) * prices[:output]
+        token_counts = normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
+                                               cache_read_input_tokens, cache_creation_input_tokens)
+        costs = calculate_costs(token_counts, prices)
 
         {
-          input_cost: input_cost.round(8),
-          output_cost: output_cost.round(8),
-          total_cost: (input_cost + output_cost).round(8),
+          input_cost: costs[:input].round(8),
+          cached_input_cost: costs[:cached_input].round(8),
+          cache_read_input_cost: costs[:cache_read_input].round(8),
+          cache_creation_input_cost: costs[:cache_creation_input].round(8),
+          output_cost: costs[:output].round(8),
+          total_cost: costs.values.sum.round(8),
           currency: "USD"
         }
       end
 
       def lookup(model)
-        overrides = LlmCostTracker.configuration.pricing_overrides
-        overrides[model] || PRICES[model] || fuzzy_match(model)
+        table = prices
+        model_name = model.to_s
+        normalized_model = normalize_model_name(model_name)
+
+        table[model_name] || table[normalized_model] || fuzzy_match(model_name, normalized_model, table)
       end
 
       def models
-        PRICES.keys | LlmCostTracker.configuration.pricing_overrides.keys
+        prices.keys
+      end
+
+      def metadata
+        PriceRegistry.metadata
+      end
+
+      def prices
+        PRICES
+          .merge(PriceRegistry.file_prices(LlmCostTracker.configuration.prices_file))
+          .merge(PriceRegistry.normalize_price_table(LlmCostTracker.configuration.pricing_overrides))
       end
 
       private
 
-      # Try to match model names like "gpt-4o-2024-08-06" to "gpt-4o"
-      def fuzzy_match(model)
-        return nil unless model
+      def normalized_token_counts(input_tokens, output_tokens, cached_input_tokens,
+                                  cache_read_input_tokens, cache_creation_input_tokens)
+        cached_input_tokens = cached_input_tokens.to_i
+
+        {
+          input: [input_tokens.to_i - cached_input_tokens, 0].max,
+          cached_input: cached_input_tokens,
+          cache_read_input: cache_read_input_tokens.to_i,
+          cache_creation_input: cache_creation_input_tokens.to_i,
+          output: output_tokens.to_i
+        }
+      end
+
+      def calculate_costs(token_counts, prices)
+        {
+          input: token_cost(token_counts[:input], prices[:input]),
+          cached_input: token_cost(token_counts[:cached_input], prices[:cached_input] || prices[:input]),
+          cache_read_input: token_cost(
+            token_counts[:cache_read_input],
+            prices[:cache_read_input] || prices[:cached_input] || prices[:input]
+          ),
+          cache_creation_input: token_cost(
+            token_counts[:cache_creation_input],
+            prices[:cache_creation_input] || prices[:input]
+          ),
+          output: token_cost(token_counts[:output], prices[:output])
+        }
+      end
+
+      def token_cost(tokens, per_million_price)
+        (tokens.to_f / 1_000_000) * per_million_price
+      end
 
-        PRICES.each do |key, value|
-          return value if model.start_with?(key)
+      def normalize_model_name(model)
+        model.to_s.split("/").last
+      end
+
+      # Try to match model names like "gpt-4o-2024-08-06" to "gpt-4o".
+      def fuzzy_match(model, normalized_model, table)
+        sorted_price_keys(table).each do |key|
+          return table[key] if model.start_with?(key) || normalized_model.start_with?(key)
         end
 
         nil
       end
+
+      def sorted_price_keys(table)
+        cache_key = table.keys
+        return @sorted_price_keys if @sorted_price_keys_cache_key == cache_key
+
+        @sorted_price_keys_cache_key = cache_key
+        @sorted_price_keys = cache_key.sort_by { |key| -key.length }
+      end
     end
   end
 end

data/lib/llm_cost_tracker/railtie.rb

@@ -3,7 +3,10 @@
 module LlmCostTracker
   class Railtie < Rails::Railtie
     generators do
+      require_relative "generators/llm_cost_tracker/add_latency_ms_generator"
       require_relative "generators/llm_cost_tracker/install_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_cost_precision_generator"
+      require_relative "generators/llm_cost_tracker/upgrade_tags_to_jsonb_generator"
     end
 
     initializer "llm_cost_tracker.configure" do

data/lib/llm_cost_tracker/storage/active_record_store.rb

@@ -5,7 +5,9 @@ module LlmCostTracker
     class ActiveRecordStore
       class << self
         def save(event)
-          model_class.create!(
+          tags = stringify_tags(event[:tags] || {})
+
+          attributes = {
             provider:      event[:provider],
             model:         event[:model],
             input_tokens:  event[:input_tokens],
@@ -14,9 +16,12 @@ module LlmCostTracker
             input_cost:    event.dig(:cost, :input_cost),
             output_cost:   event.dig(:cost, :output_cost),
             total_cost:    event.dig(:cost, :total_cost),
-            tags:          event[:tags].to_json,
+            tags:          tags_for_storage(tags),
             tracked_at:    event[:tracked_at]
-          )
+          }
+          attributes[:latency_ms] = event[:latency_ms] if model_class.latency_column?
+
+          model_class.create!(attributes)
         end
 
         def monthly_total(time: Time.now.utc)
@@ -31,6 +36,22 @@ module LlmCostTracker
         def model_class
           LlmCostTracker::LlmApiCall
         end
+
+        private
+
+        def stringify_tags(tags)
+          tags.transform_keys(&:to_s).transform_values { |value| stringify_tag_value(value) }
+        end
+
+        def tags_for_storage(tags)
+          model_class.tags_json_column? ? tags : tags.to_json
+        end
+
+        def stringify_tag_value(value)
+          return value.transform_values { |nested| stringify_tag_value(nested) } if value.is_a?(Hash)
+
+          value.to_s
+        end
       end
     end
   end

data/lib/llm_cost_tracker/tracker.rb

@@ -5,21 +5,33 @@ module LlmCostTracker
     EVENT_NAME = "llm_request.llm_cost_tracker"
 
     class << self
-      def record(provider:, model:, input_tokens:, output_tokens:, metadata: {})
+      def enforce_budget!
+        Budget.enforce!
+      end
+
+      def record(provider:, model:, input_tokens:, output_tokens:, metadata: {}, latency_ms: nil)
+        usage = EventMetadata.usage_data(input_tokens, output_tokens, metadata)
+
         cost_data = Pricing.cost_for(
           model: model,
-          input_tokens: input_tokens,
-          output_tokens: output_tokens
+          input_tokens: usage[:input_tokens],
+          output_tokens: usage[:output_tokens],
+          cached_input_tokens: usage[:cached_input_tokens],
+          cache_read_input_tokens: usage[:cache_read_input_tokens],
+          cache_creation_input_tokens: usage[:cache_creation_input_tokens]
         )
 
+        UnknownPricing.handle!(model) unless cost_data
+
         event = {
           provider: provider,
           model: model,
-          input_tokens: input_tokens,
-          output_tokens: output_tokens,
-          total_tokens: input_tokens + output_tokens,
+          input_tokens: usage[:input_tokens],
+          output_tokens: usage[:output_tokens],
+          total_tokens: usage[:total_tokens],
           cost: cost_data,
-          tags: LlmCostTracker.configuration.default_tags.merge(metadata),
+          tags: LlmCostTracker.configuration.default_tags.merge(EventMetadata.tags(metadata)),
+          latency_ms: normalized_latency_ms(latency_ms),
           tracked_at: Time.now.utc
         }
 
@@ -27,10 +39,8 @@ module LlmCostTracker
         ActiveSupport::Notifications.instrument(EVENT_NAME, event)
 
         # Store based on backend
-        store(event)
-
-        # Budget check
-        check_budget(event)
+        stored = store(event)
+        Budget.check!(event) unless stored == false
 
         event
       end
@@ -48,14 +58,22 @@ module LlmCostTracker
         when :custom
           config.custom_storage&.call(event)
         end
+
+        true
+      rescue BudgetExceededError, UnknownPricingError
+        raise
+      rescue StandardError => e
+        handle_storage_error(e)
+        false
       end
 
       def log_event(event)
-        cost_str = event[:cost] ? "$#{'%.6f' % event[:cost][:total_cost]}" : "unknown"
+        cost_str = event[:cost] ? "$#{format('%.6f', event[:cost][:total_cost])}" : "unknown"
 
         message = "[LlmCostTracker] #{event[:provider]}/#{event[:model]} " \
                   "tokens=#{event[:input_tokens]}+#{event[:output_tokens]} " \
                   "cost=#{cost_str}"
+        message += " latency=#{event[:latency_ms]}ms" if event[:latency_ms]
         message += " tags=#{event[:tags]}" unless event[:tags].empty?
 
         case LlmCostTracker.configuration.log_level
@@ -71,36 +89,50 @@ module LlmCostTracker
         warn(message) unless defined?(Rails)
       end
 
+      def log_warning(message)
+        message = "[LlmCostTracker] #{message}"
+
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.warn(message)
+        else
+          warn message
+        end
+      end
+
       def store_active_record(event)
-        return unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
+        require_relative "llm_api_call" unless defined?(LlmCostTracker::LlmApiCall)
+        require_relative "storage/active_record_store" unless defined?(LlmCostTracker::Storage::ActiveRecordStore)
 
         LlmCostTracker::Storage::ActiveRecordStore.save(event)
+      rescue LoadError => e
+        raise Error, "ActiveRecord storage requires the active_record gem: #{e.message}"
       end
 
-      def check_budget(event)
-        config = LlmCostTracker.configuration
-        return unless config.monthly_budget && config.on_budget_exceeded
-        return unless event[:cost]
+      def handle_storage_error(error)
+        case storage_error_behavior
+        when :ignore
+          nil
+        when :warn
+          log_warning("Storage failed; tracking event was not persisted: #{error.class}: #{error.message}")
+        when :raise
+          storage_error = StorageError.new(error)
+          raise storage_error
+        end
+      end
 
-        monthly_total = calculate_monthly_total(event[:cost][:total_cost])
-        return unless monthly_total > config.monthly_budget
+      def storage_error_behavior
+        behavior = (LlmCostTracker.configuration.storage_error_behavior || :warn).to_sym
+        return behavior if Configuration::STORAGE_ERROR_BEHAVIORS.include?(behavior)
 
-        config.on_budget_exceeded.call(
-          monthly_total: monthly_total,
-          budget: config.monthly_budget,
-          last_event: event
-        )
+        raise Error,
+              "Unknown storage_error_behavior: #{behavior.inspect}. " \
+              "Use one of: #{Configuration::STORAGE_ERROR_BEHAVIORS.join(', ')}"
       end
 
-      def calculate_monthly_total(latest_cost)
-        # For :active_record backend, query the DB
-        if LlmCostTracker.configuration.active_record? &&
-           defined?(LlmCostTracker::Storage::ActiveRecordStore)
-          LlmCostTracker::Storage::ActiveRecordStore.monthly_total + latest_cost
-        else
-          # For other backends, we can only report the latest cost
-          latest_cost
-        end
+      def normalized_latency_ms(latency_ms)
+        return nil if latency_ms.nil?
+
+        [latency_ms.to_i, 0].max
       end
     end
   end

data/lib/llm_cost_tracker/unknown_pricing.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  class UnknownPricing
+    class << self
+      def handle!(model)
+        model = normalized_model_name(model)
+
+        case behavior
+        when :ignore
+          nil
+        when :warn
+          warn_missing(model)
+        when :raise
+          raise UnknownPricingError.new(model: model)
+        end
+      end
+
+      private
+
+      def normalized_model_name(model)
+        model.to_s.empty? ? "unknown" : model.to_s
+      end
+
+      def warn_missing(model)
+        message = "[LlmCostTracker] No pricing configured for model #{model.inspect}. " \
+                  "Cost and budget enforcement will be skipped for this event. " \
+                  "Add a pricing_overrides entry or set unknown_pricing_behavior."
+
+        if defined?(Rails) && Rails.respond_to?(:logger) && Rails.logger
+          Rails.logger.warn(message)
+        else
+          Kernel.warn(message)
+        end
+      end
+
+      def behavior
+        behavior = (LlmCostTracker.configuration.unknown_pricing_behavior || :warn).to_sym
+        return behavior if Configuration::UNKNOWN_PRICING_BEHAVIORS.include?(behavior)
+
+        raise Error,
+              "Unknown unknown_pricing_behavior: #{behavior.inspect}. " \
+              "Use one of: #{Configuration::UNKNOWN_PRICING_BEHAVIORS.join(', ')}"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/version.rb

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