llm_cost_tracker 0.10.0 → 0.11.0

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

@@ -0,0 +1,157 @@
+# frozen_string_literal: true
+
+require_relative "../../billing/line_item"
+require_relative "model_families"
+
+module LlmCostTracker
+  module Providers
+    module Openai
+      module ServiceCharges
+        RESPONSE_OUTPUT_COMPONENTS = {
+          "web_search_call" => :web_search_request,
+          "file_search_call" => :file_search_call,
+          "code_interpreter_call" => :container_session,
+          "mcp_call" => :mcp_call
+        }.freeze
+
+        module_function
+
+        def line_items_from_output(output_items, request: nil, model: nil)
+          deduped = {}
+          Array(output_items).each { |item| store_output_item(deduped, item) }
+          deduped.values
+                 .select { |item| billable?(item) }
+                 .filter_map { |item| build_line_item(item, request: request, model: model) }
+        end
+
+        def service_line_items_for(response, request: nil, model: nil)
+          output_items = Array(response["output"])
+          output_items += chat_completions_web_search_items(response, model: model) if output_items.empty?
+          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
+
+          [{ "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"] == "url_citation"
+            end
+          end
+        end
+
+        def billable?(item)
+          return false unless item.is_a?(Hash)
+
+          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+          return false unless component
+          return true unless component == :web_search_request
+
+          action_type = item.dig("action", "type")
+          action_type.nil? || action_type == "search"
+        end
+
+        def store_output_item(output_items, item)
+          return unless item.is_a?(Hash) && RESPONSE_OUTPUT_COMPONENTS.key?(item["type"])
+
+          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+          key = if component == :container_session && item["container_id"]
+                  "#{component}:#{item['container_id']}"
+                else
+                  item["id"] || "#{item['type']}:#{output_items.length}"
+                end
+          output_items[key] = item
+        end
+
+        def build_line_item(item, request: nil, model: nil)
+          return nil unless item.is_a?(Hash)
+
+          component_key = component_key_for(item, request: request, model: model)
+          return nil unless component_key
+
+          provider_item_id = if component_key == :container_session
+                               item["container_id"] || item["id"]
+                             else
+                               item["id"]
+                             end
+          Billing::LineItem.build(
+            component_key: component_key,
+            quantity: 1,
+            cost_status: Billing::CostStatus::UNKNOWN,
+            pricing_basis: :provider_usage,
+            provider_field: item["provider_field"] || "response.output.#{item['type']}",
+            provider_item_id: provider_item_id,
+            details: line_item_details(item)
+          )
+        end
+
+        def component_key_for(item, request:, model:)
+          component = RESPONSE_OUTPUT_COMPONENTS[item["type"]]
+          return component unless component == :web_search_request
+          return component 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 web_search_preview_used?(request)
+          tools = request && (request[:tools] || request["tools"])
+          return false unless tools.respond_to?(:each)
+
+          tools.any? do |tool|
+            type = tool.is_a?(Hash) ? (tool[:type] || tool["type"]) : tool
+            type.to_s.include?("web_search_preview")
+          end
+        end
+
+        def chat_completions_search_model?(model)
+          return false unless model
+
+          name = model.to_s.split("/", 2).last
+          ModelFamilies.chat_completions_search?(name)
+        end
+
+        def reasoning_model?(model)
+          return false unless model
+
+          name = model.to_s.split("/", 2).last
+          ModelFamilies.reasoning?(name)
+        end
+
+        def line_item_details(item)
+          {
+            "status" => item["status"],
+            "action_type" => item.dig("action", "type"),
+            "container_id" => item["container_id"]
+          }.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
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/railtie.rb

@@ -20,9 +20,5 @@ module LlmCostTracker
       require_relative "generators/llm_cost_tracker/upgrade_provider_invoice_imports_provider_generator"
       require_relative "generators/llm_cost_tracker/upgrade_provider_invoices_metadata_index_generator"
     end
-
-    rake_tasks do
-      load File.expand_path("../tasks/llm_cost_tracker.rake", __dir__)
-    end
   end
 end

data/lib/llm_cost_tracker/reconcile_tasks.rb

@@ -85,38 +85,35 @@ module LlmCostTracker
     end
 
     def print_unmatched_provider_rows(diff, output)
-      return if diff.unmatched_provider_rows.empty?
-
-      output.puts "  unmatched provider rows#{truncation_suffix(diff.unmatched_provider_rows.size,
-                                                                diff.unmatched_provider_rows_total)}:"
-      diff.unmatched_provider_rows.each do |row|
-        output.puts "    #{row[:external_id]} (#{row[:match_basis]}): " \
-                    "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
+      print_section(output, "unmatched provider rows",
+                    diff.unmatched_provider_rows, diff.unmatched_provider_rows_total) do |row|
+        "#{row[:external_id]} (#{row[:match_basis]}): " \
+          "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
       end
     end
 
     def print_unmatched_local_calls(diff, output)
-      return if diff.unmatched_local_calls.empty?
-
-      output.puts "  unmatched local calls#{truncation_suffix(diff.unmatched_local_calls.size,
-                                                              diff.unmatched_local_calls_total)}:"
-      diff.unmatched_local_calls.each do |row|
-        output.puts "    #{row[:count]} calls / #{row[:total_cost].to_s('F')} " \
-                    "#{format_attribution(row[:attribution])}"
+      print_section(output, "unmatched local calls",
+                    diff.unmatched_local_calls, diff.unmatched_local_calls_total) do |row|
+        "#{row[:count]} calls / #{row[:total_cost].to_s('F')} #{format_attribution(row[:attribution])}"
       end
     end
 
     def print_non_cost_rows(diff, output)
-      return if diff.non_cost_rows.empty?
-
-      output.puts "  non-cost evidence#{truncation_suffix(diff.non_cost_rows.size,
-                                                          diff.non_cost_rows_total)}:"
-      diff.non_cost_rows.each do |row|
-        output.puts "    [#{row[:row_type]}/#{row[:meter]}] #{format_amount(row[:billed_amount])} " \
-                    "#{format_attribution(row[:attribution])}"
+      print_section(output, "non-cost evidence",
+                    diff.non_cost_rows, diff.non_cost_rows_total) do |row|
+        "[#{row[:row_type]}/#{row[:meter]}] " \
+          "#{format_amount(row[:billed_amount])} #{format_attribution(row[:attribution])}"
       end
     end
 
+    def print_section(output, label, rows, total)
+      return if rows.empty?
+
+      output.puts "  #{label}#{truncation_suffix(rows.size, total)}:"
+      rows.each { |row| output.puts "    #{yield(row)}" }
+    end
+
     def truncation_suffix(shown, total)
       return "" if shown >= total
 

data/lib/llm_cost_tracker/reconciliation/importer.rb

@@ -5,6 +5,7 @@ require "date"
 require "json"
 
 require_relative "import_result"
+require_relative "sources/coercion"
 require_relative "../ledger/rollups"
 
 module LlmCostTracker
@@ -120,7 +121,7 @@ module LlmCostTracker
       def normalize_rows(rows)
         errors = []
         normalized = rows.each_with_index.filter_map do |row, index|
-          attrs = symbolize(row)
+          attrs = Sources::Coercion.symbolize(row)
           missing = REQUIRED_FIELDS - attrs.keys
           if missing.any?
             errors << "row #{index}: missing #{missing.join(', ')}"
@@ -213,12 +214,6 @@ module LlmCostTracker
         raw.start_with?(prefix) ? raw : "#{prefix}#{raw}"
       end
 
-      def symbolize(row)
-        return row if row.is_a?(Hash) && row.keys.all?(Symbol)
-
-        row.to_h.transform_keys { |key| key.to_s.to_sym }
-      end
-
       def parse_date(value)
         return value if value.is_a?(Date)
 

data/lib/llm_cost_tracker/reconciliation/sources/anthropic_usage.rb

@@ -1,9 +1,9 @@
 # frozen_string_literal: true
 
 require "bigdecimal"
-require "json"
 require "time"
 
+require_relative "coercion"
 require_relative "fingerprint"
 require_relative "../../providers/anthropic/tier_classification"
 
@@ -23,7 +23,7 @@ module LlmCostTracker
         module_function
 
         def parse(response, authority: AUTHORITY_COST_API, row_type: ROW_TYPE_COST)
-          payload = coerce_hash(response)
+          payload = Coercion.coerce_hash(response, label: "Anthropic Usage")
           buckets = Array(payload[:data])
           buckets.flat_map do |bucket|
             rows_for_bucket(bucket, authority: authority, row_type: row_type)
@@ -31,7 +31,7 @@ module LlmCostTracker
         end
 
         def rows_for_bucket(bucket, authority:, row_type:)
-          bucket = symbolize(bucket)
+          bucket = Coercion.symbolize(bucket)
           starting_at = bucket[:starting_at]
           ending_at = bucket[:ending_at]
           return [] unless starting_at && ending_at
@@ -50,7 +50,7 @@ module LlmCostTracker
         end
 
         def row_for_result(raw, period_start:, period_end:, starting_at:, ending_at:, authority:, row_type:)
-          result = symbolize(raw)
+          result = Coercion.symbolize(raw)
           raw_amount = result[:amount]
           return nil if raw_amount.nil?
 
@@ -122,19 +122,11 @@ module LlmCostTracker
         end
 
         def fingerprint_for(result, starting_at:, ending_at:)
-          attributes = result.merge(starting_at: normalized_epoch(starting_at),
-                                    ending_at: normalized_epoch(ending_at))
+          attributes = result.merge(starting_at: Coercion.normalized_epoch(starting_at),
+                                    ending_at: Coercion.normalized_epoch(ending_at))
           Fingerprint.compute(FINGERPRINT_KEYS, attributes)
         end
 
-        def normalized_epoch(value)
-          return value.to_i if value.is_a?(Numeric)
-
-          Time.parse(value.to_s).utc.to_i
-        rescue ArgumentError
-          value.to_s
-        end
-
         def parse_date(value)
           return value if value.is_a?(Date)
           return Time.at(value).utc.to_date if value.is_a?(Numeric)
@@ -150,22 +142,6 @@ module LlmCostTracker
                  end
           (time - 1).utc.to_date
         end
-
-        def coerce_hash(response)
-          return {} if response.nil?
-          return symbolize(response) if response.is_a?(Hash)
-
-          parsed = JSON.parse(response.to_s)
-          raise ArgumentError, "Anthropic Usage payload must be a JSON object" unless parsed.is_a?(Hash)
-
-          symbolize(parsed)
-        rescue JSON::ParserError => e
-          raise ArgumentError, "Unable to parse Anthropic Usage payload: #{e.message}"
-        end
-
-        def symbolize(hash)
-          hash.to_h.transform_keys { |key| key.to_s.to_sym }
-        end
       end
     end
   end

data/lib/llm_cost_tracker/reconciliation/sources/coercion.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require "json"
+require "time"
+
+module LlmCostTracker
+  module Reconciliation
+    module Sources
+      module Coercion
+        module_function
+
+        def symbolize(hash)
+          return hash if hash.is_a?(Hash) && hash.keys.all?(Symbol)
+
+          hash.to_h.transform_keys { |key| key.to_s.to_sym }
+        end
+
+        def normalized_epoch(value)
+          return value.to_i if value.is_a?(Numeric)
+
+          Time.parse(value.to_s).utc.to_i
+        rescue ArgumentError
+          value.to_s
+        end
+
+        def coerce_hash(response, label:)
+          return {} if response.nil?
+          return symbolize(response) if response.is_a?(Hash)
+
+          parsed = JSON.parse(response.to_s)
+          raise ArgumentError, "#{label} payload must be a JSON object" unless parsed.is_a?(Hash)
+
+          symbolize(parsed)
+        rescue JSON::ParserError => e
+          raise ArgumentError, "Unable to parse #{label} payload: #{e.message}"
+        end
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/reconciliation/sources/openai_usage.rb

@@ -1,8 +1,8 @@
 # frozen_string_literal: true
 
-require "json"
 require "time"
 
+require_relative "coercion"
 require_relative "fingerprint"
 
 module LlmCostTracker
@@ -17,7 +17,7 @@ module LlmCostTracker
         module_function
 
         def parse(response, authority: AUTHORITY_COST_API, row_type: ROW_TYPE_COST)
-          payload = coerce_hash(response)
+          payload = Coercion.coerce_hash(response, label: "OpenAI Costs")
           buckets = Array(payload[:data])
           buckets.flat_map do |bucket|
             rows_for_bucket(bucket, authority: authority, row_type: row_type)
@@ -25,7 +25,7 @@ module LlmCostTracker
         end
 
         def rows_for_bucket(bucket, authority:, row_type:)
-          bucket = symbolize(bucket)
+          bucket = Coercion.symbolize(bucket)
           start_time = bucket[:start_time]
           end_time = bucket[:end_time]
           return [] unless start_time && end_time
@@ -44,8 +44,8 @@ module LlmCostTracker
         end
 
         def row_for_result(raw, period_start:, period_end:, start_time:, end_time:, authority:, row_type:)
-          result = symbolize(raw)
-          amount = symbolize(result[:amount] || {})
+          result = Coercion.symbolize(raw)
+          amount = Coercion.symbolize(result[:amount] || {})
           billed_amount = amount[:value]
           return nil if billed_amount.nil?
 
@@ -93,19 +93,11 @@ module LlmCostTracker
         end
 
         def fingerprint_for(result, start_time:, end_time:)
-          attributes = result.merge(start_time: normalized_epoch(start_time),
-                                    end_time: normalized_epoch(end_time))
+          attributes = result.merge(start_time: Coercion.normalized_epoch(start_time),
+                                    end_time: Coercion.normalized_epoch(end_time))
           Fingerprint.compute(FINGERPRINT_KEYS, attributes)
         end
 
-        def normalized_epoch(value)
-          return value.to_i if value.is_a?(Numeric)
-
-          Time.parse(value.to_s).utc.to_i
-        rescue ArgumentError
-          value.to_s
-        end
-
         def epoch_to_date(value)
           return Time.at(Integer(value)).utc.to_date if value.is_a?(Numeric) || value.to_s.match?(/\A\d+\z/)
 
@@ -120,22 +112,6 @@ module LlmCostTracker
                  end
           (time - 1).utc.to_date
         end
-
-        def coerce_hash(response)
-          return {} if response.nil?
-          return symbolize(response) if response.is_a?(Hash)
-
-          parsed = JSON.parse(response.to_s)
-          raise ArgumentError, "OpenAI Costs payload must be a JSON object" unless parsed.is_a?(Hash)
-
-          symbolize(parsed)
-        rescue JSON::ParserError => e
-          raise ArgumentError, "Unable to parse OpenAI Costs payload: #{e.message}"
-        end
-
-        def symbolize(hash)
-          hash.to_h.transform_keys { |key| key.to_s.to_sym }
-        end
       end
     end
   end

data/lib/llm_cost_tracker/report/formatter.rb

@@ -4,18 +4,18 @@ module LlmCostTracker
   class Report
     class Formatter
       TOP_LIMIT = 5
-      NAME_COLUMN_WIDTH = 28
-      TOP_CALL_COLUMN_WIDTH = 32
+      MIN_COLUMN_WIDTH = 28
 
-      def initialize(data)
+      def initialize(data, color: $stdout.tty?)
         @data = data
+        @color = color
       end
 
       def to_s
-        lines = ["LLM Cost Report (last #{@data.days} days)", ""]
+        lines = [bold("LLM Cost Report (last #{@data.days} days)"), ""]
         append_summary(lines)
-        append_cost_section(lines, "By provider", @data.cost_by_provider)
-        append_cost_section(lines, "By model", @data.cost_by_model)
+        append_cost_section(lines, "By provider", @data.cost_by_provider) { |row| row.name.to_s }
+        append_cost_section(lines, "By model", @data.cost_by_model) { |row| row.name.to_s }
         append_tag_sections(lines)
         append_top_calls(lines)
         lines.join("\n")
@@ -27,36 +27,37 @@ module LlmCostTracker
         lines << "Total cost: #{money(@data.total_cost)}"
         lines << "Requests: #{@data.requests_count}"
         lines << "Avg latency: #{average_latency}"
-        lines << "Unknown pricing: #{@data.unknown_pricing_count}"
+        lines << "Unknown pricing: #{colored_unknown_pricing(@data.unknown_pricing_count)}"
       end
 
-      def append_cost_section(lines, title, rows)
+      def append_cost_section(lines, title, rows, &name_for)
         lines << ""
-        lines << "#{title}:"
+        lines << bold("#{title}:")
         return lines << "  none" if rows.empty?
 
-        rows.first(TOP_LIMIT).each do |row|
-          lines << "  #{row.name.to_s.ljust(NAME_COLUMN_WIDTH)} #{money(row.total_cost)}"
+        visible = rows.first(TOP_LIMIT)
+        width = column_width(visible, &name_for)
+        visible.each do |row|
+          lines << "  #{name_for.call(row).ljust(width)} #{money(row.total_cost)}"
         end
       end
 
       def append_tag_sections(lines)
         @data.cost_by_tags.each do |tag_key, rows|
-          append_cost_section(lines, "By tag (#{tag_key})", rows)
+          append_cost_section(lines, "By tag (#{tag_key})", rows) { |row| row.name.to_s }
         end
       end
 
       def append_top_calls(lines)
-        lines << ""
-        lines << "Top expensive calls:"
-        return lines << "  none" if @data.top_calls.empty?
-
-        @data.top_calls.first(TOP_LIMIT).each do |call|
-          label = "#{call.provider}/#{call.model}"
-          lines << "  #{label.ljust(TOP_CALL_COLUMN_WIDTH)} #{money(call.total_cost)}"
+        append_cost_section(lines, "Top expensive calls", @data.top_calls) do |call|
+          "#{call.provider}/#{call.model}"
         end
       end
 
+      def column_width(rows, &name_for)
+        [MIN_COLUMN_WIDTH, rows.map { |row| name_for.call(row).length }.max.to_i].max
+      end
+
       def average_latency
         @data.average_latency_ms ? "#{@data.average_latency_ms.round}ms" : "n/a"
       end
@@ -64,6 +65,18 @@ module LlmCostTracker
       def money(value)
         "$#{format('%.6f', value.to_f)}"
       end
+
+      def colored_unknown_pricing(count)
+        return count.to_s unless @color
+
+        count.to_i.positive? ? "\e[33m#{count}\e[0m" : "\e[32m#{count}\e[0m"
+      end
+
+      def bold(text)
+        return text unless @color
+
+        "\e[1m#{text}\e[0m"
+      end
     end
   end
 end

data/lib/llm_cost_tracker/tracker.rb

@@ -23,7 +23,7 @@ module LlmCostTracker
       def record(event:, latency_ms: nil, pricing_mode: nil, metadata: {}, context_tags: nil)
         return unless LlmCostTracker.configuration.enabled
 
-        pricing_mode = Pricing.normalize_mode(pricing_mode) || event.pricing_mode
+        pricing_mode = Pricing::Mode.normalize(pricing_mode) || event.pricing_mode
         cost_data, pricing_snapshot, priced_line_items = Pricing.calculate(
           provider: event.provider,
           model: event.model,

data/lib/llm_cost_tracker/version.rb

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

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: llm_cost_tracker
 version: !ruby/object:Gem::Version
-  version: 0.10.0
+  version: 0.11.0
 platform: ruby
 authors:
 - Sergii Khomenko
@@ -239,6 +239,7 @@ files:
 - app/controllers/llm_cost_tracker/dashboard_controller.rb
 - app/controllers/llm_cost_tracker/data_quality_controller.rb
 - app/controllers/llm_cost_tracker/models_controller.rb
+- app/controllers/llm_cost_tracker/pricing_controller.rb
 - app/controllers/llm_cost_tracker/reconciliation_controller.rb
 - app/controllers/llm_cost_tracker/tags_controller.rb
 - app/helpers/llm_cost_tracker/application_helper.rb
@@ -249,6 +250,7 @@ files:
 - app/helpers/llm_cost_tracker/inline_style_helper.rb
 - app/helpers/llm_cost_tracker/pagination_helper.rb
 - app/helpers/llm_cost_tracker/reconciliation_helper.rb
+- app/helpers/llm_cost_tracker/sortable_table_helper.rb
 - app/helpers/llm_cost_tracker/token_usage_helper.rb
 - app/models/llm_cost_tracker/call.rb
 - app/models/llm_cost_tracker/call_line_item.rb
@@ -264,8 +266,10 @@ files:
 - app/services/llm_cost_tracker/dashboard/overview_stats.rb
 - app/services/llm_cost_tracker/dashboard/pagination.rb
 - app/services/llm_cost_tracker/dashboard/params.rb
+- app/services/llm_cost_tracker/dashboard/pricing_overview.rb
 - app/services/llm_cost_tracker/dashboard/provider_breakdown.rb
 - app/services/llm_cost_tracker/dashboard/setup_state.rb
+- app/services/llm_cost_tracker/dashboard/sort.rb
 - app/services/llm_cost_tracker/dashboard/spend_anomaly.rb
 - app/services/llm_cost_tracker/dashboard/tag_breakdown.rb
 - app/services/llm_cost_tracker/dashboard/tag_key_explorer.rb
@@ -280,12 +284,14 @@ files:
 - app/views/llm_cost_tracker/errors/invalid_filter.html.erb
 - app/views/llm_cost_tracker/errors/not_found.html.erb
 - app/views/llm_cost_tracker/models/index.html.erb
+- app/views/llm_cost_tracker/pricing/index.html.erb
 - app/views/llm_cost_tracker/reconciliation/index.html.erb
-- app/views/llm_cost_tracker/shared/_active_filters.html.erb
 - app/views/llm_cost_tracker/shared/_bar.html.erb
-- app/views/llm_cost_tracker/shared/_filters.html.erb
+- app/views/llm_cost_tracker/shared/_filter_pill_date.html.erb
+- app/views/llm_cost_tracker/shared/_filter_pill_model.html.erb
+- app/views/llm_cost_tracker/shared/_filter_pill_provider.html.erb
+- app/views/llm_cost_tracker/shared/_filter_pill_stream.html.erb
 - app/views/llm_cost_tracker/shared/_metric_stack.html.erb
-- app/views/llm_cost_tracker/shared/_sort.html.erb
 - app/views/llm_cost_tracker/shared/_spend_chart.html.erb
 - app/views/llm_cost_tracker/shared/_tag_chips.html.erb
 - app/views/llm_cost_tracker/shared/setup_required.html.erb
@@ -299,6 +305,7 @@ files:
 - lib/llm_cost_tracker/billing/cost_status.rb
 - lib/llm_cost_tracker/billing/line_item.rb
 - lib/llm_cost_tracker/budget.rb
+- lib/llm_cost_tracker/capture/sse.rb
 - lib/llm_cost_tracker/capture/stream.rb
 - lib/llm_cost_tracker/capture/stream_collector.rb
 - lib/llm_cost_tracker/capture/stream_tracker.rb
@@ -377,9 +384,7 @@ files:
 - lib/llm_cost_tracker/parsers/gemini.rb
 - lib/llm_cost_tracker/parsers/openai.rb
 - lib/llm_cost_tracker/parsers/openai_compatible.rb
-- lib/llm_cost_tracker/parsers/openai_service_charges.rb
 - lib/llm_cost_tracker/parsers/openai_usage.rb
-- lib/llm_cost_tracker/parsers/sse.rb
 - lib/llm_cost_tracker/prices.json
 - lib/llm_cost_tracker/pricing.rb
 - lib/llm_cost_tracker/pricing/backfill.rb
@@ -396,11 +401,13 @@ files:
 - lib/llm_cost_tracker/pricing/sync/registry_diff.rb
 - lib/llm_cost_tracker/pricing/sync/registry_writer.rb
 - lib/llm_cost_tracker/pricing/unknown.rb
+- lib/llm_cost_tracker/providers/anthropic/server_tools.rb
 - lib/llm_cost_tracker/providers/anthropic/tier_classification.rb
 - lib/llm_cost_tracker/providers/azure/hosts.rb
 - lib/llm_cost_tracker/providers/gemini/model_families.rb
 - lib/llm_cost_tracker/providers/openai/hosts.rb
 - lib/llm_cost_tracker/providers/openai/model_families.rb
+- lib/llm_cost_tracker/providers/openai/service_charges.rb
 - lib/llm_cost_tracker/railtie.rb
 - lib/llm_cost_tracker/reconcile_tasks.rb
 - lib/llm_cost_tracker/reconciliation.rb
@@ -409,6 +416,7 @@ files:
 - lib/llm_cost_tracker/reconciliation/import_result.rb
 - lib/llm_cost_tracker/reconciliation/importer.rb
 - lib/llm_cost_tracker/reconciliation/sources/anthropic_usage.rb
+- lib/llm_cost_tracker/reconciliation/sources/coercion.rb
 - lib/llm_cost_tracker/reconciliation/sources/fingerprint.rb
 - lib/llm_cost_tracker/reconciliation/sources/openai_usage.rb
 - lib/llm_cost_tracker/report.rb