llm_cost_tracker 0.7.0 → 0.7.2

data/lib/llm_cost_tracker/tags_column.rb

@@ -1,105 +0,0 @@
-# frozen_string_literal: true
-
-require_relative "active_record_adapter"
-
-module LlmCostTracker
-  module TagsColumn
-    USAGE_BREAKDOWN_COLUMNS = %w[
-      cache_read_input_tokens
-      cache_write_input_tokens
-      hidden_output_tokens
-    ].freeze
-
-    USAGE_BREAKDOWN_COST_COLUMNS = %w[
-      cache_read_input_cost
-      cache_write_input_cost
-    ].freeze
-
-    def reset_column_information
-      remove_instance_variable(:@lct_schema_capabilities) if instance_variable_defined?(:@lct_schema_capabilities)
-
-      super
-    end
-
-    def tags_json_column?
-      capabilities = lct_schema_capabilities
-
-      capabilities.fetch(:tags_jsonb) || capabilities.fetch(:tags_mysql_json)
-    end
-
-    def tags_jsonb_column?
-      lct_schema_capabilities.fetch(:tags_jsonb)
-    end
-
-    def tags_mysql_json_column?
-      lct_schema_capabilities.fetch(:tags_mysql_json)
-    end
-
-    def latency_column?
-      lct_schema_capabilities.fetch(:latency)
-    end
-
-    def stream_column?
-      lct_schema_capabilities.fetch(:stream)
-    end
-
-    def usage_source_column?
-      lct_schema_capabilities.fetch(:usage_source)
-    end
-
-    def provider_response_id_column?
-      lct_schema_capabilities.fetch(:provider_response_id)
-    end
-
-    def pricing_mode_column?
-      lct_schema_capabilities.fetch(:pricing_mode)
-    end
-
-    def usage_breakdown_columns?
-      lct_schema_capabilities.fetch(:usage_breakdown)
-    end
-
-    def usage_breakdown_cost_columns?
-      lct_schema_capabilities.fetch(:usage_breakdown_cost)
-    end
-
-    private
-
-    def lct_schema_capabilities
-      columns = columns_hash
-      adapter_name = connection.adapter_name
-      cache = @lct_schema_capabilities
-
-      return cache.fetch(:values) if cache && cache.fetch(:columns).equal?(columns) &&
-                                     cache.fetch(:adapter_name) == adapter_name
-
-      values = build_lct_schema_capabilities(columns, adapter_name)
-      @lct_schema_capabilities = { columns: columns, adapter_name: adapter_name, values: values }
-      values
-    end
-
-    def build_lct_schema_capabilities(columns, adapter_name)
-      ActiveRecordAdapter.ensure_supported!(adapter_name)
-
-      tag_column = columns["tags"]
-      tags_jsonb = tag_column && (tag_column.type == :jsonb || tag_column.sql_type.to_s.downcase == "jsonb")
-      tags_mysql_json =
-        tag_column &&
-        !tags_jsonb &&
-        tag_column.type == :json &&
-        ActiveRecordAdapter.mysql?(adapter_name)
-
-      {
-        tags_jsonb: tags_jsonb ? true : false,
-        tags_mysql_json: tags_mysql_json ? true : false,
-        latency: columns.key?("latency_ms"),
-        stream: columns.key?("stream"),
-        usage_source: columns.key?("usage_source"),
-        provider_response_id: columns.key?("provider_response_id"),
-        pricing_mode: columns.key?("pricing_mode"),
-        usage_breakdown: USAGE_BREAKDOWN_COLUMNS.all? { |column| columns.key?(column) },
-        usage_breakdown_cost: USAGE_BREAKDOWN_COST_COLUMNS.all? { |column| columns.key?(column) }
-      }
-    end
-  end
-end

data/lib/llm_cost_tracker/unknown_pricing.rb

@@ -1,54 +0,0 @@
-# frozen_string_literal: true
-
-require "monitor"
-
-require_relative "logging"
-
-module LlmCostTracker
-  class UnknownPricing
-    MUTEX = Monitor.new
-
-    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
-
-      def reset!
-        MUTEX.synchronize { @warned_models = Set.new }
-      end
-
-      private
-
-      def normalized_model_name(model)
-        model.to_s.empty? ? "unknown" : model.to_s
-      end
-
-      def warn_missing(model)
-        should_warn = MUTEX.synchronize do
-          @warned_models ||= Set.new
-          @warned_models.add?(model)
-        end
-        return unless should_warn
-
-        Logging.warn(
-          "No pricing configured for model #{model.inspect}. " \
-          "Cost and budget guardrails will be skipped for this event. " \
-          "Add a pricing_overrides entry or set unknown_pricing_behavior."
-        )
-      end
-
-      def behavior
-        LlmCostTracker.configuration.unknown_pricing_behavior
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/usage_breakdown.rb

@@ -1,30 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  UsageBreakdown = Data.define(
-    :input_tokens,
-    :cache_read_input_tokens,
-    :cache_write_input_tokens,
-    :output_tokens,
-    :hidden_output_tokens
-  ) do
-    def self.build(input_tokens:, output_tokens:, cache_read_input_tokens: 0,
-                   cache_write_input_tokens: 0, hidden_output_tokens: 0)
-      new(
-        input_tokens: input_tokens.to_i,
-        cache_read_input_tokens: cache_read_input_tokens.to_i,
-        cache_write_input_tokens: cache_write_input_tokens.to_i,
-        output_tokens: output_tokens.to_i,
-        hidden_output_tokens: hidden_output_tokens.to_i
-      )
-    end
-
-    def total_tokens
-      input_tokens + cache_read_input_tokens + cache_write_input_tokens + output_tokens
-    end
-
-    def to_h
-      super.merge(total_tokens: total_tokens).compact
-    end
-  end
-end

data/lib/llm_cost_tracker/value_helpers.rb

@@ -1,40 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module ValueHelpers
-    class << self
-      def deep_dup(value)
-        case value
-        when Hash
-          value.each_with_object({}) do |(key, nested_value), duplicated|
-            duplicated[deep_dup(key)] = deep_dup(nested_value)
-          end
-        when Array
-          value.map { |nested_value| deep_dup(nested_value) }
-        when String
-          value.dup
-        else
-          value
-        end
-      end
-
-      def deep_freeze(value)
-        case value
-        when Hash
-          value.each do |key, nested_value|
-            deep_freeze(key)
-            deep_freeze(nested_value)
-          end
-          value.frozen? ? value : value.freeze
-        when Array
-          value.each { |nested_value| deep_freeze(nested_value) }
-          value.frozen? ? value : value.freeze
-        when String
-          value.frozen? ? value : value.freeze
-        else
-          value
-        end
-      end
-    end
-  end
-end