llm_cost_tracker 0.5.0 → 0.5.2

data/lib/llm_cost_tracker/price_sync/sources/litellm.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module LlmCostTracker
-  module PriceSync
-    module Sources
-      class Litellm < Source
-        PER_TOKEN_TO_PER_MILLION = 1_000_000
-        SUPPORTED_MODES = %w[chat completion embedding responses].freeze
-        SUPPORTED_PROVIDERS = %w[openai anthropic gemini text-completion-openai].freeze
-        URL = "https://raw.githubusercontent.com/BerriAI/litellm/main/model_prices_and_context_window.json"
-
-        def priority
-          10
-        end
-
-        def url
-          URL
-        end
-
-        def fetch(current_models:, fetcher:)
-          response = fetcher.get(url)
-          payload = JSON.parse(response.body.to_s)
-
-          prices = []
-          missing_models = []
-
-          current_models.each_key do |our_model|
-            entry_id = ModelCatalog.resolve_from_litellm(our_model, payload)
-            entry = entry_id && payload[entry_id]
-
-            if entry && supported_entry?(entry)
-              prices << build_raw_price(our_model, entry, response)
-            else
-              missing_models << our_model
-            end
-          end
-
-          SourceResult.new(
-            prices: prices,
-            missing_models: missing_models.sort,
-            source_version: response_version(response)
-          )
-        rescue JSON::ParserError => e
-          raise Error, "Unable to parse #{url}: #{e.message}"
-        end
-
-        private
-
-        def supported_entry?(entry)
-          SUPPORTED_PROVIDERS.include?(entry["litellm_provider"]) &&
-            SUPPORTED_MODES.include?(entry["mode"]) &&
-            entry.key?("input_cost_per_token") &&
-            entry.key?("output_cost_per_token")
-        end
-
-        def build_raw_price(model, entry, response)
-          provider = normalize_provider(entry["litellm_provider"])
-          cache_read = price_per_million(entry["cache_read_input_token_cost"])
-          cache_write = price_per_million(entry["cache_creation_input_token_cost"])
-
-          RawPrice.new(
-            model: model,
-            provider: provider,
-            input: price_per_million(entry["input_cost_per_token"]),
-            output: price_per_million(entry["output_cost_per_token"]),
-            cache_read_input: cache_read,
-            cache_write_input: cache_write,
-            source: name,
-            source_version: response_version(response),
-            fetched_at: response.fetched_at
-          )
-        end
-
-        def normalize_provider(provider)
-          return "openai" if provider == "text-completion-openai"
-
-          provider
-        end
-
-        def price_per_million(value)
-          return nil if value.nil?
-
-          value.to_f * PER_TOKEN_TO_PER_MILLION
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/price_sync/sources/open_router.rb

@@ -1,93 +0,0 @@
-# frozen_string_literal: true
-
-require "json"
-
-module LlmCostTracker
-  module PriceSync
-    module Sources
-      class OpenRouter < Source
-        PER_TOKEN_TO_PER_MILLION = 1_000_000
-        SUPPORTED_PREFIXES = %w[openai anthropic google].freeze
-        URL = "https://openrouter.ai/api/v1/models"
-
-        def priority
-          20
-        end
-
-        def url
-          URL
-        end
-
-        def fetch(current_models:, fetcher:)
-          response = fetcher.get(url)
-          payload = JSON.parse(response.body.to_s)
-          index = payload.fetch("data", []).to_h { |entry| [entry["id"], entry] }
-
-          prices = []
-          missing_models = []
-
-          current_models.each_key do |our_model|
-            entry_id = ModelCatalog.resolve_from_openrouter(our_model, index)
-            entry = entry_id && index[entry_id]
-
-            if entry && supported_entry?(entry)
-              prices << build_raw_price(our_model, entry, response)
-            else
-              missing_models << our_model
-            end
-          end
-
-          SourceResult.new(
-            prices: prices,
-            missing_models: missing_models.sort,
-            source_version: response_version(response)
-          )
-        rescue JSON::ParserError => e
-          raise Error, "Unable to parse #{url}: #{e.message}"
-        end
-
-        private
-
-        def supported_entry?(entry)
-          pricing = entry["pricing"] || {}
-          provider = entry["id"].to_s.split("/").first
-
-          SUPPORTED_PREFIXES.include?(provider) &&
-            pricing["prompt"] &&
-            pricing["completion"]
-        end
-
-        def build_raw_price(model, entry, response)
-          pricing = entry.fetch("pricing", {})
-          provider = normalize_provider(entry.fetch("id").split("/").first)
-          cache_read = price_per_million(pricing["input_cache_read"])
-          cache_write = price_per_million(pricing["input_cache_write"])
-
-          RawPrice.new(
-            model: model,
-            provider: provider,
-            input: price_per_million(pricing["prompt"]),
-            output: price_per_million(pricing["completion"]),
-            cache_read_input: cache_read,
-            cache_write_input: cache_write,
-            source: name,
-            source_version: response_version(response),
-            fetched_at: response.fetched_at
-          )
-        end
-
-        def normalize_provider(provider)
-          return "gemini" if provider == "google"
-
-          provider
-        end
-
-        def price_per_million(value)
-          return nil if value.nil?
-
-          value.to_f * PER_TOKEN_TO_PER_MILLION
-        end
-      end
-    end
-  end
-end

data/lib/llm_cost_tracker/price_sync/validator.rb

@@ -1,66 +0,0 @@
-# frozen_string_literal: true
-
-module LlmCostTracker
-  module PriceSync
-    class Validator
-      Result = Data.define(:accepted, :rejected, :flagged)
-      Issue = Data.define(:model, :reason, :old_price, :new_price)
-
-      MAX_INPUT_PER_MILLION = 100.0
-      MAX_OUTPUT_PER_MILLION = 500.0
-      MAX_RELATIVE_CHANGE = 3.0
-
-      def validate_batch(merged_prices, existing_registry:)
-        merged_prices.each_with_object(Result.new(accepted: {}, rejected: [], flagged: [])) do |(model, price), result|
-          old_price = normalize_entry(existing_registry[model])
-          status, reason = validate(new_price: price, old_price: old_price)
-
-          case status
-          when :rejected
-            result.rejected << Issue.new(model: model, reason: reason, old_price: old_price, new_price: price)
-          when :flagged
-            result.flagged << Issue.new(model: model, reason: reason, old_price: old_price, new_price: price)
-            result.accepted[model] = price
-          else
-            result.accepted[model] = price
-          end
-        end
-      end
-
-      private
-
-      def validate(new_price:, old_price:)
-        overrides = Array(normalize_entry(old_price)["_validator_override"])
-
-        return [:rejected, "input > $#{MAX_INPUT_PER_MILLION}/1M"] if new_price.input > MAX_INPUT_PER_MILLION
-        return [:rejected, "output > $#{MAX_OUTPUT_PER_MILLION}/1M"] if new_price.output > MAX_OUTPUT_PER_MILLION
-        return [:ok, nil] if overrides.include?("skip_relative_change")
-
-        if old_price.any? && changed_too_much?(old_price, new_price)
-          return [:flagged, "price changed >#{MAX_RELATIVE_CHANGE}x"]
-        end
-
-        [:ok, nil]
-      end
-
-      def changed_too_much?(old_price, new_price)
-        %i[input output].any? do |field|
-          old_value = old_price[field.to_s].to_f
-          next false if old_value.zero?
-
-          new_value = new_price.public_send(field).to_f
-          next false if new_value.zero?
-
-          ratio = [new_value / old_value, old_value / new_value].max
-          ratio > MAX_RELATIVE_CHANGE
-        end
-      end
-
-      def normalize_entry(entry)
-        (entry || {}).each_with_object({}) do |(key, value), normalized|
-          normalized[key.to_s] = value
-        end
-      end
-    end
-  end
-end