mirror of
https://github.com/BerriAI/litellm.git
synced 2026-11-18 09:45:23 +00:00
feat(cost): parse ModelPricing once with a grammar-checked tokenizer and one Rate policy
ModelPricing is parsed from a raw catalog entry into typed storage: base
rates, tier and batch maps, a threshold vec sorted by token count, off_peak,
tiered_pricing, search_context_cost_per_query, provider_specific_entry,
guardrail_cost_per_unit, and PTU fields, with an extra map no calculation
reads. Rate::{Missing, Null, Invalid, Value} mirrors _get_cost_per_unit
coercions (int, float, bool as 1 or 0, trimmed numeric string) and
wire::cost_per_unit reproduces its tier-suffix base-key fallback with
Python's exact suffix order, pinned against executed Python along with
_parse_above_token_threshold, _BATCH_TIER_KEY, and get_model_info's
projection allowlist via new fixture surfaces. A coverage test walks every
embedded catalog key and fails on any pattern the tokenizer or allowlist
does not recognize, so a new key shape cannot ship silently unpriced, and
clippy disallowed-types now confines serde_json::Value to wire.rs with
explicit allows marking the modules not yet migrated
This commit is contained in:
parent
a8725892a4
commit
6908fe19e6
66 changed files with 1711 additions and 4 deletions
|
|
@ -20,3 +20,6 @@ rstest.workspace = true
|
|||
[[bench]]
|
||||
name = "calculate"
|
||||
harness = false
|
||||
|
||||
[lints.clippy]
|
||||
disallowed-types = "deny"
|
||||
|
|
|
|||
3
litellm-rust/crates/cost/clippy.toml
Normal file
3
litellm-rust/crates/cost/clippy.toml
Normal file
|
|
@ -0,0 +1,3 @@
|
|||
disallowed-types = [
|
||||
{ path = "serde_json::Value", reason = "wire.rs owns serde_json::Value in litellm-cost; cost code reads typed inputs (ModelPricing, UsageInput)" },
|
||||
]
|
||||
|
|
@ -1,61 +1,116 @@
|
|||
#[allow(clippy::disallowed_types)]
|
||||
pub mod a2a_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod anthropic_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod anthropic_usage;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod azure_ai_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod azure_ai_image_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod azure_cost;
|
||||
pub mod background_cost_polling;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod base_rate_selection;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod batch;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod bedrock_image_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod billed_token_rates;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod catalog;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod completion_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod completion_input;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod completion_response;
|
||||
pub mod cost_breakdown;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod custom_pricing;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod dashscope_cost;
|
||||
pub mod databricks_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod fal_ai_image_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod fireworks_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod gemini_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod generic_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod generic_input;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod generic_output;
|
||||
pub mod generic_usage;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod groq_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod guardrail_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod image_cost_router;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod image_response_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod interactions_usage;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod mcp_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod model_selection;
|
||||
pub mod non_token;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod ocr_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod off_peak;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod openai_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod openai_image_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod per_second;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod perplexity_cost;
|
||||
pub mod pricing;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod prompt_caching_savings;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod provider_cache;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod ptu_pricing;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod realtime_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod regional_uplift;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod responses_usage;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod retrieval_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod search_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod speech_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod tiered_pricing;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod together_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod tool_call_cost_tracking;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod tool_cost_dispatch;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod transcription_usage;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod usage_dispatch;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod vertex_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod wire;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod xai_cost;
|
||||
#[allow(clippy::disallowed_types)]
|
||||
pub mod zero_cost_diagnostic;
|
||||
|
||||
#[derive(Clone, Copy, Debug, PartialEq)]
|
||||
|
|
|
|||
376
litellm-rust/crates/cost/src/pricing.rs
Normal file
376
litellm-rust/crates/cost/src/pricing.rs
Normal file
|
|
@ -0,0 +1,376 @@
|
|||
use std::collections::BTreeMap;
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
pub enum Rate {
|
||||
#[default]
|
||||
Missing,
|
||||
Null,
|
||||
Invalid,
|
||||
Value(f64),
|
||||
}
|
||||
|
||||
impl Rate {
|
||||
pub fn value(self) -> Option<f64> {
|
||||
match self {
|
||||
Self::Value(value) => Some(value),
|
||||
Self::Missing | Self::Null | Self::Invalid => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||
pub enum ServiceTier {
|
||||
Auto,
|
||||
Flex,
|
||||
Priority,
|
||||
Fast,
|
||||
Ultrafast,
|
||||
}
|
||||
|
||||
impl ServiceTier {
|
||||
pub const SUFFIXES: [Self; 5] = [
|
||||
Self::Ultrafast,
|
||||
Self::Priority,
|
||||
Self::Auto,
|
||||
Self::Flex,
|
||||
Self::Fast,
|
||||
];
|
||||
|
||||
pub fn as_str(self) -> &'static str {
|
||||
match self {
|
||||
Self::Auto => "auto",
|
||||
Self::Flex => "flex",
|
||||
Self::Priority => "priority",
|
||||
Self::Fast => "fast",
|
||||
Self::Ultrafast => "ultrafast",
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, Hash, Ord, PartialEq, PartialOrd)]
|
||||
pub enum Metric {
|
||||
AnnotationPerPage,
|
||||
CacheCreationAudioToken,
|
||||
CacheCreationToken,
|
||||
CacheCreationToken1hr,
|
||||
CacheReadAudioToken,
|
||||
CacheReadImageToken,
|
||||
CacheReadToken,
|
||||
CitationToken,
|
||||
CodeInterpreterPerSession,
|
||||
ComputerUseInput1kTokens,
|
||||
ComputerUseOutput1kTokens,
|
||||
FileSearchPer1kCalls,
|
||||
FileSearchPerGbPerDay,
|
||||
GoogleMapsGroundingPerQuery,
|
||||
InputAudioPerSecond,
|
||||
InputAudioToken,
|
||||
InputCharacter,
|
||||
InputDbuToken,
|
||||
InputPerImage,
|
||||
InputPerImageToken,
|
||||
InputPerPixel,
|
||||
InputPerQuery,
|
||||
InputPerRequest,
|
||||
InputPerSecond,
|
||||
InputPerToken,
|
||||
InputPerTokenCacheHit,
|
||||
InputVideoPerSecond,
|
||||
InputVideoPerSecond15sInterval,
|
||||
InputVideoPerSecond8sInterval,
|
||||
InputVideoToken,
|
||||
OcrPerCredit,
|
||||
OcrPerPage,
|
||||
OutputAudioToken,
|
||||
OutputCharacter,
|
||||
OutputDbuToken,
|
||||
OutputPerImage,
|
||||
OutputPerImage1024,
|
||||
OutputPerImage1536,
|
||||
OutputPerImage512,
|
||||
OutputPerImageToken,
|
||||
OutputPerPixel,
|
||||
OutputPerSecond,
|
||||
OutputPerSecond1080p,
|
||||
OutputPerSecond2k,
|
||||
OutputPerSecond480p,
|
||||
OutputPerSecond4k,
|
||||
OutputPerSecond720p,
|
||||
OutputPerSecond768p,
|
||||
OutputPerToken,
|
||||
OutputReasoningToken,
|
||||
OutputVideoPerSecond,
|
||||
OutputVideoToken,
|
||||
VectorStorePerGbPerDay,
|
||||
}
|
||||
|
||||
impl Metric {
|
||||
const NAMES: [(Self, &'static str); 53] = [
|
||||
(Self::AnnotationPerPage, "annotation_cost_per_page"),
|
||||
(
|
||||
Self::CacheCreationAudioToken,
|
||||
"cache_creation_input_audio_token_cost",
|
||||
),
|
||||
(Self::CacheCreationToken, "cache_creation_input_token_cost"),
|
||||
(
|
||||
Self::CacheCreationToken1hr,
|
||||
"cache_creation_input_token_cost_above_1hr",
|
||||
),
|
||||
(
|
||||
Self::CacheReadAudioToken,
|
||||
"cache_read_input_audio_token_cost",
|
||||
),
|
||||
(
|
||||
Self::CacheReadImageToken,
|
||||
"cache_read_input_image_token_cost",
|
||||
),
|
||||
(Self::CacheReadToken, "cache_read_input_token_cost"),
|
||||
(Self::CitationToken, "citation_cost_per_token"),
|
||||
(
|
||||
Self::CodeInterpreterPerSession,
|
||||
"code_interpreter_cost_per_session",
|
||||
),
|
||||
(
|
||||
Self::ComputerUseInput1kTokens,
|
||||
"computer_use_input_cost_per_1k_tokens",
|
||||
),
|
||||
(
|
||||
Self::ComputerUseOutput1kTokens,
|
||||
"computer_use_output_cost_per_1k_tokens",
|
||||
),
|
||||
(Self::FileSearchPer1kCalls, "file_search_cost_per_1k_calls"),
|
||||
(
|
||||
Self::FileSearchPerGbPerDay,
|
||||
"file_search_cost_per_gb_per_day",
|
||||
),
|
||||
(
|
||||
Self::GoogleMapsGroundingPerQuery,
|
||||
"google_maps_grounding_cost_per_query",
|
||||
),
|
||||
(Self::InputAudioPerSecond, "input_cost_per_audio_per_second"),
|
||||
(Self::InputAudioToken, "input_cost_per_audio_token"),
|
||||
(Self::InputCharacter, "input_cost_per_character"),
|
||||
(Self::InputDbuToken, "input_dbu_cost_per_token"),
|
||||
(Self::InputPerImage, "input_cost_per_image"),
|
||||
(Self::InputPerImageToken, "input_cost_per_image_token"),
|
||||
(Self::InputPerPixel, "input_cost_per_pixel"),
|
||||
(Self::InputPerQuery, "input_cost_per_query"),
|
||||
(Self::InputPerRequest, "input_cost_per_request"),
|
||||
(Self::InputPerSecond, "input_cost_per_second"),
|
||||
(Self::InputPerToken, "input_cost_per_token"),
|
||||
(
|
||||
Self::InputPerTokenCacheHit,
|
||||
"input_cost_per_token_cache_hit",
|
||||
),
|
||||
(Self::InputVideoPerSecond, "input_cost_per_video_per_second"),
|
||||
(
|
||||
Self::InputVideoPerSecond15sInterval,
|
||||
"input_cost_per_video_per_second_above_15s_interval",
|
||||
),
|
||||
(
|
||||
Self::InputVideoPerSecond8sInterval,
|
||||
"input_cost_per_video_per_second_above_8s_interval",
|
||||
),
|
||||
(Self::InputVideoToken, "input_cost_per_video_token"),
|
||||
(Self::OcrPerCredit, "ocr_cost_per_credit"),
|
||||
(Self::OcrPerPage, "ocr_cost_per_page"),
|
||||
(Self::OutputAudioToken, "output_cost_per_audio_token"),
|
||||
(Self::OutputCharacter, "output_cost_per_character"),
|
||||
(Self::OutputDbuToken, "output_dbu_cost_per_token"),
|
||||
(Self::OutputPerImage, "output_cost_per_image"),
|
||||
(Self::OutputPerImage1024, "output_cost_per_image_1024"),
|
||||
(Self::OutputPerImage1536, "output_cost_per_image_1536"),
|
||||
(Self::OutputPerImage512, "output_cost_per_image_512"),
|
||||
(Self::OutputPerImageToken, "output_cost_per_image_token"),
|
||||
(Self::OutputPerPixel, "output_cost_per_pixel"),
|
||||
(Self::OutputPerSecond, "output_cost_per_second"),
|
||||
(Self::OutputPerSecond1080p, "output_cost_per_second_1080p"),
|
||||
(Self::OutputPerSecond2k, "output_cost_per_second_2k"),
|
||||
(Self::OutputPerSecond480p, "output_cost_per_second_480p"),
|
||||
(Self::OutputPerSecond4k, "output_cost_per_second_4k"),
|
||||
(Self::OutputPerSecond720p, "output_cost_per_second_720p"),
|
||||
(Self::OutputPerSecond768p, "output_cost_per_second_768p"),
|
||||
(Self::OutputPerToken, "output_cost_per_token"),
|
||||
(
|
||||
Self::OutputReasoningToken,
|
||||
"output_cost_per_reasoning_token",
|
||||
),
|
||||
(
|
||||
Self::OutputVideoPerSecond,
|
||||
"output_cost_per_video_per_second",
|
||||
),
|
||||
(Self::OutputVideoToken, "output_cost_per_video_token"),
|
||||
(
|
||||
Self::VectorStorePerGbPerDay,
|
||||
"vector_store_cost_per_gb_per_day",
|
||||
),
|
||||
];
|
||||
|
||||
pub fn parse(name: &str) -> Option<Self> {
|
||||
Self::NAMES
|
||||
.iter()
|
||||
.find(|(_, known)| *known == name)
|
||||
.map(|(metric, _)| *metric)
|
||||
}
|
||||
|
||||
pub fn as_str(self) -> &'static str {
|
||||
Self::NAMES
|
||||
.iter()
|
||||
.find(|(metric, _)| *metric == self)
|
||||
.map(|(_, name)| *name)
|
||||
.expect("every metric carries its name")
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub struct RateKey {
|
||||
pub metric: Metric,
|
||||
pub threshold: Option<u64>,
|
||||
pub tier: Option<ServiceTier>,
|
||||
pub batch: bool,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
|
||||
pub enum TokenizeError {
|
||||
UnrecognizedMetric,
|
||||
BadThreshold,
|
||||
}
|
||||
|
||||
pub fn tokenize(key: &str) -> Result<RateKey, TokenizeError> {
|
||||
let (base, batch) = match key.strip_suffix("_batches") {
|
||||
Some(base) => (base, true),
|
||||
None => (key, false),
|
||||
};
|
||||
let (base, tier) = ServiceTier::SUFFIXES
|
||||
.into_iter()
|
||||
.find_map(|tier| {
|
||||
base.strip_suffix(format!("_{}", tier.as_str()).as_str())
|
||||
.map(|stripped| (stripped, Some(tier)))
|
||||
})
|
||||
.unwrap_or((base, None));
|
||||
let (metric_name, threshold) = match base.strip_suffix("_tokens") {
|
||||
Some(prefix) => match prefix.rsplit_once("_above") {
|
||||
Some((metric_name, tail)) => (
|
||||
metric_name,
|
||||
Some(parse_threshold_number(
|
||||
tail.strip_prefix('_').unwrap_or(tail),
|
||||
)?),
|
||||
),
|
||||
None => (base, None),
|
||||
},
|
||||
None => (base, None),
|
||||
};
|
||||
let metric = Metric::parse(metric_name).ok_or(TokenizeError::UnrecognizedMetric)?;
|
||||
Ok(RateKey {
|
||||
metric,
|
||||
threshold,
|
||||
tier,
|
||||
batch,
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_threshold_number(text: &str) -> Result<u64, TokenizeError> {
|
||||
let (digits, multiplier) = match text.strip_suffix('k') {
|
||||
Some(digits) => (digits, 1_000_u64),
|
||||
None => (text, 1),
|
||||
};
|
||||
if digits.is_empty() || !digits.bytes().all(|b| b.is_ascii_digit()) {
|
||||
return Err(TokenizeError::BadThreshold);
|
||||
}
|
||||
digits
|
||||
.parse::<u64>()
|
||||
.ok()
|
||||
.and_then(|value| value.checked_mul(multiplier))
|
||||
.ok_or(TokenizeError::BadThreshold)
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct ThresholdPricing {
|
||||
pub above_tokens: u64,
|
||||
pub standard: BTreeMap<Metric, Rate>,
|
||||
pub tiers: BTreeMap<(Metric, ServiceTier), Rate>,
|
||||
pub batches: BTreeMap<Metric, Rate>,
|
||||
pub batch_tiers: BTreeMap<(Metric, ServiceTier), Rate>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct OffPeakWindow {
|
||||
pub hours_utc: Vec<String>,
|
||||
pub weekdays: Option<Vec<String>>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct OffPeakPricing {
|
||||
pub input: Rate,
|
||||
pub output: Rate,
|
||||
pub cache_read: Rate,
|
||||
pub cache_creation: Rate,
|
||||
pub output_reasoning: Rate,
|
||||
pub hours_utc: Vec<String>,
|
||||
pub weekdays: Option<Vec<String>>,
|
||||
pub weekday_timezone: Option<String>,
|
||||
pub windows: Vec<OffPeakWindow>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct TieredPricingTier {
|
||||
pub range: (f64, Option<f64>),
|
||||
pub input: Rate,
|
||||
pub output: Rate,
|
||||
pub output_reasoning: Rate,
|
||||
pub cache_read: Rate,
|
||||
pub cache_creation: Rate,
|
||||
}
|
||||
|
||||
#[derive(Clone, Copy, Debug, Default, PartialEq)]
|
||||
pub struct SearchContextCostPerQuery {
|
||||
pub low: Rate,
|
||||
pub medium: Rate,
|
||||
pub high: Rate,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, PartialEq)]
|
||||
pub struct PtuPricing {
|
||||
pub count: i64,
|
||||
pub cost_per_hour: Rate,
|
||||
pub effective_from: Option<String>,
|
||||
pub effective_to: Option<String>,
|
||||
}
|
||||
|
||||
#[derive(Clone, Debug, Default, PartialEq)]
|
||||
pub struct ModelPricing {
|
||||
pub base: BTreeMap<Metric, Rate>,
|
||||
pub tiers: BTreeMap<(Metric, ServiceTier), Rate>,
|
||||
pub batches: BTreeMap<Metric, Rate>,
|
||||
pub batch_tiers: BTreeMap<(Metric, ServiceTier), Rate>,
|
||||
pub thresholds: Vec<ThresholdPricing>,
|
||||
pub off_peak: Option<OffPeakPricing>,
|
||||
pub tiered_pricing: Option<Vec<TieredPricingTier>>,
|
||||
pub search_context_cost_per_query: Option<SearchContextCostPerQuery>,
|
||||
pub provider_specific_entry: BTreeMap<String, Rate>,
|
||||
pub guardrail_cost_per_unit: BTreeMap<String, Rate>,
|
||||
pub web_search_billing_unit: Option<String>,
|
||||
pub regional_processing_eu: Rate,
|
||||
pub regional_processing_us: Rate,
|
||||
pub regional_endpoint_uplift: Rate,
|
||||
pub litellm_provider: Option<String>,
|
||||
pub ptu: Option<PtuPricing>,
|
||||
pub extra: BTreeMap<String, Rate>,
|
||||
}
|
||||
|
||||
impl ModelPricing {
|
||||
pub fn rate(&self, metric: Metric) -> Rate {
|
||||
self.base.get(&metric).copied().unwrap_or(Rate::Missing)
|
||||
}
|
||||
|
||||
pub fn tier_rate(&self, metric: Metric, tier: ServiceTier) -> Rate {
|
||||
self.tiers
|
||||
.get(&(metric, tier))
|
||||
.copied()
|
||||
.unwrap_or(Rate::Missing)
|
||||
}
|
||||
|
||||
pub fn batch_rate(&self, metric: Metric) -> Rate {
|
||||
self.batches.get(&metric).copied().unwrap_or(Rate::Missing)
|
||||
}
|
||||
}
|
||||
|
|
@ -9,6 +9,10 @@ use std::sync::LazyLock;
|
|||
use serde::Deserialize;
|
||||
use serde_json::{Map, Value};
|
||||
|
||||
use crate::pricing::{
|
||||
ModelPricing, OffPeakPricing, OffPeakWindow, PtuPricing, Rate, SearchContextCostPerQuery,
|
||||
ServiceTier, ThresholdPricing, TieredPricingTier, tokenize,
|
||||
};
|
||||
use crate::responses_usage::{
|
||||
CacheCreationTokenDetails, CompletionTokenDetails, PromptTokenDetails,
|
||||
};
|
||||
|
|
@ -68,6 +72,341 @@ pub fn catalog_with_overlays(
|
|||
overlay_catalog(&EMBEDDED_CATALOG, overlays)
|
||||
}
|
||||
|
||||
pub fn rate(value: Option<&Value>) -> Rate {
|
||||
match value {
|
||||
None => Rate::Missing,
|
||||
Some(Value::Null) => Rate::Null,
|
||||
Some(Value::Number(number)) => number.as_f64().map_or(Rate::Invalid, Rate::Value),
|
||||
Some(Value::Bool(flag)) => Rate::Value(f64::from(*flag)),
|
||||
Some(Value::String(text)) => text
|
||||
.trim()
|
||||
.parse::<f64>()
|
||||
.map_or(Rate::Invalid, Rate::Value),
|
||||
Some(_) => Rate::Invalid,
|
||||
}
|
||||
}
|
||||
|
||||
pub fn cost_per_unit(
|
||||
fields: &Map<String, Value>,
|
||||
cost_key: &str,
|
||||
default: Option<f64>,
|
||||
) -> Option<f64> {
|
||||
match fields.get(cost_key) {
|
||||
None | Some(Value::Null) => {}
|
||||
Some(present) => return rate(Some(present)).value().or(default),
|
||||
}
|
||||
for tier in ServiceTier::SUFFIXES {
|
||||
let suffix = format!("_{}", tier.as_str());
|
||||
if cost_key.contains(&suffix) {
|
||||
let base = cost_key.replace(&suffix, "");
|
||||
return rate(fields.get(&base)).value().or(default);
|
||||
}
|
||||
}
|
||||
default
|
||||
}
|
||||
|
||||
const NON_RATE_KEYS: [&str; 76] = [
|
||||
"audio_transcription_config",
|
||||
"bedrock_converse_supports_strict_tools",
|
||||
"bedrock_output_config_effort_ceiling",
|
||||
"comment",
|
||||
"default_reasoning_effort",
|
||||
"deprecation_date",
|
||||
"gemini_audio_only_live",
|
||||
"gemini_native_audio",
|
||||
"key",
|
||||
"litellm_provider",
|
||||
"max_input_tokens",
|
||||
"max_output_tokens",
|
||||
"max_tokens",
|
||||
"metadata",
|
||||
"mode",
|
||||
"output_vector_size",
|
||||
"prompt_cache_min_tokens",
|
||||
"reasoning_effort_levels",
|
||||
"rpm",
|
||||
"source",
|
||||
"supported_audio_formats",
|
||||
"supported_endpoints",
|
||||
"supported_modalities",
|
||||
"supported_output_modalities",
|
||||
"supported_regions",
|
||||
"supported_openai_params",
|
||||
"supports_adaptive_thinking",
|
||||
"supports_anthropic_compaction",
|
||||
"supports_anthropic_thinking_payload",
|
||||
"supports_assistant_prefill",
|
||||
"supports_audio_input",
|
||||
"supports_audio_output",
|
||||
"supports_computer_use",
|
||||
"supports_embedding_image_input",
|
||||
"supports_fast_mode",
|
||||
"supports_forced_tool_use",
|
||||
"supports_function_calling",
|
||||
"supports_image_input",
|
||||
"supports_image_size",
|
||||
"supports_legacy_thinking",
|
||||
"supports_low_reasoning_effort",
|
||||
"supports_max_reasoning_effort",
|
||||
"supports_mid_conversation_system",
|
||||
"supports_minimal_reasoning_effort",
|
||||
"supports_multimodal",
|
||||
"supports_native_streaming",
|
||||
"supports_native_structured_output",
|
||||
"supports_none_reasoning_effort",
|
||||
"supports_nova_canvas_image_edit",
|
||||
"supports_output_config",
|
||||
"supports_parallel_function_calling",
|
||||
"supports_parallel_tool_use_config",
|
||||
"supports_pdf_input",
|
||||
"supports_prompt_cache_breakpoint",
|
||||
"supports_prompt_caching",
|
||||
"supports_reasoning",
|
||||
"supports_response_schema",
|
||||
"supports_sampling_params",
|
||||
"supports_speed",
|
||||
"supports_system_messages",
|
||||
"supports_thinking_cache_preservation",
|
||||
"supports_tool_choice",
|
||||
"supports_tool_search",
|
||||
"supports_url_context",
|
||||
"supports_video_input",
|
||||
"supports_vision",
|
||||
"supports_web_search",
|
||||
"supports_xhigh_reasoning_effort",
|
||||
"thinking_always_on",
|
||||
"tpm",
|
||||
"use_openai_responses_path",
|
||||
"uses_embed_content",
|
||||
"vertex_ai_audio_api",
|
||||
"web_search_billing_unit",
|
||||
"ptu_effective_from",
|
||||
"ptu_effective_to",
|
||||
];
|
||||
|
||||
const TYPED_KEYS: [&str; 10] = [
|
||||
"off_peak_pricing",
|
||||
"tiered_pricing",
|
||||
"search_context_cost_per_query",
|
||||
"provider_specific_entry",
|
||||
"guardrail_cost_per_unit",
|
||||
"regional_processing_uplift_multiplier_eu",
|
||||
"regional_processing_uplift_multiplier_us",
|
||||
"regional_endpoint_uplift_multiplier",
|
||||
"ptu_count",
|
||||
"cost_per_ptu_per_hour",
|
||||
];
|
||||
|
||||
pub fn recognized_non_rate_key(key: &str) -> bool {
|
||||
NON_RATE_KEYS.contains(&key) || TYPED_KEYS.contains(&key)
|
||||
}
|
||||
|
||||
fn hours_list(value: Option<&Value>) -> Vec<String> {
|
||||
match value {
|
||||
Some(Value::String(text)) => vec![text.clone()],
|
||||
Some(Value::Array(entries)) => entries
|
||||
.iter()
|
||||
.filter_map(Value::as_str)
|
||||
.map(str::to_owned)
|
||||
.collect(),
|
||||
_ => Vec::new(),
|
||||
}
|
||||
}
|
||||
|
||||
fn weekdays(value: Option<&Value>) -> Option<Vec<String>> {
|
||||
match value {
|
||||
Some(Value::Array(entries)) => Some(
|
||||
entries
|
||||
.iter()
|
||||
.filter_map(Value::as_str)
|
||||
.map(str::to_owned)
|
||||
.collect(),
|
||||
),
|
||||
Some(Value::String(text)) => Some(vec![text.clone()]),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_off_peak(block: &Value) -> OffPeakPricing {
|
||||
OffPeakPricing {
|
||||
input: rate(block.get("input_cost_per_token")),
|
||||
output: rate(block.get("output_cost_per_token")),
|
||||
cache_read: rate(block.get("cache_read_input_token_cost")),
|
||||
cache_creation: rate(block.get("cache_creation_input_token_cost")),
|
||||
output_reasoning: rate(block.get("output_cost_per_reasoning_token")),
|
||||
hours_utc: hours_list(block.get("hours_utc")),
|
||||
weekdays: weekdays(block.get("weekdays")),
|
||||
weekday_timezone: block
|
||||
.get("weekday_timezone")
|
||||
.and_then(Value::as_str)
|
||||
.map(str::to_owned),
|
||||
windows: block
|
||||
.get("windows")
|
||||
.and_then(Value::as_array)
|
||||
.map_or(Vec::new(), |rules| {
|
||||
rules
|
||||
.iter()
|
||||
.map(|rule| OffPeakWindow {
|
||||
hours_utc: hours_list(rule.get("hours_utc")),
|
||||
weekdays: weekdays(rule.get("weekdays")),
|
||||
})
|
||||
.collect()
|
||||
}),
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_tiered_pricing(tiers: &Value) -> Vec<TieredPricingTier> {
|
||||
tiers.as_array().map_or(Vec::new(), |entries| {
|
||||
entries
|
||||
.iter()
|
||||
.map(|entry| {
|
||||
let range =
|
||||
entry
|
||||
.get("range")
|
||||
.and_then(Value::as_array)
|
||||
.map_or((0.0, None), |bounds| {
|
||||
let start = bounds.first().and_then(Value::as_f64).unwrap_or(0.0);
|
||||
let end = bounds.get(1).and_then(Value::as_f64);
|
||||
(start, end)
|
||||
});
|
||||
TieredPricingTier {
|
||||
range,
|
||||
input: rate(entry.get("input_cost_per_token")),
|
||||
output: rate(entry.get("output_cost_per_token")),
|
||||
output_reasoning: rate(entry.get("output_cost_per_reasoning_token")),
|
||||
cache_read: rate(entry.get("cache_read_input_token_cost")),
|
||||
cache_creation: rate(entry.get("cache_creation_input_token_cost")),
|
||||
}
|
||||
})
|
||||
.collect()
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_search_context(block: &Value) -> SearchContextCostPerQuery {
|
||||
SearchContextCostPerQuery {
|
||||
low: rate(block.get("search_context_size_low")),
|
||||
medium: rate(block.get("search_context_size_medium")),
|
||||
high: rate(block.get("search_context_size_high")),
|
||||
}
|
||||
}
|
||||
|
||||
fn parse_rate_map(block: &Value) -> BTreeMap<String, Rate> {
|
||||
block.as_object().map_or(BTreeMap::new(), |entries| {
|
||||
entries
|
||||
.iter()
|
||||
.map(|(key, value)| (key.clone(), rate(Some(value))))
|
||||
.collect()
|
||||
})
|
||||
}
|
||||
|
||||
fn parse_ptu(fields: &Map<String, Value>) -> Option<PtuPricing> {
|
||||
fields
|
||||
.get("cost_per_ptu_per_hour")
|
||||
.map(|cost_per_hour| PtuPricing {
|
||||
count: fields.get("ptu_count").and_then(Value::as_i64).unwrap_or(0),
|
||||
cost_per_hour: rate(Some(cost_per_hour)),
|
||||
effective_from: fields
|
||||
.get("ptu_effective_from")
|
||||
.and_then(Value::as_str)
|
||||
.map(str::to_owned),
|
||||
effective_to: fields
|
||||
.get("ptu_effective_to")
|
||||
.and_then(Value::as_str)
|
||||
.map(str::to_owned),
|
||||
})
|
||||
}
|
||||
|
||||
impl RawCatalogEntry {
|
||||
pub fn pricing(&self) -> ModelPricing {
|
||||
let fields = self.fields();
|
||||
let mut pricing = ModelPricing {
|
||||
web_search_billing_unit: fields
|
||||
.get("web_search_billing_unit")
|
||||
.and_then(Value::as_str)
|
||||
.map(str::to_owned),
|
||||
regional_processing_eu: rate(fields.get("regional_processing_uplift_multiplier_eu")),
|
||||
regional_processing_us: rate(fields.get("regional_processing_uplift_multiplier_us")),
|
||||
regional_endpoint_uplift: rate(fields.get("regional_endpoint_uplift_multiplier")),
|
||||
litellm_provider: fields
|
||||
.get("litellm_provider")
|
||||
.and_then(Value::as_str)
|
||||
.map(str::to_owned),
|
||||
off_peak: fields.get("off_peak_pricing").map(parse_off_peak),
|
||||
tiered_pricing: fields.get("tiered_pricing").map(parse_tiered_pricing),
|
||||
search_context_cost_per_query: fields
|
||||
.get("search_context_cost_per_query")
|
||||
.map(parse_search_context),
|
||||
provider_specific_entry: fields
|
||||
.get("provider_specific_entry")
|
||||
.map(parse_rate_map)
|
||||
.unwrap_or_default(),
|
||||
guardrail_cost_per_unit: fields
|
||||
.get("guardrail_cost_per_unit")
|
||||
.map(parse_rate_map)
|
||||
.unwrap_or_default(),
|
||||
ptu: parse_ptu(fields),
|
||||
..ModelPricing::default()
|
||||
};
|
||||
let mut thresholds: BTreeMap<u64, ThresholdPricing> = BTreeMap::new();
|
||||
for (key, value) in fields {
|
||||
if NON_RATE_KEYS.contains(&key.as_str()) || TYPED_KEYS.contains(&key.as_str()) {
|
||||
continue;
|
||||
}
|
||||
let Ok(rate_key) = tokenize(key) else {
|
||||
pricing.extra.insert(key.clone(), rate(Some(value)));
|
||||
continue;
|
||||
};
|
||||
let parsed_rate = rate(Some(value));
|
||||
match (rate_key.threshold, rate_key.tier, rate_key.batch) {
|
||||
(None, None, false) => {
|
||||
pricing.base.insert(rate_key.metric, parsed_rate);
|
||||
}
|
||||
(None, Some(tier), false) => {
|
||||
pricing.tiers.insert((rate_key.metric, tier), parsed_rate);
|
||||
}
|
||||
(None, None, true) => {
|
||||
pricing.batches.insert(rate_key.metric, parsed_rate);
|
||||
}
|
||||
(None, Some(tier), true) => {
|
||||
pricing
|
||||
.batch_tiers
|
||||
.insert((rate_key.metric, tier), parsed_rate);
|
||||
}
|
||||
(Some(above_tokens), tier, batch) => {
|
||||
let entry =
|
||||
thresholds
|
||||
.entry(above_tokens)
|
||||
.or_insert_with(|| ThresholdPricing {
|
||||
above_tokens,
|
||||
standard: BTreeMap::new(),
|
||||
tiers: BTreeMap::new(),
|
||||
batches: BTreeMap::new(),
|
||||
batch_tiers: BTreeMap::new(),
|
||||
});
|
||||
match (tier, batch) {
|
||||
(None, false) => {
|
||||
entry.standard.insert(rate_key.metric, parsed_rate);
|
||||
}
|
||||
(Some(tier), false) => {
|
||||
entry.tiers.insert((rate_key.metric, tier), parsed_rate);
|
||||
}
|
||||
(None, true) => {
|
||||
entry.batches.insert(rate_key.metric, parsed_rate);
|
||||
}
|
||||
(Some(tier), true) => {
|
||||
entry
|
||||
.batch_tiers
|
||||
.insert((rate_key.metric, tier), parsed_rate);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
pricing.thresholds = thresholds.into_values().collect();
|
||||
pricing
|
||||
}
|
||||
}
|
||||
|
||||
fn count_value(value: &Value) -> Option<u64> {
|
||||
match value {
|
||||
Value::Null => Some(0),
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ from litellm.litellm_core_utils.llm_cost_calc.utils import (
|
|||
get_billed_token_rates,
|
||||
)
|
||||
from litellm.responses.utils import ResponseAPILoggingUtils
|
||||
from litellm.utils import register_model
|
||||
from litellm.utils import get_model_info, register_model
|
||||
from litellm.types.utils import Choices, Message, ModelResponse, Usage
|
||||
from openai.types.images_response import ImagesResponse
|
||||
|
||||
|
|
@ -1057,6 +1057,95 @@ def billed_rates_surface() -> list[dict[str, Any]]:
|
|||
return rows
|
||||
|
||||
|
||||
def pinning_threshold_cases() -> list[str]:
|
||||
return [
|
||||
"input_cost_per_token_above_128k_tokens",
|
||||
"input_cost_per_token_above_200k_tokens",
|
||||
"input_cost_per_token_above_256k_tokens",
|
||||
"input_cost_per_token_above_272k_tokens",
|
||||
"input_cost_per_token_above_512k_tokens",
|
||||
"input_cost_per_token_above_1k_tokens",
|
||||
"input_cost_per_token_above_500_tokens",
|
||||
"cache_creation_input_token_cost_above_1hr_above_200k_tokens",
|
||||
"cache_creation_input_token_cost_above_1hr",
|
||||
"input_cost_per_video_per_second_above_15s_interval",
|
||||
"input_cost_per_token",
|
||||
]
|
||||
|
||||
|
||||
PINNING_COST_PER_UNIT_CASES: tuple[tuple[dict[str, Any], str, float | None], ...] = (
|
||||
({"input_cost_per_token": 3e-6}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": 3}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": True}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": False}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": " 0.5 "}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": "garbage"}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": "garbage"}, "input_cost_per_token", 0.0),
|
||||
({}, "input_cost_per_token", None),
|
||||
({}, "input_cost_per_token", 0.0),
|
||||
({"input_cost_per_token": None}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": [1]}, "input_cost_per_token", None),
|
||||
({"input_cost_per_token": 1.0}, "input_cost_per_token_priority", None),
|
||||
({"input_cost_per_token": 1.0}, "input_cost_per_token_auto", None),
|
||||
({"input_cost_per_token": 1.0}, "input_cost_per_token_flex", None),
|
||||
({"input_cost_per_token_priority": 2.0}, "input_cost_per_token_priority", None),
|
||||
({"input_cost_per_token_flex": 2.0}, "input_cost_per_token_priority", None),
|
||||
({"input_cost_per_token": 1.0, "input_cost_per_token_priority": 2.0}, "input_cost_per_token_priority", None),
|
||||
({"input_cost_per_token_ultrafast": 2.0}, "input_cost_per_token_fast", None),
|
||||
)
|
||||
|
||||
|
||||
def pinning_surface() -> dict[str, Any]:
|
||||
from litellm.litellm_core_utils.llm_cost_calc import utils as cost_utils
|
||||
|
||||
thresholds: list[dict[str, Any]] = []
|
||||
for key in pinning_threshold_cases():
|
||||
try:
|
||||
thresholds.append({"key": key, "threshold": cost_utils._parse_above_token_threshold(key)})
|
||||
except Exception as error:
|
||||
thresholds.append({"key": key, "error": type(error).__name__})
|
||||
|
||||
cost_per_unit: list[dict[str, Any]] = []
|
||||
for model_info, cost_key, default in PINNING_COST_PER_UNIT_CASES:
|
||||
result = cost_utils._get_cost_per_unit(model_info, cost_key, default)
|
||||
cost_per_unit.append(
|
||||
{
|
||||
"model_info": model_info,
|
||||
"cost_key": cost_key,
|
||||
"default": default,
|
||||
"result": result,
|
||||
}
|
||||
)
|
||||
return {
|
||||
"thresholds": thresholds,
|
||||
"service_tier_suffixes": list(cost_utils._SERVICE_TIER_SUFFIXES),
|
||||
"batch_tier_key": cost_utils._BATCH_TIER_KEY.pattern,
|
||||
"cost_per_unit": cost_per_unit,
|
||||
}
|
||||
|
||||
|
||||
def model_info_projection_surface() -> dict[str, Any]:
|
||||
entry = {
|
||||
"max_tokens": 4_096,
|
||||
"max_input_tokens": 4_096,
|
||||
"max_output_tokens": 1_024,
|
||||
"input_cost_per_token": 1e-6,
|
||||
"output_cost_per_token": 2e-6,
|
||||
"input_cost_per_token_above_128k_tokens": 5e-7,
|
||||
"input_cost_per_token_above_128k_tokens_priority": 6e-7,
|
||||
"cache_read_input_token_cost": 1e-7,
|
||||
"litellm_provider": "synthetic",
|
||||
"mode": "chat",
|
||||
"supports_function_calling": True,
|
||||
"rpm": 100,
|
||||
"made_up_capability": "x",
|
||||
"input_cost_per_gadget": 0.5,
|
||||
}
|
||||
register_model({"synthetic-pinning-model": entry})
|
||||
info = get_model_info(model="synthetic-pinning-model", custom_llm_provider="synthetic")
|
||||
return {"registered": sorted(entry.keys()), "projected": sorted(info.keys())}
|
||||
|
||||
|
||||
def main() -> None:
|
||||
revision = subprocess.check_output(("git", "rev-parse", "HEAD"), text=True).strip()
|
||||
fixture = {
|
||||
|
|
@ -1070,10 +1159,16 @@ def main() -> None:
|
|||
"anthropic_usage": anthropic_usage_surface(),
|
||||
"wire_usage": wire_usage_surface(),
|
||||
"wire_response": wire_response_surface(),
|
||||
"pinning": pinning_surface(),
|
||||
"model_info_projection": model_info_projection_surface(),
|
||||
}
|
||||
target = Path(__file__).parent / "python_fixtures.json"
|
||||
target.write_text(json.dumps(fixture, indent=1) + "\n")
|
||||
counts = {key: len(value) for key, value in fixture.items() if isinstance(value, list)}
|
||||
counts = {
|
||||
key: len(value)
|
||||
for key, value in fixture.items()
|
||||
if isinstance(value, (list, dict)) and key != "model_info_projection"
|
||||
}
|
||||
print(json.dumps(counts))
|
||||
|
||||
|
||||
|
|
|
|||
181
litellm-rust/crates/cost/tests/pricing_grammar.rs
Normal file
181
litellm-rust/crates/cost/tests/pricing_grammar.rs
Normal file
|
|
@ -0,0 +1,181 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::sync::LazyLock;
|
||||
|
||||
use litellm_cost::pricing::{Metric, Rate, ServiceTier, tokenize};
|
||||
use litellm_cost::wire::{EMBEDDED_CATALOG, rate};
|
||||
|
||||
#[test]
|
||||
fn every_embedded_key_is_recognized_by_the_tokenizer() {
|
||||
let mut offenders: Vec<String> = Vec::new();
|
||||
for (model, entry) in EMBEDDED_CATALOG.iter() {
|
||||
let pricing = entry.pricing();
|
||||
for key in pricing.extra.keys() {
|
||||
offenders.push(format!("{model}: {key}"));
|
||||
}
|
||||
}
|
||||
assert!(
|
||||
offenders.is_empty(),
|
||||
"unrecognized keys in the embedded catalog (a new key shape would ship silently unpriced): {}",
|
||||
offenders.join(", ")
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn embedded_catalog_yields_decorated_and_plain_rates() {
|
||||
let mut thresholds = 0_usize;
|
||||
let mut tiers = 0_usize;
|
||||
let mut batches = 0_usize;
|
||||
let mut plain = 0_usize;
|
||||
for entry in EMBEDDED_CATALOG.values() {
|
||||
let pricing = entry.pricing();
|
||||
thresholds += pricing.thresholds.len();
|
||||
tiers += pricing.tiers.len();
|
||||
batches += pricing.batches.len();
|
||||
plain += pricing.base.len();
|
||||
}
|
||||
assert!(thresholds > 0);
|
||||
assert!(tiers > 0);
|
||||
assert!(batches > 0);
|
||||
assert!(plain > 0);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tokenizer_applies_the_rate_key_grammar() {
|
||||
let plain = tokenize("input_cost_per_token").expect("plain rate key");
|
||||
assert_eq!(plain.metric, Metric::InputPerToken);
|
||||
assert_eq!(plain.threshold, None);
|
||||
assert_eq!(plain.tier, None);
|
||||
assert!(!plain.batch);
|
||||
|
||||
let threshold = tokenize("input_cost_per_token_above_128k_tokens").expect("threshold key");
|
||||
assert_eq!(threshold.metric, Metric::InputPerToken);
|
||||
assert_eq!(threshold.threshold, Some(128_000));
|
||||
|
||||
let plain_threshold =
|
||||
tokenize("input_cost_per_token_above_512k_tokens").expect("threshold key");
|
||||
assert_eq!(plain_threshold.threshold, Some(512_000));
|
||||
|
||||
let one_hour = tokenize("cache_creation_input_token_cost_above_1hr").expect("1hr is a metric");
|
||||
assert_eq!(one_hour.metric, Metric::CacheCreationToken1hr);
|
||||
assert_eq!(one_hour.threshold, None);
|
||||
|
||||
let one_hour_threshold =
|
||||
tokenize("cache_creation_input_token_cost_above_1hr_above_200k_tokens")
|
||||
.expect("1hr metric with threshold");
|
||||
assert_eq!(one_hour_threshold.metric, Metric::CacheCreationToken1hr);
|
||||
assert_eq!(one_hour_threshold.threshold, Some(200_000));
|
||||
|
||||
let interval = tokenize("input_cost_per_video_per_second_above_15s_interval")
|
||||
.expect("interval-suffixed metric stays whole");
|
||||
assert_eq!(interval.metric, Metric::InputVideoPerSecond15sInterval);
|
||||
assert_eq!(interval.threshold, None);
|
||||
|
||||
let tiered = tokenize("input_cost_per_token_priority").expect("tier key");
|
||||
assert_eq!(tiered.tier, Some(ServiceTier::Priority));
|
||||
|
||||
let auto = tokenize("input_cost_per_token_auto").expect("auto is a grammar tier");
|
||||
assert_eq!(auto.tier, Some(ServiceTier::Auto));
|
||||
|
||||
let full = tokenize("cache_read_input_token_cost_above_272k_tokens_flex")
|
||||
.expect("threshold plus tier");
|
||||
assert_eq!(full.metric, Metric::CacheReadToken);
|
||||
assert_eq!(full.threshold, Some(272_000));
|
||||
assert_eq!(full.tier, Some(ServiceTier::Flex));
|
||||
|
||||
let batch = tokenize("cache_read_input_token_cost_above_272k_tokens_batches")
|
||||
.expect("threshold plus batch");
|
||||
assert_eq!(batch.threshold, Some(272_000));
|
||||
assert!(batch.batch);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tokenizer_rejects_unknown_metrics_and_malformed_decorations() {
|
||||
assert!(tokenize("input_cost_per_gadget").is_err());
|
||||
assert!(tokenize("input_cost_per_token_standard").is_err());
|
||||
assert!(tokenize("input_cost_per_token_above_128.5k_tokens").is_err());
|
||||
assert!(tokenize("input_cost_per_token_above_tokens").is_err());
|
||||
assert!(tokenize("max_tokens").is_err());
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn rate_parser_mirrors_get_cost_per_unit_coercions() {
|
||||
use serde_json::json;
|
||||
assert_eq!(rate(None), Rate::Missing);
|
||||
assert_eq!(rate(Some(&json!(null))), Rate::Null);
|
||||
assert_eq!(rate(Some(&json!(true))), Rate::Value(1.0));
|
||||
assert_eq!(rate(Some(&json!(false))), Rate::Value(0.0));
|
||||
assert_eq!(rate(Some(&json!(3))), Rate::Value(3.0));
|
||||
assert_eq!(rate(Some(&json!(3.5))), Rate::Value(3.5));
|
||||
assert_eq!(rate(Some(&json!(" 0.5 "))), Rate::Value(0.5));
|
||||
assert_eq!(rate(Some(&json!("not a number"))), Rate::Invalid);
|
||||
assert_eq!(rate(Some(&json!([1]))), Rate::Invalid);
|
||||
assert_eq!(rate(Some(&json!({"cost": 1}))), Rate::Invalid);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn parsed_pricing_buckets_a_synthetic_overlay_entry() {
|
||||
let entry: litellm_cost::wire::RawCatalogEntry = serde_json::from_value(serde_json::json!({
|
||||
"input_cost_per_token": 3e-6,
|
||||
"output_cost_per_token": 15e-6,
|
||||
"input_cost_per_token_above_128k_tokens": 1.5e-6,
|
||||
"input_cost_per_token_priority": 6e-6,
|
||||
"input_cost_per_token_batches": 1.5e-6,
|
||||
"cache_creation_input_token_cost_above_1hr_above_200k_tokens": 1e-6,
|
||||
"off_peak_pricing": {
|
||||
"input_cost_per_token": 1e-6,
|
||||
"hours_utc": "22:00-06:00"
|
||||
},
|
||||
"tiered_pricing": [
|
||||
{"range": [0, 16000], "input_cost_per_token": 1e-6, "output_cost_per_token": 2e-6}
|
||||
],
|
||||
"search_context_cost_per_query": {"search_context_size_medium": 3e-6},
|
||||
"provider_specific_entry": {"us": 1.1},
|
||||
"litellm_provider": "synthetic",
|
||||
"max_tokens": 8192,
|
||||
"supports_function_calling": true
|
||||
}))
|
||||
.expect("synthetic entry parses");
|
||||
let pricing = entry.pricing();
|
||||
assert_eq!(pricing.rate(Metric::InputPerToken), Rate::Value(3e-6));
|
||||
assert_eq!(
|
||||
pricing.tier_rate(Metric::InputPerToken, ServiceTier::Priority),
|
||||
Rate::Value(6e-6)
|
||||
);
|
||||
assert_eq!(
|
||||
pricing.batch_rate(Metric::InputPerToken),
|
||||
Rate::Value(1.5e-6)
|
||||
);
|
||||
let threshold = &pricing.thresholds[0];
|
||||
assert_eq!(threshold.above_tokens, 128_000);
|
||||
assert_eq!(
|
||||
threshold.standard.get(&Metric::InputPerToken),
|
||||
Some(&Rate::Value(1.5e-6))
|
||||
);
|
||||
let one_hour = &pricing.thresholds[1];
|
||||
assert_eq!(one_hour.above_tokens, 200_000);
|
||||
assert!(
|
||||
one_hour
|
||||
.standard
|
||||
.contains_key(&Metric::CacheCreationToken1hr)
|
||||
);
|
||||
let off_peak = pricing.off_peak.as_ref().expect("off peak parsed");
|
||||
assert_eq!(off_peak.input, Rate::Value(1e-6));
|
||||
assert_eq!(off_peak.hours_utc, vec!["22:00-06:00".to_string()]);
|
||||
let tier = &pricing.tiered_pricing.as_ref().expect("tiered parsed")[0];
|
||||
assert_eq!(tier.range, (0.0, Some(16_000.0)));
|
||||
assert_eq!(
|
||||
pricing
|
||||
.search_context_cost_per_query
|
||||
.expect("search context")
|
||||
.medium,
|
||||
Rate::Value(3e-6)
|
||||
);
|
||||
assert_eq!(
|
||||
pricing.provider_specific_entry.get("us"),
|
||||
Some(&Rate::Value(1.1))
|
||||
);
|
||||
assert_eq!(pricing.litellm_provider.as_deref(), Some("synthetic"));
|
||||
assert!(pricing.extra.is_empty(), "recognized non-rate keys drop");
|
||||
let _: LazyLock<()> = LazyLock::new(|| ());
|
||||
}
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::a2a_cost::calculate_a2a_cost;
|
||||
use litellm_cost::mcp_cost::calculate_mcp_tool_call_cost;
|
||||
use rstest::rstest;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::anthropic_usage::{
|
||||
is_anthropic_usage_object, transform_anthropic_usage_to_chat_usage,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::base_rate_selection::{
|
||||
TokenBaseRates, get_tiered_reasoning_rate, get_token_base_cost_without_off_peak,
|
||||
uses_inclusive_token_thresholds,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::catalog::{CatalogCallError, CostCall, ModelCostRequest, ModelInfoCatalog};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::catalog::ModelInfoCatalog;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use litellm_cost::billed_token_rates::{BilledTokenRates, TokenTypeCostBreakdown};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::batch::{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::catalog::{CatalogCustomError, CostCall, ModelCostRequest, ModelInfoCatalog};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,5 +1,5 @@
|
|||
{
|
||||
"python_commit": "492ac2e9c43ed8fc9ae18650f6d41987ff7ae0fc",
|
||||
"python_commit": "a8725892a4d1986e09e6db7a736f872083479de1",
|
||||
"generic": [
|
||||
{
|
||||
"id": "audio_mixed_modalities",
|
||||
|
|
@ -2122,5 +2122,373 @@
|
|||
}
|
||||
}
|
||||
}
|
||||
]
|
||||
],
|
||||
"pinning": {
|
||||
"thresholds": [
|
||||
{
|
||||
"key": "input_cost_per_token_above_128k_tokens",
|
||||
"threshold": 128000.0
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_token_above_200k_tokens",
|
||||
"threshold": 200000.0
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_token_above_256k_tokens",
|
||||
"threshold": 256000.0
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_token_above_272k_tokens",
|
||||
"threshold": 272000.0
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_token_above_512k_tokens",
|
||||
"threshold": 512000.0
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_token_above_1k_tokens",
|
||||
"threshold": 1000.0
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_token_above_500_tokens",
|
||||
"threshold": 500.0
|
||||
},
|
||||
{
|
||||
"key": "cache_creation_input_token_cost_above_1hr_above_200k_tokens",
|
||||
"error": "ValueError"
|
||||
},
|
||||
{
|
||||
"key": "cache_creation_input_token_cost_above_1hr",
|
||||
"error": "ValueError"
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_video_per_second_above_15s_interval",
|
||||
"error": "ValueError"
|
||||
},
|
||||
{
|
||||
"key": "input_cost_per_token",
|
||||
"error": "IndexError"
|
||||
}
|
||||
],
|
||||
"service_tier_suffixes": [
|
||||
"_ultrafast",
|
||||
"_priority",
|
||||
"_auto",
|
||||
"_flex",
|
||||
"_fast"
|
||||
],
|
||||
"batch_tier_key": "^(input_cost_per_token|output_cost_per_token|cache_read_input_token_cost|cache_creation_input_token_cost)_above_(\\d+k?)_tokens_batches$",
|
||||
"cost_per_unit": [
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": 3e-06
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": 3e-06
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": 3
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": 3.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": true
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": 1.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": false
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": 0.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": " 0.5 "
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": 0.5
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": "garbage"
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": null
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": "garbage"
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": 0.0,
|
||||
"result": 0.0
|
||||
},
|
||||
{
|
||||
"model_info": {},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": null
|
||||
},
|
||||
{
|
||||
"model_info": {},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": 0.0,
|
||||
"result": 0.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": null
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": null
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": [
|
||||
1
|
||||
]
|
||||
},
|
||||
"cost_key": "input_cost_per_token",
|
||||
"default": null,
|
||||
"result": null
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": 1.0
|
||||
},
|
||||
"cost_key": "input_cost_per_token_priority",
|
||||
"default": null,
|
||||
"result": 1.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": 1.0
|
||||
},
|
||||
"cost_key": "input_cost_per_token_auto",
|
||||
"default": null,
|
||||
"result": 1.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": 1.0
|
||||
},
|
||||
"cost_key": "input_cost_per_token_flex",
|
||||
"default": null,
|
||||
"result": 1.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token_priority": 2.0
|
||||
},
|
||||
"cost_key": "input_cost_per_token_priority",
|
||||
"default": null,
|
||||
"result": 2.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token_flex": 2.0
|
||||
},
|
||||
"cost_key": "input_cost_per_token_priority",
|
||||
"default": null,
|
||||
"result": null
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token": 1.0,
|
||||
"input_cost_per_token_priority": 2.0
|
||||
},
|
||||
"cost_key": "input_cost_per_token_priority",
|
||||
"default": null,
|
||||
"result": 2.0
|
||||
},
|
||||
{
|
||||
"model_info": {
|
||||
"input_cost_per_token_ultrafast": 2.0
|
||||
},
|
||||
"cost_key": "input_cost_per_token_fast",
|
||||
"default": null,
|
||||
"result": null
|
||||
}
|
||||
]
|
||||
},
|
||||
"model_info_projection": {
|
||||
"registered": [
|
||||
"cache_read_input_token_cost",
|
||||
"input_cost_per_gadget",
|
||||
"input_cost_per_token",
|
||||
"input_cost_per_token_above_128k_tokens",
|
||||
"input_cost_per_token_above_128k_tokens_priority",
|
||||
"litellm_provider",
|
||||
"made_up_capability",
|
||||
"max_input_tokens",
|
||||
"max_output_tokens",
|
||||
"max_tokens",
|
||||
"mode",
|
||||
"output_cost_per_token",
|
||||
"rpm",
|
||||
"supports_function_calling"
|
||||
],
|
||||
"projected": [
|
||||
"annotation_cost_per_page",
|
||||
"annotation_cost_per_page_batches",
|
||||
"bedrock_converse_supports_strict_tools",
|
||||
"bedrock_output_config_effort_ceiling",
|
||||
"cache_creation_input_token_cost",
|
||||
"cache_creation_input_token_cost_above_1hr",
|
||||
"cache_creation_input_token_cost_above_200k_tokens",
|
||||
"cache_creation_input_token_cost_above_272k_tokens",
|
||||
"cache_creation_input_token_cost_above_272k_tokens_batches",
|
||||
"cache_creation_input_token_cost_above_272k_tokens_flex",
|
||||
"cache_creation_input_token_cost_above_272k_tokens_priority",
|
||||
"cache_creation_input_token_cost_batches",
|
||||
"cache_creation_input_token_cost_flex",
|
||||
"cache_creation_input_token_cost_priority",
|
||||
"cache_creation_input_token_cost_ultrafast",
|
||||
"cache_read_input_audio_token_cost",
|
||||
"cache_read_input_token_cost",
|
||||
"cache_read_input_token_cost_above_200k_tokens",
|
||||
"cache_read_input_token_cost_above_200k_tokens_priority",
|
||||
"cache_read_input_token_cost_above_272k_tokens",
|
||||
"cache_read_input_token_cost_above_272k_tokens_batches",
|
||||
"cache_read_input_token_cost_above_272k_tokens_flex",
|
||||
"cache_read_input_token_cost_above_272k_tokens_priority",
|
||||
"cache_read_input_token_cost_above_512k_tokens",
|
||||
"cache_read_input_token_cost_batches",
|
||||
"cache_read_input_token_cost_flex",
|
||||
"cache_read_input_token_cost_priority",
|
||||
"cache_read_input_token_cost_ultrafast",
|
||||
"citation_cost_per_token",
|
||||
"default_reasoning_effort",
|
||||
"google_maps_grounding_cost_per_query",
|
||||
"input_cost_per_audio_per_second",
|
||||
"input_cost_per_audio_token",
|
||||
"input_cost_per_audio_token_batches",
|
||||
"input_cost_per_character",
|
||||
"input_cost_per_image",
|
||||
"input_cost_per_image_token",
|
||||
"input_cost_per_image_token_batches",
|
||||
"input_cost_per_query",
|
||||
"input_cost_per_second",
|
||||
"input_cost_per_token",
|
||||
"input_cost_per_token_above_128k_tokens",
|
||||
"input_cost_per_token_above_200k_tokens",
|
||||
"input_cost_per_token_above_200k_tokens_priority",
|
||||
"input_cost_per_token_above_272k_tokens",
|
||||
"input_cost_per_token_above_272k_tokens_batches",
|
||||
"input_cost_per_token_above_272k_tokens_flex",
|
||||
"input_cost_per_token_above_272k_tokens_priority",
|
||||
"input_cost_per_token_above_512k_tokens",
|
||||
"input_cost_per_token_batches",
|
||||
"input_cost_per_token_flex",
|
||||
"input_cost_per_token_priority",
|
||||
"input_cost_per_token_ultrafast",
|
||||
"input_cost_per_video_per_second",
|
||||
"input_cost_per_video_token",
|
||||
"input_cost_per_video_token_batches",
|
||||
"key",
|
||||
"litellm_provider",
|
||||
"max_input_tokens",
|
||||
"max_output_tokens",
|
||||
"max_tokens",
|
||||
"mode",
|
||||
"ocr_cost_per_credit",
|
||||
"ocr_cost_per_page",
|
||||
"ocr_cost_per_page_batches",
|
||||
"off_peak_pricing",
|
||||
"output_cost_per_audio_token",
|
||||
"output_cost_per_character",
|
||||
"output_cost_per_character_above_128k_tokens",
|
||||
"output_cost_per_image",
|
||||
"output_cost_per_image_token",
|
||||
"output_cost_per_pixel",
|
||||
"output_cost_per_reasoning_token",
|
||||
"output_cost_per_reasoning_token_flex",
|
||||
"output_cost_per_reasoning_token_priority",
|
||||
"output_cost_per_second",
|
||||
"output_cost_per_second_1080p",
|
||||
"output_cost_per_second_2k",
|
||||
"output_cost_per_second_480p",
|
||||
"output_cost_per_second_4k",
|
||||
"output_cost_per_second_720p",
|
||||
"output_cost_per_second_768p",
|
||||
"output_cost_per_token",
|
||||
"output_cost_per_token_above_128k_tokens",
|
||||
"output_cost_per_token_above_200k_tokens",
|
||||
"output_cost_per_token_above_200k_tokens_priority",
|
||||
"output_cost_per_token_above_272k_tokens",
|
||||
"output_cost_per_token_above_272k_tokens_batches",
|
||||
"output_cost_per_token_above_272k_tokens_flex",
|
||||
"output_cost_per_token_above_272k_tokens_priority",
|
||||
"output_cost_per_token_above_512k_tokens",
|
||||
"output_cost_per_token_batches",
|
||||
"output_cost_per_token_flex",
|
||||
"output_cost_per_token_priority",
|
||||
"output_cost_per_token_ultrafast",
|
||||
"output_cost_per_video_per_second",
|
||||
"output_cost_per_video_token",
|
||||
"output_vector_size",
|
||||
"prompt_cache_min_tokens",
|
||||
"provider_specific_entry",
|
||||
"reasoning_effort_levels",
|
||||
"regional_endpoint_uplift_multiplier",
|
||||
"regional_processing_uplift_multiplier_eu",
|
||||
"regional_processing_uplift_multiplier_us",
|
||||
"rpm",
|
||||
"search_context_cost_per_query",
|
||||
"supported_audio_formats",
|
||||
"supported_endpoints",
|
||||
"supported_openai_params",
|
||||
"supports_adaptive_thinking",
|
||||
"supports_anthropic_compaction",
|
||||
"supports_anthropic_thinking_payload",
|
||||
"supports_assistant_prefill",
|
||||
"supports_audio_input",
|
||||
"supports_audio_output",
|
||||
"supports_computer_use",
|
||||
"supports_embedding_image_input",
|
||||
"supports_function_calling",
|
||||
"supports_image_size",
|
||||
"supports_legacy_thinking",
|
||||
"supports_low_reasoning_effort",
|
||||
"supports_max_reasoning_effort",
|
||||
"supports_mid_conversation_system",
|
||||
"supports_minimal_reasoning_effort",
|
||||
"supports_native_streaming",
|
||||
"supports_native_structured_output",
|
||||
"supports_none_reasoning_effort",
|
||||
"supports_parallel_function_calling",
|
||||
"supports_pdf_input",
|
||||
"supports_prompt_cache_breakpoint",
|
||||
"supports_prompt_caching",
|
||||
"supports_reasoning",
|
||||
"supports_response_schema",
|
||||
"supports_system_messages",
|
||||
"supports_thinking_cache_preservation",
|
||||
"supports_tool_choice",
|
||||
"supports_tool_search",
|
||||
"supports_url_context",
|
||||
"supports_vision",
|
||||
"supports_web_search",
|
||||
"supports_xhigh_reasoning_effort",
|
||||
"thinking_always_on",
|
||||
"tiered_pricing",
|
||||
"tpm",
|
||||
"uses_embed_content",
|
||||
"vertex_ai_audio_api",
|
||||
"web_search_billing_unit"
|
||||
]
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use litellm_cost::gemini_cost::{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use jiff::Timestamp;
|
||||
use litellm_cost::generic_cost::{
|
||||
ResolvedTokenRates, billable_prompt_details, calculate_generic_cost_from_model_info,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::generic_input::{
|
||||
InputBaseRates, calculate_cache_writing_cost, calculate_cost_component, calculate_input_cost,
|
||||
get_cost_per_unit,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::generic_output::{calculate_output_cost, resolve_reasoning_token_cost};
|
||||
use litellm_cost::usage_dispatch::get_usage_object;
|
||||
use rstest::rstest;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::catalog::{ModelCostRequest, ModelInfoCatalog};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::generic_usage::{
|
||||
get_billable_input_tokens, parse_completion_tokens_details, parse_prompt_tokens_details,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::groq_cost::cost_per_web_search_request;
|
||||
use litellm_cost::usage_dispatch::get_usage_object;
|
||||
use rstest::rstest;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::BTreeMap;
|
||||
|
||||
use litellm_cost::guardrail_cost::{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::interactions_usage::{
|
||||
is_interactions_usage_object, transform_interactions_usage_object,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::catalog::ModelInfoCatalog;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use jiff::Timestamp;
|
||||
use litellm_cost::base_rate_selection::get_token_base_cost;
|
||||
use litellm_cost::off_peak::{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::non_token::Error;
|
||||
use litellm_cost::openai_cost::{
|
||||
cost_router, video_generation_cost, video_output_cost_per_second,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
173
litellm-rust/crates/cost/tests/python_pricing_pinning.rs
Normal file
173
litellm-rust/crates/cost/tests/python_pricing_pinning.rs
Normal file
|
|
@ -0,0 +1,173 @@
|
|||
// mirrors: crates/cost/tests/generate_python_fixtures.py (pinning + model_info_projection surfaces)
|
||||
|
||||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use serde_json::Value;
|
||||
|
||||
use litellm_cost::pricing::{Metric, ServiceTier, tokenize};
|
||||
use litellm_cost::wire::{RawCatalogEntry, cost_per_unit};
|
||||
|
||||
fn fixture() -> Value {
|
||||
serde_json::from_str(include_str!("python_fixtures.json")).expect("fixture parses")
|
||||
}
|
||||
|
||||
fn pinning() -> Value {
|
||||
fixture()["pinning"].clone()
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn tokenizer_agrees_with_parse_above_token_threshold_where_python_parses() {
|
||||
for row in pinning()["thresholds"].as_array().expect("threshold rows") {
|
||||
let key = row["key"].as_str().expect("key");
|
||||
if let Some(value) = row["threshold"].as_f64() {
|
||||
let rate_key = tokenize(key).expect("python-parsed keys tokenize");
|
||||
assert_eq!(rate_key.threshold, Some(value as u64), "key {key}");
|
||||
}
|
||||
}
|
||||
let no_threshold_keys = [
|
||||
"input_cost_per_video_per_second_above_15s_interval",
|
||||
"cache_creation_input_token_cost_above_1hr",
|
||||
"input_cost_per_token",
|
||||
];
|
||||
for key in no_threshold_keys {
|
||||
assert_eq!(
|
||||
tokenize(key).expect("tokenizes").threshold,
|
||||
None,
|
||||
"no token threshold for {key}"
|
||||
);
|
||||
}
|
||||
assert_eq!(
|
||||
tokenize("cache_creation_input_token_cost_above_1hr_above_200k_tokens")
|
||||
.expect("tokenizes")
|
||||
.threshold,
|
||||
Some(200_000)
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn service_tier_suffixes_match_python() {
|
||||
let pinning = pinning();
|
||||
let pinned: Vec<&str> = pinning["service_tier_suffixes"]
|
||||
.as_array()
|
||||
.expect("suffix list")
|
||||
.iter()
|
||||
.map(|value| value.as_str().expect("suffix string"))
|
||||
.collect();
|
||||
let rust: Vec<String> = ServiceTier::SUFFIXES
|
||||
.into_iter()
|
||||
.map(|tier| format!("_{}", tier.as_str()))
|
||||
.collect();
|
||||
assert_eq!(rust, pinned);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn batch_tier_grammar_matches_python_regex_language() {
|
||||
let pattern = pinning()["batch_tier_key"]
|
||||
.as_str()
|
||||
.expect("batch pattern")
|
||||
.to_string();
|
||||
let regex = regex::Regex::new(&pattern).expect("python batch pattern compiles");
|
||||
for prefix in [
|
||||
"input_cost_per_token",
|
||||
"output_cost_per_token",
|
||||
"cache_read_input_token_cost",
|
||||
"cache_creation_input_token_cost",
|
||||
] {
|
||||
for magnitude in ["1k", "128k", "500"] {
|
||||
let key = format!("{prefix}_above_{magnitude}_tokens_batches");
|
||||
let rate_key = tokenize(&key).unwrap_or_else(|_| panic!("{key} tokenizes"));
|
||||
assert!(regex.is_match(&key), "{key} matches python pattern");
|
||||
assert!(rate_key.batch);
|
||||
assert_eq!(
|
||||
rate_key.metric,
|
||||
Metric::parse(prefix).expect("known metric"),
|
||||
"{key}"
|
||||
);
|
||||
}
|
||||
}
|
||||
let rejected = [
|
||||
"input_cost_per_token_above_128.5k_tokens_batches",
|
||||
"input_cost_per_audio_token_above_128k_tokens_batches",
|
||||
"input_cost_per_token_above_128k_tokens",
|
||||
];
|
||||
for key in rejected {
|
||||
assert!(!regex.is_match(key), "{key} outside python pattern");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn cost_per_unit_replays_python_coercion_and_tier_fallback() {
|
||||
for row in pinning()["cost_per_unit"]
|
||||
.as_array()
|
||||
.expect("cost_per_unit rows")
|
||||
{
|
||||
let fields = row["model_info"].as_object().expect("model_info object");
|
||||
let cost_key = row["cost_key"].as_str().expect("cost key");
|
||||
let default = row["default"].as_f64();
|
||||
let expected = row["result"].as_f64();
|
||||
let actual = cost_per_unit(fields, cost_key, default);
|
||||
assert_eq!(actual, expected, "key {cost_key} default {default:?}");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn model_info_projection_passes_rate_keys_the_tokenizer_recognizes() {
|
||||
let fixture = fixture();
|
||||
let projected = fixture["model_info_projection"]["projected"]
|
||||
.as_array()
|
||||
.expect("projected keys");
|
||||
let mut unrecognized: Vec<&str> = Vec::new();
|
||||
for key in projected.iter().filter_map(Value::as_str) {
|
||||
let known = tokenize(key).is_ok()
|
||||
|| litellm_cost::wire::recognized_non_rate_key(key)
|
||||
|| matches!(
|
||||
key,
|
||||
"off_peak_pricing"
|
||||
| "tiered_pricing"
|
||||
| "search_context_cost_per_query"
|
||||
| "provider_specific_entry"
|
||||
| "guardrail_cost_per_unit"
|
||||
| "regional_processing_uplift_multiplier_eu"
|
||||
| "regional_processing_uplift_multiplier_us"
|
||||
| "regional_endpoint_uplift_multiplier"
|
||||
);
|
||||
if !known {
|
||||
unrecognized.push(key);
|
||||
}
|
||||
}
|
||||
assert!(
|
||||
unrecognized.is_empty(),
|
||||
"projected keys the tokenizer or allowlist must recognize: {unrecognized:?}"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn registered_entry_parses_into_model_pricing_with_projected_rates() {
|
||||
let entry: RawCatalogEntry = serde_json::from_value(serde_json::json!({
|
||||
"input_cost_per_token": 1e-6,
|
||||
"output_cost_per_token": 2e-6,
|
||||
"input_cost_per_token_above_128k_tokens": 5e-7,
|
||||
"input_cost_per_token_above_128k_tokens_priority": 6e-7,
|
||||
"cache_read_input_token_cost": 1e-7,
|
||||
}))
|
||||
.expect("synthetic entry parses");
|
||||
let pricing = entry.pricing();
|
||||
assert_eq!(pricing.rate(Metric::InputPerToken).value(), Some(1e-6));
|
||||
assert_eq!(pricing.rate(Metric::CacheReadToken).value(), Some(1e-7));
|
||||
let threshold = &pricing.thresholds[0];
|
||||
assert_eq!(threshold.above_tokens, 128_000);
|
||||
assert_eq!(
|
||||
threshold
|
||||
.standard
|
||||
.get(&Metric::InputPerToken)
|
||||
.and_then(|r| r.value()),
|
||||
Some(5e-7)
|
||||
);
|
||||
assert_eq!(
|
||||
threshold
|
||||
.tiers
|
||||
.get(&(Metric::InputPerToken, ServiceTier::Priority))
|
||||
.and_then(|r| r.value()),
|
||||
Some(6e-7)
|
||||
);
|
||||
}
|
||||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::ptu_pricing::{
|
||||
MAX_COST_PER_PTU_PER_HOUR, MAX_PTU_COUNT, PTU_ZEROED_PRICING_FIELDS, SEARCH_CONTEXT_SIZES,
|
||||
azure_spillover, declares_ptu, is_spilled_over_ptu_request, ptu_config_error,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use jiff::Timestamp;
|
||||
use litellm_cost::generic_cost::calculate_generic_cost_from_model_info_with_region;
|
||||
use litellm_cost::regional_uplift::{
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::responses_usage::{
|
||||
UsageError, is_response_api_usage, text_tokens_without_nested_reasoning,
|
||||
transform_response_api_usage_to_chat_usage,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::retrieval_cost::{rerank_cost, vector_store_search_cost};
|
||||
use rstest::rstest;
|
||||
use serde_json::json;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::catalog::ModelInfoCatalog;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::tiered_pricing::{select_tier_for_input, tier_rate};
|
||||
use rstest::rstest;
|
||||
use serde_json::{Value, json};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::tool_call_cost_tracking::{
|
||||
DefaultToolRates, ResponseKind, chat_completion_response_includes_annotations,
|
||||
count_web_search_calls, extract_file_search_params, extract_token_counts,
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::tool_call_cost_tracking::{DefaultToolRates, ResponseKind};
|
||||
use litellm_cost::tool_cost_dispatch::{BuiltInToolCostRequest, get_cost_for_built_in_tools};
|
||||
use litellm_cost::usage_dispatch::get_usage_object;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::transcription_usage::{
|
||||
is_transcription_usage_object, transform_transcription_usage_object,
|
||||
};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use litellm_cost::usage_dispatch::get_usage_object;
|
||||
use rstest::rstest;
|
||||
use serde_json::{Value, json};
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
// mirrors: crates/cost/tests/generate_python_fixtures.py (wire_usage + wire_response surfaces)
|
||||
|
||||
use serde_json::Value;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use jiff::Timestamp;
|
||||
|
|
|
|||
|
|
@ -1,3 +1,5 @@
|
|||
#![allow(clippy::disallowed_types)]
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
use litellm_cost::catalog::ModelInfoCatalog;
|
||||
|
|
|
|||
Loading…
Add table
Reference in a new issue