pricing.rs

crates/cortex-core/src/pricing.rs

1. //! Models and their prices.
2. //!
3. //! DeepInfra's `GET /v1/openai/models` needs no key and carries, per model,
4. //! `metadata.pricing` in US dollars per million tokens (`input_tokens`,
5. //! `output_tokens`, sometimes `cache_read_tokens`), the context length, and
6. //! tags (`chat`, `vision`, `reasoning`, ...). That list is an extension to the
7. //! OpenAI format rather than a documented contract, so a dated snapshot ships
8. //! with the app as a fallback and the interface says which one is in use.
9. //! Local servers list bare model ids; they cost nothing.
11. use serde::{Deserialize, Serialize};
12. use serde_json::Value;
13. use ts_rs::TS;
15. use crate::types::Prices;
17. /// Anything above this per million tokens is treated as a parsing mistake.
18. const PRICE_CEILING: f64 = 1000.0;
20. #[derive(Debug, Clone, PartialEq, Serialize, Deserialize, TS)]
21. #[ts(export)]
22. pub struct ModelInfo {
23. pub provider_id: String,
24. pub id: String,
25. pub prices: Prices,
26. #[ts(type = "number | null")]
27. pub context_length: Option<i64>,
28. #[ts(type = "number | null")]
29. pub max_tokens: Option<i64>,
30. pub tags: Vec<String>,
31. }
33. impl ModelInfo {
34. pub fn has_tag(&self, tag: &str) -> bool {
35. self.tags.iter().any(|t| t == tag)
36. }
37. pub fn vision(&self) -> bool {
38. self.has_tag("vision") || self.has_tag("vlm")
39. }
40. }
42. fn price(v: Option<&Value>) -> Option<f64> {
43. let p = v?.as_f64()?;
44. (p.is_finite() && (0.0..=PRICE_CEILING).contains(&p)).then_some(p)
45. }
47. /// DeepInfra's list (live or snapshot): chat models with token prices only.
48. pub fn parse_priced_models(provider_id: &str, v: &Value) -> Vec<ModelInfo> {
49. let Some(data) = v.get("data").and_then(Value::as_array) else { return vec![] };
50. let mut out: Vec<ModelInfo> = data
51. .iter()
52. .filter_map(|m| {
53. let id = m.get("id")?.as_str()?.to_string();
54. let meta = m.get("metadata")?;
55. let tags: Vec<String> = meta
56. .get("tags")
57. .and_then(Value::as_array)
58. .map(|a| a.iter().filter_map(|t| t.as_str().map(str::to_string)).collect())
59. .unwrap_or_default();
60. if !tags.iter().any(|t| t == "chat") {
61. return None;
62. }
63. let p = meta.get("pricing")?;
64. let prices = Prices {
65. input_per_m: price(p.get("input_tokens"))?,
66. output_per_m: price(p.get("output_tokens"))?,
67. cache_read_per_m: price(p.get("cache_read_tokens")),
68. };
69. Some(ModelInfo {
70. provider_id: provider_id.to_string(),
71. id,
72. prices,
73. context_length: meta.get("context_length").and_then(Value::as_i64),
74. max_tokens: meta.get("max_tokens").and_then(Value::as_i64),
75. tags,
76. })
77. })
78. .collect();
79. out.sort_by_key(|m| m.id.to_lowercase());
80. out
81. }
83. /// A local server's `{"data": [{"id": ...}]}`: every model free.
84. pub fn parse_local_models(provider_id: &str, v: &Value) -> Vec<ModelInfo> {
85. let Some(data) = v.get("data").and_then(Value::as_array) else { return vec![] };
86. let mut out: Vec<ModelInfo> = data
87. .iter()
88. .filter_map(|m| m.get("id")?.as_str())
89. .map(|id| ModelInfo {
90. provider_id: provider_id.to_string(),
91. id: id.to_string(),
92. prices: Prices::default(),
93. context_length: None,
94. max_tokens: None,
95. tags: vec!["chat".into(), "local".into()],
96. })
97. .collect();
98. out.sort_by(|a, b| a.id.cmp(&b.id));
99. out
100. }
102. /// The bundled fallback, written by `scripts/snapshot-pricing.mjs`.
103. pub const SNAPSHOT_JSON: &str = include_str!("../data/pricing-snapshot.json");
105. pub struct Snapshot {
106. pub fetched_at: String,
107. pub models: Vec<ModelInfo>,
108. }
110. pub fn snapshot(provider_id: &str) -> Snapshot {
111. let v: Value = serde_json::from_str(SNAPSHOT_JSON).expect("bundled pricing snapshot is valid JSON");
112. Snapshot {
113. fetched_at: v.get("fetched_at").and_then(Value::as_str).unwrap_or("unknown").to_string(),
114. models: parse_priced_models(provider_id, &v),
115. }
116. }
118. #[cfg(test)]
119. mod tests {
120. use super::*;
122. #[test]
123. fn keeps_priced_chat_models_only() {
124. let models = parse_priced_models("deepinfra", &standin::models());
125. let ids: Vec<&str> = models.iter().map(|m| m.id.as_str()).collect();
126. assert!(ids.contains(&"standin/echo"));
127. assert!(!ids.contains(&"standin/embed") && !ids.contains(&"standin/image"));
128. let cached = models.iter().find(|m| m.id == "standin/cached").unwrap();
129. assert_eq!(cached.prices.cache_read_per_m, Some(0.1));
130. assert!(models.iter().find(|m| m.id == "standin/vision").unwrap().vision());
131. }
133. #[test]
134. fn rejects_absurd_prices() {
135. let v = serde_json::json!({"data": [
136. {"id": "a", "metadata": {"tags": ["chat"], "pricing": {"input_tokens": 5000.0, "output_tokens": 1.0}}},
137. {"id": "b", "metadata": {"tags": ["chat"], "pricing": {"input_tokens": -1.0, "output_tokens": 1.0}}},
138. {"id": "c", "metadata": {"tags": ["chat"], "pricing": {"input_tokens": 0.1}}},
139. {"id": "d", "metadata": {"tags": ["chat"], "pricing": {"input_tokens": 0.1, "output_tokens": 0.2}}}
140. ]});
141. let ids: Vec<String> = parse_priced_models("p", &v).into_iter().map(|m| m.id).collect();
142. assert_eq!(ids, ["d"]);
143. }
145. #[test]
146. fn local_models_are_free() {
147. let v = serde_json::json!({"object": "list", "data": [{"id": "qwen3:8b"}, {"id": "llama3.2"}]});
148. let m = parse_local_models("ollama", &v);
149. assert_eq!(m[0].id, "llama3.2");
150. assert_eq!(m[0].prices, Prices::default());
151. }
153. #[test]
154. fn bundled_snapshot_parses() {
155. let s = snapshot("deepinfra");
156. assert!(s.models.len() > 20, "snapshot has {} chat models", s.models.len());
157. assert!(s.fetched_at.starts_with("20"));
158. assert!(s.models.iter().all(|m| m.has_tag("chat")));
159. }
160. }