mod connector;
mod details;
mod facts;
mod lookup;
mod read;
mod row;
mod spec;
use std::sync::{Arc, OnceLock};
use std::time::{Duration, SystemTime, UNIX_EPOCH};
use crate::providers::registry::{Format, ProviderId};
use row::Row;
pub use connector::{Connector, ModelStatus, Provide, SignIn, Transport};
pub use details::{
CostDetails, CostTier, Interleaved, Mode, ModelDetails, ProviderOverride, Rates, Tier,
};
pub use facts::ModelFacts;
pub use lookup::{Matched, NotFound, Resolved, closest_name, edit_distance};
pub use read::{OverrideError, OverrideErrorKind, OverrideErrors, SkipReason, Skipped};
pub use spec::{
CacheSupport, ChatTools, Compat, Modalities, ModelSpec, Pricing, ReasoningChoice,
ReasoningSupport, Sampling, UnknownReasoning,
};
const BUILTIN: &str = include_str!("models.json");
#[derive(Clone, Debug, Default)]
pub struct Catalog {
entries: Arc<Vec<Entry>>,
}
#[derive(Clone, Debug)]
struct Entry {
row: Arc<Row>,
spec: Arc<ModelSpec>,
}
#[non_exhaustive]
#[derive(Debug, thiserror::Error)]
pub enum CatalogError {
#[error("not a models.dev-style catalog: {0}")]
Json(#[from] serde_json::Error),
}
const KEYS: [(&str, &str); 9] = [
("azure", "azure.openai"),
("google", "gcp.gemini"),
("google-vertex", "vertexai"),
("amazon-bedrock", "aws_bedrock"),
("togetherai", "together"),
("moonshotai", "moonshot"),
("xiaomi", "xiaomimimo"),
("ollama-cloud", "ollama"),
("github-copilot", "copilot"),
];
impl Catalog {
pub fn builtin() -> &'static Catalog {
static BUILTIN_CATALOG: OnceLock<Catalog> = OnceLock::new();
BUILTIN_CATALOG.get_or_init(|| match Catalog::from_models_dev(BUILTIN) {
Ok((catalog, skipped)) if skipped.is_empty() => catalog,
#[allow(clippy::panic)]
Ok((_, skipped)) => panic!(
"rig-core's built-in catalog data skips {}: {:?}",
skipped.len(),
skipped.first()
),
#[allow(clippy::panic)]
Err(error) => panic!("rig-core's built-in catalog data does not parse: {error}"),
})
}
pub fn generated_at() -> SystemTime {
crate::error::rfc3339(include_str!("generated_at").trim_ascii_end())
.and_then(|nanos| u64::try_from(nanos).ok())
.map_or(UNIX_EPOCH, |nanos| UNIX_EPOCH + Duration::from_nanos(nanos))
}
pub fn get(&self, provider: ProviderId, model: &str) -> Option<Resolved<'_>> {
self.get_vendor(provider.vendor(), model)
}
pub fn get_exact(&self, provider: ProviderId, model: &str) -> Option<&ModelSpec> {
self.exact(provider.vendor(), model)
}
pub fn resolve(&self, reference: &str) -> Result<Resolved<'_>, NotFound> {
Reference::parse(reference)
.and_then(|parsed| self.get_vendor(parsed.vendor, parsed.model))
.ok_or_else(|| self.not_found(reference))
}
pub(crate) fn not_found(&self, reference: &str) -> NotFound {
let mut suggestions = lookup::suggestions(reference, self.iter());
if suggestions.is_empty() {
suggestions = lookup::vendor_models(reference, self.iter());
}
NotFound {
reference: reference.to_owned(),
suggestions,
}
}
pub fn iter(&self) -> impl Iterator<Item = &ModelSpec> {
self.entries.iter().map(|entry| &*entry.spec)
}
pub fn with_overrides(&self, overrides: &Catalog) -> Catalog {
let mut catalog = self.clone();
for entry in overrides.entries.iter() {
catalog.put(
entry.spec.provider,
&entry.spec.id,
Row::clone(&entry.row),
Row::overlay,
);
}
catalog
}
pub fn with_models_dev(&self, fetched: &Catalog) -> Catalog {
let mut catalog = self.clone();
for entry in fetched.entries.iter() {
let (provider, id) = (entry.spec.provider, entry.spec.id.as_str());
let row = Row::clone(&entry.row);
let row = match catalog.position(provider.vendor(), id) {
Ok(index) => match catalog.entries.get(index) {
Some(base) => row.without(base.row.pinned()),
None => row,
},
Err(_) => row,
};
catalog.put(provider, id, row, Row::refresh);
}
catalog
}
pub fn insert(&mut self, spec: ModelSpec) {
let position = self.position(spec.provider.vendor(), &spec.id);
let entry = Entry {
row: Arc::new(Row::from_spec(&spec)),
spec: Arc::new(spec),
};
let entries = Arc::make_mut(&mut self.entries);
match position {
Ok(index) => {
if let Some(slot) = entries.get_mut(index) {
*slot = entry;
}
}
Err(index) => entries.insert(index, entry),
}
}
pub(crate) fn get_vendor(&self, vendor: &str, model: &str) -> Option<Resolved<'_>> {
if let Some(shared) = self.entry(vendor, model) {
return Some(Resolved {
spec: shared,
matched: Matched::Exact,
shared,
});
}
lookup::snapshot_bases(model).find_map(|base| {
self.entry(vendor, base).map(|shared| Resolved {
spec: shared,
matched: Matched::SnapshotOf(shared.id.clone()),
shared,
})
})
}
fn exact(&self, vendor: &str, model: &str) -> Option<&ModelSpec> {
self.entry(vendor, model).map(|spec| &**spec)
}
fn entry(&self, vendor: &str, model: &str) -> Option<&Arc<ModelSpec>> {
self.position(vendor, model)
.ok()
.and_then(|index| self.entries.get(index))
.map(|entry| &entry.spec)
}
fn position(&self, vendor: &str, model: &str) -> Result<usize, usize> {
self.entries.binary_search_by(|entry| {
(entry.spec.provider.vendor(), entry.spec.id.as_str()).cmp(&(vendor, model))
})
}
fn put(&mut self, provider: ProviderId, id: &str, row: Row, merge: fn(Row, Row) -> Row) {
let position = self.position(provider.vendor(), id);
let entries = Arc::make_mut(&mut self.entries);
match position {
Ok(index) => {
if let Some(entry) = entries.get_mut(index) {
let row = merge(Row::clone(&entry.row), row);
entry.spec = Arc::new(row.spec(entry.spec.provider, id));
entry.row = Arc::new(row);
}
}
Err(index) => {
let spec = Arc::new(row.spec(provider, id));
entries.insert(
index,
Entry {
row: Arc::new(row),
spec,
},
);
}
}
}
}
fn vendor_of(key: &str) -> &str {
KEYS.iter()
.find_map(|(models_dev, vendor)| (*models_dev == key).then_some(*vendor))
.unwrap_or(key)
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct Reference<'a> {
pub(crate) vendor: &'a str,
pub(crate) model: &'a str,
pub(crate) format: Option<Format>,
}
impl<'a> Reference<'a> {
pub(crate) fn parse(text: &'a str) -> Option<Self> {
let (vendor, rest) = text.split_once('/')?;
if vendor.is_empty() || rest.is_empty() {
return None;
}
if let Some((format, model)) = rest.split_once(':')
&& let Some(format) = Format::named(format)
{
return (!model.is_empty()).then_some(Self {
vendor,
model,
format: Some(format),
});
}
Some(Self {
vendor,
model: rest,
format: None,
})
}
}
#[cfg(test)]
mod tests;