llm_cost_tracker 0.3.0 → 0.3.1

data/app/views/llm_cost_tracker/data_quality/index.html.erb

@@ -1,10 +1,7 @@
 <% total = @stats.total_calls %>
-<% known_pricing_calls = total - @stats.unknown_pricing_count %>
-<% tagged_calls = total - @stats.untagged_calls_count %>
-<% latency_calls = @stats.latency_column_present ? total - @stats.missing_latency_count : nil %>
 <% streaming_count = @stats.streaming_count %>
 <% streaming_missing_usage = @stats.streaming_missing_usage_count %>
-<% streams_with_usage = streaming_count && streaming_missing_usage ? streaming_count - streaming_missing_usage : nil %>
+<% calls_with_provider_response_id = @stats.provider_response_id_column_present ? total - @stats.missing_provider_response_id_count : nil %>
 
 <section class="lct-panel lct-toolbar">
   <div class="lct-toolbar-head">
@@ -15,7 +12,7 @@
     <div class="lct-filter-row lct-filter-row-basic">
       <div class="lct-field">
         <label for="lct-quality-from">From</label>
-        <input id="lct-quality-from" data-lct-filter-input type="date" name="from" value="<%= params[:from] %>">
+        <input id="lct-quality-from" type="date" name="from" value="<%= params[:from] %>">
       </div>
 
       <div class="lct-field">
@@ -113,6 +110,14 @@
             </article>
           <% end %>
         <% end %>
+
+        <% if @stats.provider_response_id_column_present %>
+          <article class="lct-stat">
+            <p class="lct-stat-label">Calls with provider response ID</p>
+            <p class="lct-stat-value"><%= number(calls_with_provider_response_id) %></p>
+            <p class="lct-stat-sub"><%= percent(coverage_percent(calls_with_provider_response_id, total)) %> of calls</p>
+          </article>
+        <% end %>
       </div>
     </div>
   </section>
@@ -136,41 +141,51 @@
           </tr>
         </thead>
         <tbody>
-          <% cost_coverage = coverage_percent(known_pricing_calls, total) %>
+          <% cost_coverage = coverage_percent(total - @stats.unknown_pricing_count, total) %>
           <tr>
             <td>Cost (pricing known)</td>
             <td class="lct-num"><%= percent(cost_coverage) %></td>
-            <td class="lct-num"><%= number(known_pricing_calls) %></td>
+            <td class="lct-num"><%= number(total - @stats.unknown_pricing_count) %></td>
             <td><%= render "llm_cost_tracker/shared/bar", value: cost_coverage, max: 100.0 %></td>
           </tr>
 
-          <% tag_coverage = coverage_percent(tagged_calls, total) %>
+          <% tag_coverage = coverage_percent(total - @stats.untagged_calls_count, total) %>
           <tr>
             <td>Tags (at least one tag)</td>
             <td class="lct-num"><%= percent(tag_coverage) %></td>
-            <td class="lct-num"><%= number(tagged_calls) %></td>
+            <td class="lct-num"><%= number(total - @stats.untagged_calls_count) %></td>
             <td><%= render "llm_cost_tracker/shared/bar", value: tag_coverage, max: 100.0 %></td>
           </tr>
 
           <% if @stats.latency_column_present %>
-            <% latency_coverage = coverage_percent(latency_calls, total) %>
+            <% latency_coverage = coverage_percent(total - @stats.missing_latency_count, total) %>
             <tr>
               <td>Latency</td>
               <td class="lct-num"><%= percent(latency_coverage) %></td>
-              <td class="lct-num"><%= number(latency_calls) %></td>
+              <td class="lct-num"><%= number(total - @stats.missing_latency_count) %></td>
               <td><%= render "llm_cost_tracker/shared/bar", value: latency_coverage, max: 100.0 %></td>
             </tr>
           <% end %>
 
-          <% if @stats.stream_column_present && streams_with_usage && streaming_count.to_i.positive? %>
-            <% stream_coverage = coverage_percent(streams_with_usage, streaming_count) %>
+          <% if @stats.stream_column_present && streaming_count.to_i.positive? && streaming_missing_usage %>
+            <% stream_coverage = coverage_percent(streaming_count - streaming_missing_usage, streaming_count) %>
             <tr>
               <td>Streaming usage captured</td>
               <td class="lct-num"><%= percent(stream_coverage) %></td>
-              <td class="lct-num"><%= number(streams_with_usage) %> / <%= number(streaming_count) %></td>
+              <td class="lct-num"><%= number(streaming_count - streaming_missing_usage) %> / <%= number(streaming_count) %></td>
               <td><%= render "llm_cost_tracker/shared/bar", value: stream_coverage, max: 100.0 %></td>
             </tr>
           <% end %>
+
+          <% if @stats.provider_response_id_column_present %>
+            <% provider_response_id_coverage = coverage_percent(calls_with_provider_response_id, total) %>
+            <tr>
+              <td>Provider response ID</td>
+              <td class="lct-num"><%= percent(provider_response_id_coverage) %></td>
+              <td class="lct-num"><%= number(calls_with_provider_response_id) %></td>
+              <td><%= render "llm_cost_tracker/shared/bar", value: provider_response_id_coverage, max: 100.0 %></td>
+            </tr>
+          <% end %>
         </tbody>
       </table>
     </section>
@@ -216,6 +231,13 @@
               <td>Send OpenAI requests with <code class="lct-code">stream_options: { include_usage: true }</code>, or wrap custom clients with <code class="lct-code">LlmCostTracker.track_stream</code>.</td>
             </tr>
           <% end %>
+          <% if @stats.provider_response_id_column_present && @stats.missing_provider_response_id_count.to_i.positive? %>
+            <tr>
+              <td>Missing provider response IDs</td>
+              <td>Proof of provider-issued responses is weaker when calls cannot be tied back to provider objects.</td>
+              <td>Upgrade to the latest parser coverage and pass <code class="lct-code">provider_response_id:</code> for custom clients when the provider exposes one.</td>
+            </tr>
+          <% end %>
         </tbody>
       </table>
     </section>

data/app/views/llm_cost_tracker/models/index.html.erb

@@ -7,7 +7,7 @@
     <div class="lct-filter-row lct-filter-row-with-sort">
       <div class="lct-field">
         <label for="lct-models-from">From</label>
-        <input id="lct-models-from" data-lct-filter-input type="date" name="from" value="<%= params[:from] %>">
+        <input id="lct-models-from" type="date" name="from" value="<%= params[:from] %>">
       </div>
 
       <div class="lct-field">
@@ -33,14 +33,15 @@
 
       <div class="lct-field">
         <label for="lct-models-sort">Sort</label>
-        <select id="lct-models-sort" name="sort">
-          <option value="cost" <%= "selected" if @sort.blank? || @sort == "cost" %>>Total spend</option>
-          <option value="calls" <%= "selected" if @sort == "calls" %>>Call volume</option>
-          <option value="avg_cost" <%= "selected" if @sort == "avg_cost" %>>Avg cost / call</option>
-          <% if @latency_available %>
-            <option value="latency" <%= "selected" if @sort == "latency" %>>Avg latency</option>
-          <% end %>
-        </select>
+        <%= select_tag :sort,
+                       options_for_select(
+                         [["Total spend", "cost"],
+                          ["Call volume", "calls"],
+                          ["Avg cost / call", "avg_cost"]] +
+                         (@latency_available ? [["Avg latency", "latency"]] : []),
+                         @sort.presence || "cost"
+                       ),
+                       id: "lct-models-sort" %>
       </div>
 
       <div class="lct-filter-actions">

data/app/views/llm_cost_tracker/shared/_spend_chart.html.erb

@@ -1,4 +1,3 @@
-<%# locals: series: Array[{ label:, cost: }], comparison_series: nil %>
 <% if series.blank? %>
   <div class="lct-chart-empty">No spend in this range.</div>
 <% else %>

data/app/views/llm_cost_tracker/shared/_tag_chips.html.erb

@@ -1,4 +1,3 @@
-<%# locals: tags: Hash, limit: Integer (optional) %>
 <% entries = tag_chip_entries(tags, limit: local_assigns.fetch(:limit, 3)) %>
 <% if entries.empty? %>
   <span class="lct-tag-empty">(untagged)</span>

data/app/views/llm_cost_tracker/tags/index.html.erb

@@ -7,7 +7,7 @@
     <div class="lct-filter-row lct-filter-row-basic">
       <div class="lct-field">
         <label for="lct-tags-from">From</label>
-        <input id="lct-tags-from" data-lct-filter-input type="date" name="from" value="<%= params[:from] %>">
+        <input id="lct-tags-from" type="date" name="from" value="<%= params[:from] %>">
       </div>
 
       <div class="lct-field">

data/app/views/llm_cost_tracker/tags/show.html.erb

@@ -12,7 +12,7 @@
     <div class="lct-filter-row lct-filter-row-basic">
       <div class="lct-field">
         <label for="lct-tag-show-from">From</label>
-        <input id="lct-tag-show-from" data-lct-filter-input type="date" name="from" value="<%= params[:from] %>">
+        <input id="lct-tag-show-from" type="date" name="from" value="<%= params[:from] %>">
       </div>
 
       <div class="lct-field">

data/lib/llm_cost_tracker/configuration.rb

@@ -5,7 +5,6 @@ require_relative "value_helpers"
 
 module LlmCostTracker
   class Configuration
-    # Hostname => provider name for OpenAI-compatible APIs.
     OPENAI_COMPATIBLE_PROVIDERS = {
       "openrouter.ai" => "openrouter",
       "api.deepseek.com" => "deepseek"

data/lib/llm_cost_tracker/event.rb

@@ -12,6 +12,7 @@ module LlmCostTracker
     :latency_ms,
     :stream,
     :usage_source,
+    :provider_response_id,
     :tracked_at
   ) do
     def to_h

data/lib/llm_cost_tracker/event_metadata.rb

@@ -10,6 +10,7 @@ module LlmCostTracker
       cached_input_tokens
       input_tokens
       output_tokens
+      provider_response_id
       reasoning_tokens
       total_tokens
     ].freeze

data/lib/llm_cost_tracker/generators/llm_cost_tracker/add_provider_response_id_generator.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require "rails/generators"
+require "rails/generators/active_record"
+
+module LlmCostTracker
+  module Generators
+    class AddProviderResponseIdGenerator < Rails::Generators::Base
+      include ActiveRecord::Generators::Migration
+
+      source_root File.expand_path("templates", __dir__)
+
+      desc "Creates a migration to add llm_api_calls.provider_response_id"
+
+      def create_migration_file
+        migration_template(
+          "add_provider_response_id_to_llm_api_calls.rb.erb",
+          "db/migrate/add_provider_response_id_to_llm_api_calls.rb"
+        )
+      end
+
+      private
+
+      def migration_version
+        "[#{ActiveRecord::VERSION::MAJOR}.#{ActiveRecord::VERSION::MINOR}]"
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/add_provider_response_id_to_llm_api_calls.rb.erb

@@ -0,0 +1,15 @@
+class AddProviderResponseIdToLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
+  def up
+    return if column_exists?(:llm_api_calls, :provider_response_id)
+
+    add_column :llm_api_calls, :provider_response_id, :string
+    add_index :llm_api_calls, :provider_response_id
+  end
+
+  def down
+    return unless column_exists?(:llm_api_calls, :provider_response_id)
+
+    remove_index :llm_api_calls, :provider_response_id if index_exists?(:llm_api_calls, :provider_response_id)
+    remove_column :llm_api_calls, :provider_response_id
+  end
+end

data/lib/llm_cost_tracker/generators/llm_cost_tracker/templates/create_llm_api_calls.rb.erb

@@ -12,6 +12,7 @@ class CreateLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
       t.integer :latency_ms
       t.boolean :stream,        null: false, default: false
       t.string  :usage_source
+      t.string  :provider_response_id
       if postgresql?
         t.jsonb :tags, null: false, default: {}
       else
@@ -28,6 +29,7 @@ class CreateLlmApiCalls < ActiveRecord::Migration<%= migration_version %>
     add_index :llm_api_calls, [:provider, :tracked_at]
     add_index :llm_api_calls, :stream
     add_index :llm_api_calls, :usage_source
+    add_index :llm_api_calls, :provider_response_id
     add_index :llm_api_calls, :tags, using: :gin if postgresql?
   end
 

data/lib/llm_cost_tracker/llm_api_call.rb

@@ -16,7 +16,6 @@ module LlmCostTracker
 
     self.table_name = "llm_api_calls"
 
-    # Scopes for querying
     scope :with_cost, -> { where.not(total_cost: nil) }
     scope :without_cost, -> { where(total_cost: nil) }
     scope :unknown_pricing, -> { without_cost }
@@ -24,6 +23,12 @@ module LlmCostTracker
     scope :streaming,     -> { stream_column? ? where(stream: true) : none }
     scope :non_streaming, -> { stream_column? ? where(stream: [false, nil]) : all }
     scope :by_usage_source, ->(source) { usage_source_column? ? where(usage_source: source.to_s) : none }
+    scope :with_provider_response_id, lambda {
+      provider_response_id_column? ? where.not(provider_response_id: [nil, ""]) : none
+    }
+    scope :missing_provider_response_id, lambda {
+      provider_response_id_column? ? where(provider_response_id: [nil, ""]) : none
+    }
     scope :streaming_missing_usage, lambda {
       return none unless stream_column? && usage_source_column?
 
@@ -51,7 +56,6 @@ module LlmCostTracker
       TagQuery.apply(self, tags)
     end
 
-    # Aggregations
     def self.total_cost
       sum(:total_cost).to_f
     end

data/lib/llm_cost_tracker/middleware/faraday.rb

@@ -61,6 +61,7 @@ module LlmCostTracker
           latency_ms: latency_ms,
           stream: parsed.stream,
           usage_source: parsed.usage_source,
+          provider_response_id: parsed.provider_response_id,
           metadata: resolved_tags(request_env).merge(parsed.metadata)
         )
       rescue LlmCostTracker::Error

data/lib/llm_cost_tracker/parameter_hash.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module LlmCostTracker
+  module ParameterHash
+    class << self
+      def hash_like?(value)
+        value.is_a?(Hash) || action_controller_parameters?(value)
+      end
+
+      def to_hash(value)
+        return {} if value.nil?
+        return value.to_unsafe_h if action_controller_parameters?(value)
+        return value.to_h if value.is_a?(Hash)
+        return {} unless value.respond_to?(:to_h)
+
+        hash = value.to_h
+        hash.is_a?(Hash) ? hash : {}
+      rescue ArgumentError, TypeError
+        {}
+      end
+
+      def with_indifferent_access(value)
+        to_hash(value).with_indifferent_access
+      end
+
+      private
+
+      def action_controller_parameters?(value)
+        defined?(ActionController::Parameters) && value.is_a?(ActionController::Parameters)
+      end
+    end
+  end
+end

data/lib/llm_cost_tracker/parsed_usage.rb

@@ -12,11 +12,21 @@ module LlmCostTracker
     :cache_creation_input_tokens,
     :reasoning_tokens,
     :stream,
-    :usage_source
+    :usage_source,
+    :provider_response_id
   )
 
   class ParsedUsage
-    TRACKING_KEYS = %i[provider model input_tokens output_tokens total_tokens stream usage_source].freeze
+    TRACKING_KEYS = %i[
+      provider
+      model
+      input_tokens
+      output_tokens
+      total_tokens
+      stream
+      usage_source
+      provider_response_id
+    ].freeze
 
     def self.build(**attributes)
       new(
@@ -30,7 +40,8 @@ module LlmCostTracker
         cache_creation_input_tokens: attributes[:cache_creation_input_tokens],
         reasoning_tokens: attributes[:reasoning_tokens],
         stream: attributes[:stream] || false,
-        usage_source: attributes[:usage_source]
+        usage_source: attributes[:usage_source],
+        provider_response_id: attributes[:provider_response_id]
       )
     end
 

data/lib/llm_cost_tracker/parsers/anthropic.rb

@@ -31,6 +31,7 @@ module LlmCostTracker
 
         ParsedUsage.build(
           provider: "anthropic",
+          provider_response_id: response["id"],
           model: response["model"] || request["model"],
           input_tokens: usage["input_tokens"].to_i,
           output_tokens: usage["output_tokens"].to_i,
@@ -48,35 +49,9 @@ module LlmCostTracker
         request = safe_json_parse(request_body)
         model = stream_model(events) || request["model"]
         usage = stream_usage(events)
+        response_id = stream_response_id(events)
 
-        if usage
-          input = usage["input_tokens"].to_i
-          output = usage["output_tokens"].to_i
-          cache_read = usage["cache_read_input_tokens"].to_i
-          cache_creation = usage["cache_creation_input_tokens"].to_i
-
-          ParsedUsage.build(
-            provider: "anthropic",
-            model: model,
-            input_tokens: input,
-            output_tokens: output,
-            total_tokens: input + output + cache_read + cache_creation,
-            cache_read_input_tokens: usage["cache_read_input_tokens"],
-            cache_creation_input_tokens: usage["cache_creation_input_tokens"],
-            stream: true,
-            usage_source: :stream_final
-          )
-        else
-          ParsedUsage.build(
-            provider: "anthropic",
-            model: model,
-            input_tokens: 0,
-            output_tokens: 0,
-            total_tokens: 0,
-            stream: true,
-            usage_source: :unknown
-          )
-        end
+        usage ? build_stream_result(model, usage, response_id) : build_unknown_stream_result(model, response_id)
       end
 
       private
@@ -114,6 +89,50 @@ module LlmCostTracker
         end
         nil
       end
+
+      def stream_response_id(events)
+        events.each do |event|
+          data = event[:data]
+          next unless data.is_a?(Hash)
+
+          id = data.dig("message", "id") || data["id"]
+          return id if id && !id.to_s.empty?
+        end
+        nil
+      end
+
+      def build_stream_result(model, usage, response_id)
+        input = usage["input_tokens"].to_i
+        output = usage["output_tokens"].to_i
+        cache_read = usage["cache_read_input_tokens"].to_i
+        cache_creation = usage["cache_creation_input_tokens"].to_i
+
+        ParsedUsage.build(
+          provider: "anthropic",
+          provider_response_id: response_id,
+          model: model,
+          input_tokens: input,
+          output_tokens: output,
+          total_tokens: input + output + cache_read + cache_creation,
+          cache_read_input_tokens: usage["cache_read_input_tokens"],
+          cache_creation_input_tokens: usage["cache_creation_input_tokens"],
+          stream: true,
+          usage_source: :stream_final
+        )
+      end
+
+      def build_unknown_stream_result(model, response_id)
+        ParsedUsage.build(
+          provider: "anthropic",
+          provider_response_id: response_id,
+          model: model,
+          input_tokens: 0,
+          output_tokens: 0,
+          total_tokens: 0,
+          stream: true,
+          usage_source: :unknown
+        )
+      end
     end
   end
 end

data/lib/llm_cost_tracker/parsers/gemini.rb

@@ -35,7 +35,12 @@ module LlmCostTracker
         usage    = response["usageMetadata"]
         return nil unless usage
 
-        build_parsed_usage(request_url, usage, usage_source: :response)
+        build_parsed_usage(
+          request_url,
+          usage,
+          usage_source: :response,
+          provider_response_id: response["responseId"]
+        )
       end
 
       def parse_stream(request_url, _request_body, response_status, events)
@@ -45,10 +50,17 @@ module LlmCostTracker
         model = extract_model_from_url(request_url)
 
         if usage
-          build_parsed_usage(request_url, usage, stream: true, usage_source: :stream_final)
+          build_parsed_usage(
+            request_url,
+            usage,
+            stream: true,
+            usage_source: :stream_final,
+            provider_response_id: stream_response_id(events)
+          )
         else
           ParsedUsage.build(
             provider: "gemini",
+            provider_response_id: stream_response_id(events),
             model: model,
             input_tokens: 0,
             output_tokens: 0,
@@ -61,7 +73,7 @@ module LlmCostTracker
 
       private
 
-      def build_parsed_usage(request_url, usage, usage_source:, stream: false)
+      def build_parsed_usage(request_url, usage, usage_source:, stream: false, provider_response_id: nil)
         ParsedUsage.build(
           provider: "gemini",
           model: extract_model_from_url(request_url),
@@ -70,7 +82,8 @@ module LlmCostTracker
           total_tokens: usage["totalTokenCount"].to_i,
           cached_input_tokens: usage["cachedContentTokenCount"],
           stream: stream,
-          usage_source: usage_source
+          usage_source: usage_source,
+          provider_response_id: provider_response_id
         )
       end
 
@@ -90,6 +103,17 @@ module LlmCostTracker
         usage["candidatesTokenCount"].to_i + usage["thoughtsTokenCount"].to_i
       end
 
+      def stream_response_id(events)
+        events.each do |event|
+          data = event[:data]
+          next unless data.is_a?(Hash)
+
+          id = data["responseId"]
+          return id if id && !id.to_s.empty?
+        end
+        nil
+      end
+
       def streaming_url?(request_url)
         URI.parse(request_url.to_s).path.match?(STREAM_PATH_PATTERN)
       rescue URI::InvalidURIError

data/lib/llm_cost_tracker/parsers/openai_compatible.rb

@@ -20,7 +20,10 @@ module LlmCostTracker
       end
 
       def provider_names
-        ["openai_compatible", *configured_providers.each_value.map(&:to_s)].uniq.freeze
+        [
+          "openai_compatible",
+          *LlmCostTracker.configuration.openai_compatible_providers.each_value.map(&:to_s)
+        ].uniq.freeze
       end
 
       def parse(request_url, request_body, response_status, response_body)
@@ -41,11 +44,7 @@ module LlmCostTracker
       end
 
       def provider_for_host(host)
-        configured_providers[host.to_s.downcase]&.to_s
-      end
-
-      def configured_providers
-        LlmCostTracker.configuration.openai_compatible_providers
+        LlmCostTracker.configuration.openai_compatible_providers[host.to_s.downcase]&.to_s
       end
 
       def tracked_path?(path)

data/lib/llm_cost_tracker/parsers/openai_usage.rb

@@ -16,6 +16,7 @@ module LlmCostTracker
 
         ParsedUsage.build(
           provider: provider_for(request_url),
+          provider_response_id: response["id"],
           model: response["model"] || request["model"],
           input_tokens: (usage["prompt_tokens"] || usage["input_tokens"]).to_i,
           output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
@@ -35,6 +36,7 @@ module LlmCostTracker
         if usage
           ParsedUsage.build(
             provider: provider_for(request_url),
+            provider_response_id: detect_stream_response_id(events),
             model: model,
             input_tokens: (usage["prompt_tokens"] || usage["input_tokens"]).to_i,
             output_tokens: (usage["completion_tokens"] || usage["output_tokens"]).to_i,
@@ -46,6 +48,7 @@ module LlmCostTracker
         else
           ParsedUsage.build(
             provider: provider_for(request_url),
+            provider_response_id: detect_stream_response_id(events),
             model: model,
             input_tokens: 0,
             output_tokens: 0,
@@ -78,6 +81,17 @@ module LlmCostTracker
         nil
       end
 
+      def detect_stream_response_id(events)
+        events.each do |event|
+          data = event[:data]
+          next unless data.is_a?(Hash)
+
+          id = data["id"] || data.dig("response", "id")
+          return id if id && !id.to_s.empty?
+        end
+        nil
+      end
+
       def cached_input_tokens(usage)
         details = usage["prompt_tokens_details"] || usage["input_tokens_details"] || {}
         details["cached_tokens"]