#[cfg(feature = "json")]
use crate::error::RouterError;
#[cfg(feature = "serde")]
use serde::{Deserialize, Serialize};
use std::collections::BTreeMap;
#[derive(Debug, Clone, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
pub struct ModelPricing {
pub input_per_1m: f64,
pub output_per_1m: f64,
pub context_window: usize,
pub max_output_tokens: usize,
pub quality_tier: u8,
#[cfg_attr(feature = "serde", serde(default))]
updated_at_unix: Option<u64>,
}
impl ModelPricing {
pub fn new(input_per_1m: f64, output_per_1m: f64) -> Self {
Self {
input_per_1m,
output_per_1m,
..ModelPricing::default()
}
}
pub fn with_context_window(mut self, context_window: usize) -> Self {
self.context_window = context_window;
self
}
pub fn with_max_output_tokens(mut self, max_output_tokens: usize) -> Self {
self.max_output_tokens = max_output_tokens;
self
}
pub fn with_quality_tier(mut self, quality_tier: u8) -> Self {
self.quality_tier = quality_tier;
self
}
pub fn with_updated_at_unix(mut self, updated_at_unix: u64) -> Self {
self.updated_at_unix = Some(updated_at_unix);
self
}
pub fn with_updated_at_now(self) -> Self {
let now = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.map(|d| d.as_secs())
.unwrap_or(0);
self.with_updated_at_unix(now)
}
pub fn updated_at_unix(&self) -> Option<u64> {
self.updated_at_unix
}
pub fn is_newer_than(&self, other: &Self) -> bool {
match (self.updated_at_unix, other.updated_at_unix) {
(Some(mine), Some(theirs)) => mine > theirs,
(Some(_), None) => true,
(None, _) => false,
}
}
pub fn cost(&self, input_tokens: usize, output_tokens: usize) -> f64 {
(input_tokens as f64 * self.input_per_1m / 1_000_000.0)
+ (output_tokens as f64 * self.output_per_1m / 1_000_000.0)
}
pub fn efficiency(&self) -> f64 {
let avg_cost = (self.input_per_1m + self.output_per_1m) / 2.0;
if avg_cost > 0.0 {
self.quality_tier as f64 / avg_cost
} else {
f64::MAX
}
}
}
impl Default for ModelPricing {
fn default() -> Self {
Self {
input_per_1m: 1.0,
output_per_1m: 3.0,
context_window: 128_000,
max_output_tokens: 4_096,
quality_tier: 3,
updated_at_unix: None,
}
}
}
pub fn default_pricing_table() -> BTreeMap<String, ModelPricing> {
let mut table = BTreeMap::new();
let mut insert = |key: &str, pricing: ModelPricing| {
table.insert(key.to_string(), pricing);
};
insert(
"claude-sonnet-4-20250514",
ModelPricing::new(3.0, 15.0)
.with_context_window(200_000)
.with_max_output_tokens(16_384)
.with_quality_tier(5),
);
insert(
"claude-3-5-sonnet-20241022",
ModelPricing::new(3.0, 15.0)
.with_context_window(200_000)
.with_max_output_tokens(8_192)
.with_quality_tier(4),
);
insert(
"claude-3-5-haiku-20241022",
ModelPricing::new(0.8, 4.0)
.with_context_window(200_000)
.with_max_output_tokens(8_192)
.with_quality_tier(3),
);
insert(
"claude-3-opus-20240229",
ModelPricing::new(15.0, 75.0)
.with_context_window(200_000)
.with_max_output_tokens(4_096)
.with_quality_tier(5),
);
insert(
"gpt-4o",
ModelPricing::new(2.5, 10.0)
.with_context_window(128_000)
.with_max_output_tokens(16_384)
.with_quality_tier(4),
);
insert(
"gpt-4o-mini",
ModelPricing::new(0.15, 0.6)
.with_context_window(128_000)
.with_max_output_tokens(16_384)
.with_quality_tier(3),
);
insert(
"gpt-4-turbo",
ModelPricing::new(10.0, 30.0)
.with_context_window(128_000)
.with_max_output_tokens(4_096)
.with_quality_tier(5),
);
insert(
"gemini-2.0-flash",
ModelPricing::new(0.1, 0.4)
.with_context_window(1_000_000)
.with_max_output_tokens(8_192)
.with_quality_tier(3),
);
insert(
"gemini-1.5-pro",
ModelPricing::new(1.25, 5.0)
.with_context_window(2_000_000)
.with_max_output_tokens(8_192)
.with_quality_tier(4),
);
insert(
"glm-4.6",
ModelPricing::new(0.5, 0.5)
.with_context_window(128_000)
.with_max_output_tokens(4_096)
.with_quality_tier(3),
);
insert(
"glm-5-turbo",
ModelPricing::new(0.5, 0.5)
.with_context_window(128_000)
.with_max_output_tokens(4_096)
.with_quality_tier(3),
);
insert(
"deepseek-chat",
ModelPricing::new(0.14, 0.28)
.with_context_window(64_000)
.with_max_output_tokens(8_192)
.with_quality_tier(3),
);
insert(
"deepseek-coder",
ModelPricing::new(0.14, 0.28)
.with_context_window(64_000)
.with_max_output_tokens(8_192)
.with_quality_tier(3),
);
insert(
"anthropic/claude-3.5-sonnet",
ModelPricing::new(3.0, 15.0)
.with_context_window(200_000)
.with_max_output_tokens(8_192)
.with_quality_tier(4),
);
insert(
"openai/gpt-4o",
ModelPricing::new(2.5, 10.0)
.with_context_window(128_000)
.with_max_output_tokens(16_384)
.with_quality_tier(4),
);
insert(
"google/gemma-3-4b-it:free",
ModelPricing::new(0.0, 0.0)
.with_context_window(32_000)
.with_max_output_tokens(4_096)
.with_quality_tier(2),
);
insert(
"openai/gpt-oss-20b:free",
ModelPricing::new(0.0, 0.0)
.with_context_window(32_000)
.with_max_output_tokens(4_096)
.with_quality_tier(2),
);
table
}
#[derive(Debug, Clone, Default, PartialEq)]
#[cfg_attr(feature = "serde", derive(Serialize, Deserialize), serde(transparent))]
pub struct PricingTable {
entries: BTreeMap<String, ModelPricing>,
}
impl PricingTable {
pub fn new() -> Self {
Self::default()
}
pub fn with_defaults() -> Self {
Self {
entries: default_pricing_table(),
}
}
pub fn insert(
&mut self,
model: impl Into<String>,
pricing: ModelPricing,
) -> Option<ModelPricing> {
self.entries.insert(model.into(), pricing)
}
pub fn get(&self, model: &str) -> Option<&ModelPricing> {
self.entries.get(model)
}
pub fn len(&self) -> usize {
self.entries.len()
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
pub fn iter(&self) -> impl Iterator<Item = (&str, &ModelPricing)> {
self.entries
.iter()
.map(|(model, pricing)| (model.as_str(), pricing))
}
pub fn merge(&mut self, other: &PricingTable) {
merge_into(&mut self.entries, other);
}
#[cfg(feature = "json")]
pub fn from_json(json: &str) -> Result<Self, RouterError> {
serde_json::from_str(json).map_err(|e| RouterError::Json(e.to_string()))
}
#[cfg(feature = "json")]
pub fn to_json(&self) -> Result<String, RouterError> {
serde_json::to_string(self).map_err(|e| RouterError::Json(e.to_string()))
}
}
pub(crate) fn merge_into(entries: &mut BTreeMap<String, ModelPricing>, other: &PricingTable) {
for (model, incoming) in other.iter() {
match entries.get(model) {
Some(existing) if !incoming.is_newer_than(existing) => {}
_ => {
entries.insert(model.to_string(), incoming.clone());
}
}
}
}