use std::collections::BTreeMap;
use std::path::PathBuf;
use std::sync::atomic::{AtomicBool, Ordering};
use std::sync::{Arc, Mutex};
use std::time::{Duration, Instant, SystemTime};
use anyhow::Context;
use serde::Deserialize;
const CATALOG_URL: &str = "https://models.dev/api.json";
const CACHE_FILE: &str = "models-dev.json";
const CACHE_TTL: Duration = Duration::from_secs(24 * 60 * 60);
const FETCH_TIMEOUT: Duration = Duration::from_secs(30);
const OPENAI_COMPATIBLE_NPM: &[&str] = &[
"@ai-sdk/openai-compatible",
"@ai-sdk/openai",
"@openrouter/ai-sdk-provider",
];
#[derive(Clone, Copy, Debug, PartialEq, Eq, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Wire {
OpenAi,
Anthropic,
}
impl Wire {
pub fn as_str(self) -> &'static str {
match self {
Wire::OpenAi => "openai",
Wire::Anthropic => "anthropic",
}
}
}
struct Builtin {
id: &'static str,
base_url: &'static str,
key_env: &'static str,
wire: Wire,
}
const BUILTIN_ENDPOINTS: &[Builtin] = &[
Builtin {
id: "openai",
base_url: "https://api.openai.com/v1",
key_env: "OPENAI_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "anthropic",
base_url: "https://api.anthropic.com/v1",
key_env: "ANTHROPIC_API_KEY",
wire: Wire::Anthropic,
},
Builtin {
id: "google",
base_url: "https://generativelanguage.googleapis.com/v1beta/openai",
key_env: "GEMINI_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "groq",
base_url: "https://api.groq.com/openai/v1",
key_env: "GROQ_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "mistral",
base_url: "https://api.mistral.ai/v1",
key_env: "MISTRAL_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "xai",
base_url: "https://api.x.ai/v1",
key_env: "XAI_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "cerebras",
base_url: "https://api.cerebras.ai/v1",
key_env: "CEREBRAS_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "togetherai",
base_url: "https://api.together.xyz/v1",
key_env: "TOGETHER_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "deepinfra",
base_url: "https://api.deepinfra.com/v1/openai",
key_env: "DEEPINFRA_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "perplexity",
base_url: "https://api.perplexity.ai",
key_env: "PERPLEXITY_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "cohere",
base_url: "https://api.cohere.ai/compatibility/v1",
key_env: "COHERE_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "venice",
base_url: "https://api.venice.ai/api/v1",
key_env: "VENICE_API_KEY",
wire: Wire::OpenAi,
},
Builtin {
id: "vercel",
base_url: "https://ai-gateway.vercel.sh/v1",
key_env: "AI_GATEWAY_API_KEY",
wire: Wire::OpenAi,
},
];
pub const REMOTE_PREFIX: &str = "llmman.provider/";
pub const PLACEHOLDER_API_KEY: &str = "llmman";
pub fn format_remote_ref(provider: &str, model: &str) -> String {
format!("{REMOTE_PREFIX}{provider}/{model}")
}
pub fn split_remote_ref(reference: &str) -> Option<(&str, &str)> {
let rest = reference.strip_prefix(REMOTE_PREFIX)?;
let (provider, model) = rest.split_once('/')?;
(!provider.is_empty() && !model.is_empty()).then_some((provider, model))
}
pub fn is_remote_ref(reference: &str) -> bool {
split_remote_ref(reference).is_some()
}
#[derive(Clone, Debug, PartialEq)]
pub struct Provider {
pub id: String,
pub name: String,
pub base_url: String,
pub key_env: Option<String>,
pub wire: Wire,
pub key_optional: bool,
pub models: Vec<Model>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Model {
pub id: String,
pub cost: Option<Cost>,
pub max_output: Option<u32>,
pub max_context: Option<u64>,
pub thinking: Option<Vec<String>>,
}
#[derive(Clone, Debug, PartialEq)]
pub struct Cost {
pub input: f64,
pub output: f64,
pub cache_read: Option<f64>,
pub cache_write: Option<f64>,
pub reasoning: Option<f64>,
pub tiers: Vec<Tier>,
}
impl Cost {
pub fn flat(input: f64, output: f64) -> Self {
Self {
input,
output,
cache_read: None,
cache_write: None,
reasoning: None,
tiers: Vec::new(),
}
}
}
#[derive(Clone, Debug, PartialEq)]
pub struct Tier {
pub above: u64,
pub price: Cost,
}
impl Provider {
pub fn api_key(&self) -> Option<String> {
key_for(&self.id, self.key_env.as_deref())
}
pub fn url(&self, route: &str) -> String {
rebase_url(&self.base_url, route)
}
pub fn from_configured(conf: &crate::config::ConfiguredProvider) -> Self {
Self {
id: conf.id.clone(),
name: conf.name.clone(),
base_url: conf.base_url.clone(),
key_env: conf.key_env.clone(),
wire: conf.wire,
key_optional: true,
models: Vec::new(),
}
}
}
pub fn key_for(id: &str, var: Option<&str>) -> Option<String> {
resolve_key(
var.and_then(key_from_env),
crate::config::provider_api_key(id).as_deref(),
)
}
fn resolve_key(from_env: Option<String>, from_conf: Option<&str>) -> Option<String> {
from_env.or_else(|| {
from_conf
.map(|k| k.trim().to_string())
.filter(|k| !k.is_empty())
})
}
pub(crate) fn key_from_env(var: &str) -> Option<String> {
std::env::var(var)
.ok()
.map(|v| v.trim().to_string())
.filter(|v| !v.is_empty())
}
pub fn key_hint(id: &str, var: Option<&str>) -> String {
let key = shell_word(&format!(
"providers.{}.api_key",
crate::config::toml_key(id)
));
let set = format!("run `llmman config set {key} <key>`");
match var {
Some(var) => format!("set {var} in the environment, or {set}"),
None => set,
}
}
fn shell_word(word: &str) -> String {
let plain = !word.is_empty()
&& word
.chars()
.all(|c| c.is_ascii_alphanumeric() || "_-.".contains(c));
if plain {
word.to_string()
} else {
format!("'{}'", word.replace('\'', r"'\''"))
}
}
pub fn provider_flag(value: Option<&str>) -> anyhow::Result<Option<&str>> {
match value.map(str::trim) {
Some("") => anyhow::bail!(
"--provider needs a provider id — run 'llmman providers' for the ones llmman \
can route to"
),
other => Ok(other),
}
}
pub fn example_models(name: &str, ids: &[&str]) -> String {
if ids.is_empty() {
return format!("{name} lists no models");
}
let shown: Vec<&str> = ids.iter().take(5).copied().collect();
let more = ids.len().saturating_sub(shown.len());
let suffix = if more > 0 {
format!(", … ({more} more)")
} else {
String::new()
};
format!("{name} models include: {}{suffix}", shown.join(", "))
}
pub fn unknown_provider_error(provider: &str, catalog: &Catalog) -> anyhow::Error {
let close = suggestions(provider, catalog);
if close.is_empty() {
anyhow::anyhow!(
"unknown provider {provider:?}\nRun 'llmman providers' for the {} providers \
llmman can route to.",
catalog.len()
)
} else {
anyhow::anyhow!(
"unknown provider {provider:?}\nDid you mean: {}?\nRun 'llmman providers' for \
all {} of them.",
close.join(", "),
catalog.len()
)
}
}
fn suggestions<'a>(provider: &str, catalog: &'a Catalog) -> Vec<&'a str> {
let needle = provider.to_lowercase();
if needle.len() > MAX_SUGGESTION_LEN {
return Vec::new();
}
let close: Vec<&str> = catalog
.ids()
.filter(|id| id.contains(&needle) || needle.contains(*id))
.take(10)
.collect();
if !close.is_empty() {
return close;
}
let mut ranked: Vec<(usize, &str)> = catalog
.ids()
.map(|id| (edit_distance(&needle, id), id))
.filter(|(d, id)| d * 3 <= needle.len().max(id.len()))
.collect();
ranked.sort_unstable();
ranked.into_iter().take(5).map(|(_, id)| id).collect()
}
const MAX_SUGGESTION_LEN: usize = 64;
fn edit_distance(a: &str, b: &str) -> usize {
let b: Vec<char> = b.chars().collect();
let mut prev: Vec<usize> = (0..=b.len()).collect();
let mut cur = vec![0; b.len() + 1];
for (i, ca) in a.chars().enumerate() {
cur[0] = i + 1;
for (j, cb) in b.iter().enumerate() {
cur[j + 1] = (prev[j] + usize::from(ca != *cb))
.min(prev[j + 1] + 1)
.min(cur[j] + 1);
}
std::mem::swap(&mut prev, &mut cur);
}
prev[b.len()]
}
pub fn rebase_url(base_url: &str, route: &str) -> String {
let suffix = route.trim_start_matches('/');
let suffix = suffix.strip_prefix("v1/").unwrap_or(suffix);
format!("{base_url}/{suffix}")
}
#[derive(Debug, Default)]
pub struct Catalog {
providers: BTreeMap<String, Provider>,
}
impl Catalog {
pub fn get(&self, id: &str) -> Option<&Provider> {
self.providers.get(id)
}
pub fn lacks_model(&self, provider: &str, model: &str) -> bool {
self.get(provider)
.is_some_and(|p| !p.key_optional && !p.models.iter().any(|m| m.id == model))
}
pub fn iter(&self) -> impl Iterator<Item = &Provider> {
self.providers.values()
}
pub fn ids(&self) -> impl Iterator<Item = &str> {
self.providers.keys().map(String::as_str)
}
pub fn len(&self) -> usize {
self.providers.len()
}
pub fn is_empty(&self) -> bool {
self.providers.is_empty()
}
pub fn from_json(raw: &[u8]) -> anyhow::Result<Self> {
let raw: BTreeMap<String, serde_json::Value> =
serde_json::from_slice(raw).context("parse models.dev api.json")?;
let providers: BTreeMap<_, _> = raw
.into_iter()
.filter_map(|(id, provider)| {
let provider = serde_json::from_value(provider).ok()?;
Some((id.clone(), routable(&id, provider)?))
})
.collect();
anyhow::ensure!(
!providers.is_empty(),
"models.dev returned no provider llmman can route to"
);
Ok(Self { providers })
}
pub fn from_configured(configured: &[crate::config::ConfiguredProvider]) -> Self {
Self::default().with_configured(configured)
}
pub fn with_configured(mut self, configured: &[crate::config::ConfiguredProvider]) -> Self {
for conf in configured {
let provider = Provider::from_configured(conf);
if provider.base_url.starts_with("http://") && provider.api_key().is_some() {
eprintln!(
"[llmman] warning: provider {} has an API key and a plain-http base_url \
({}); the key will cross the network in cleartext",
provider.id, provider.base_url
);
}
if self
.providers
.insert(provider.id.clone(), provider)
.is_some()
{
crate::debug_log!(
"provider catalog: {} from llmman.conf shadows the models.dev entry",
conf.id
);
}
}
self
}
}
#[derive(Debug, Deserialize)]
struct RawProvider {
#[serde(default)]
name: String,
#[serde(default)]
api: Option<String>,
#[serde(default)]
npm: Option<String>,
#[serde(default)]
env: Vec<String>,
#[serde(default)]
models: BTreeMap<String, RawModel>,
}
#[derive(Debug, Deserialize)]
struct RawModel {
#[serde(default)]
cost: Option<serde_json::Value>,
#[serde(default)]
limit: Option<serde_json::Value>,
#[serde(default)]
reasoning: Option<serde_json::Value>,
#[serde(default)]
reasoning_options: Option<serde_json::Value>,
}
fn max_output_of(raw: &serde_json::Value) -> Option<u32> {
let n = raw.get("output")?.as_u64()?;
u32::try_from(n).ok().filter(|&n| n > 0)
}
fn max_context_of(raw: &serde_json::Value) -> Option<u64> {
raw.get("context")?.as_u64().filter(|&n| n > 0)
}
fn thinking_levels_of(raw: &RawModel, wire: Wire, max_output: Option<u32>) -> Option<Vec<String>> {
let options = raw
.reasoning_options
.as_ref()
.and_then(serde_json::Value::as_array);
let of_type = |kind: &str| options?.iter().find(|o| o["type"] == kind);
if options.is_some_and(Vec::is_empty) {
return Some(Vec::new());
}
if let Some(effort) = of_type("effort") {
let mut levels: Vec<String> = Vec::new();
for value in effort["values"].as_array().into_iter().flatten() {
let level = match value {
serde_json::Value::Null => "none",
serde_json::Value::String(s) => s.trim(),
_ => continue,
};
if !level.is_empty() && !levels.iter().any(|l| l == level) {
levels.push(level.to_string());
}
}
return Some(levels);
}
if wire == Wire::Anthropic
&& of_type("budget_tokens").is_some()
&& max_output.is_some_and(|n| n > 1)
{
return Some(vec!["high".to_string(), "max".to_string()]);
}
(raw.reasoning.as_ref().and_then(serde_json::Value::as_bool) == Some(false)).then(Vec::new)
}
fn cost_of(raw: &serde_json::Value) -> Option<Cost> {
let tier = |above: u64, raw: &serde_json::Value| {
Some(Tier {
above,
price: flat_cost_of(raw)?,
})
};
let mut tiers: Vec<Tier> = raw
.get("tiers")
.and_then(serde_json::Value::as_array)
.into_iter()
.flatten()
.filter(|t| t["tier"]["type"] == "context")
.filter_map(|t| tier(t["tier"]["size"].as_u64()?, t))
.collect();
if tiers.is_empty() {
tiers.extend(raw.get("context_over_200k").and_then(|t| tier(200_000, t)));
}
tiers.sort_by_key(|t| t.above);
tiers.dedup_by_key(|t| t.above);
Some(Cost {
tiers,
..flat_cost_of(raw)?
})
}
fn flat_cost_of(raw: &serde_json::Value) -> Option<Cost> {
let field = |name: &str| -> Option<f64> {
raw.get(name)?
.as_f64()
.filter(|v| v.is_finite() && *v >= 0.0)
};
Some(Cost {
cache_read: field("cache_read"),
cache_write: field("cache_write"),
reasoning: field("reasoning"),
..Cost::flat(field("input")?, field("output")?)
})
}
const OAUTH_ONLY: &[&str] = &["github-copilot"];
fn routable(id: &str, raw: RawProvider) -> Option<Provider> {
if OAUTH_ONLY.contains(&id) {
return None;
}
let builtin = BUILTIN_ENDPOINTS.iter().find(|b| b.id == id);
let base_url = match raw.api.as_deref().map(str::trim) {
Some(api) if api.starts_with("https://") && !api.contains("${") => api,
_ => builtin?.base_url,
};
let wire = match (builtin, raw.npm.as_deref()) {
(Some(b), _) => b.wire,
(None, Some(npm)) if OPENAI_COMPATIBLE_NPM.contains(&npm) => Wire::OpenAi,
_ => return None,
};
let key_env = match builtin {
Some(b) => b.key_env.to_string(),
None => match raw.env.as_slice() {
[only] if !only.trim().is_empty() => only.trim().to_string(),
_ => return None,
},
};
Some(Provider {
id: id.to_string(),
name: raw.name,
base_url: base_url_of(base_url),
key_env: Some(key_env),
wire,
key_optional: false,
models: raw
.models
.into_iter()
.map(|(id, model)| {
let max_output = model.limit.as_ref().and_then(max_output_of);
Model {
cost: model.cost.as_ref().and_then(cost_of),
thinking: thinking_levels_of(&model, wire, max_output),
max_context: model.limit.as_ref().and_then(max_context_of),
max_output,
id,
}
})
.collect(),
})
}
fn base_url_of(api: &str) -> String {
let api = api.trim_end_matches('/');
api.strip_suffix("/chat/completions")
.or_else(|| api.strip_suffix("/messages"))
.unwrap_or(api)
.trim_end_matches('/')
.to_string()
}
const RETRY_COOLDOWN: Duration = Duration::from_secs(60);
const MISS_REFRESH_COOLDOWN: Duration = Duration::from_secs(5 * 60);
static GATE: Gate = Gate::new(MISS_REFRESH_COOLDOWN);
struct Gate {
cooldown: Duration,
turn: Mutex<()>,
last: Mutex<Option<Instant>>,
}
impl Gate {
const fn new(cooldown: Duration) -> Self {
Self {
cooldown,
turn: Mutex::new(()),
last: Mutex::new(None),
}
}
fn record(&self) {
*self.last.lock().unwrap_or_else(|e| e.into_inner()) = Some(Instant::now());
}
fn last(&self) -> Option<Instant> {
*self.last.lock().unwrap_or_else(|e| e.into_inner())
}
fn background(&self, load: impl FnOnce()) {
self.background_since(Instant::now(), load);
}
fn background_since(&self, queued: Instant, load: impl FnOnce()) {
let _turn = self.turn.lock().unwrap_or_else(|e| e.into_inner());
if self.last().is_none_or(|at| at < queued) {
load();
}
}
fn listing(
&self,
provider: &str,
model: &str,
held: impl Fn() -> anyhow::Result<Arc<Catalog>>,
fetch: impl FnOnce() -> anyhow::Result<Arc<Catalog>>,
) -> anyhow::Result<Arc<Catalog>> {
let current = held()?;
if !current.lacks_model(provider, model) {
return Ok(current);
}
let _turn = self.turn.lock().unwrap_or_else(|e| e.into_inner());
let current = held()?;
let cooling = self.last().is_some_and(|at| at.elapsed() < self.cooldown);
if !current.lacks_model(provider, model) || cooling {
return Ok(current);
}
fetch().or_else(|e| {
eprintln!("[llmman] could not refresh the provider list ({e:#})");
Ok(current)
})
}
}
type Cached = (Instant, Duration, Result<Arc<Catalog>, String>);
static CATALOG: Mutex<Option<Cached>> = Mutex::new(None);
#[cfg(test)]
pub(crate) fn hold_catalog_for_tests(json: &str) {
let catalog = Catalog::from_json(json.as_bytes()).expect("test catalog parses");
*CATALOG.lock().unwrap_or_else(|e| e.into_inner()) = Some((
Instant::now(),
Duration::from_secs(3600),
Ok(Arc::new(catalog)),
));
}
static REFRESHING: AtomicBool = AtomicBool::new(false);
pub fn catalog() -> anyhow::Result<Arc<Catalog>> {
let mut cached = CATALOG.lock().unwrap_or_else(|e| e.into_inner());
match cached.as_ref() {
Some((at, good_for, result)) if at.elapsed() < *good_for => result_of(result),
Some((_, _, Ok(stale))) => {
let stale = stale.clone();
if !REFRESHING.swap(true, Ordering::AcqRel) {
std::thread::spawn(|| {
struct Done;
impl Drop for Done {
fn drop(&mut self) {
REFRESHING.store(false, Ordering::Release);
}
}
let _done = Done;
GATE.background(|| {
let entry = load_entry();
*CATALOG.lock().unwrap_or_else(|e| e.into_inner()) = Some(entry);
});
});
}
Ok(stale)
}
_ => {
let entry = load_entry();
let result = result_of(&entry.2);
*cached = Some(entry);
result
}
}
}
pub fn catalog_listing(provider: &str, model: &str) -> anyhow::Result<Arc<Catalog>> {
GATE.listing(provider, model, catalog, || {
let fresh = entry(Instant::now(), refresh(cache_path().as_deref())?, CACHE_TTL);
let result = result_of(&fresh.2);
*CATALOG.lock().unwrap_or_else(|e| e.into_inner()) = Some(fresh);
result
})
}
fn result_of(result: &Result<Arc<Catalog>, String>) -> anyhow::Result<Arc<Catalog>> {
result.clone().map_err(anyhow::Error::msg)
}
fn load_entry() -> Cached {
let configured = crate::config::configured_providers();
let now = Instant::now();
match load() {
Ok(loaded) => {
let good_for = loaded.good_for();
entry(now, loaded.into_catalog(), good_for)
}
Err(e) if !configured.is_empty() => {
eprintln!(
"[llmman] using only the {} provider(s) defined in llmman.conf ({e:#})",
configured.len()
);
(
now,
RETRY_COOLDOWN,
Ok(Arc::new(Catalog::from_configured(configured))),
)
}
Err(e) => (now, RETRY_COOLDOWN, Err(format!("{e:#}"))),
}
}
fn entry(at: Instant, catalog: Catalog, good_for: Duration) -> Cached {
let configured = crate::config::configured_providers();
(
at,
good_for,
Ok(Arc::new(catalog.with_configured(configured))),
)
}
fn cache_path() -> Option<PathBuf> {
crate::default_cache().ok().map(|d| d.join(CACHE_FILE))
}
fn is_fresh(path: &std::path::Path) -> bool {
std::fs::metadata(path)
.and_then(|m| m.modified())
.ok()
.and_then(|m| SystemTime::now().duration_since(m).ok())
.is_some_and(|age| age < CACHE_TTL)
}
enum Loaded {
Fresh(Catalog),
Stale(Catalog),
}
impl Loaded {
fn good_for(&self) -> Duration {
match self {
Self::Fresh(_) => CACHE_TTL,
Self::Stale(_) => RETRY_COOLDOWN,
}
}
fn into_catalog(self) -> Catalog {
match self {
Self::Fresh(c) | Self::Stale(c) => c,
}
}
}
fn load() -> anyhow::Result<Loaded> {
let path = cache_path();
if let Some(path) = path.as_deref().filter(|p| is_fresh(p)) {
if let Ok(raw) = std::fs::read(path) {
if let Ok(catalog) = Catalog::from_json(&raw) {
crate::debug_log!("provider catalog: {} cached", path.display());
return Ok(Loaded::Fresh(catalog));
}
}
}
match refresh(path.as_deref()) {
Ok(catalog) => Ok(Loaded::Fresh(catalog)),
Err(err) => {
let stale = path
.as_deref()
.and_then(|p| std::fs::read(p).ok())
.and_then(|raw| Catalog::from_json(&raw).ok());
match stale {
Some(catalog) => {
eprintln!("[llmman] using cached provider list ({err:#})");
Ok(Loaded::Stale(catalog))
}
None => Err(err.context(format!(
"could not fetch the provider list from {CATALOG_URL}, and no cached \
copy is available"
))),
}
}
}
}
fn refresh(path: Option<&std::path::Path>) -> anyhow::Result<Catalog> {
crate::debug_log!("provider catalog: fetching {CATALOG_URL}");
let fetched = fetch(CATALOG_URL);
GATE.record();
let raw = fetched?;
let catalog = Catalog::from_json(&raw)?;
if let Some(path) = path {
let _ = write_cache(path, &raw);
}
Ok(catalog)
}
fn write_cache(path: &std::path::Path, raw: &[u8]) -> std::io::Result<()> {
if let Some(dir) = path.parent() {
std::fs::create_dir_all(dir)?;
}
crate::fsutil::write_atomic(path, raw)
}
fn fetch(url: &str) -> anyhow::Result<Vec<u8>> {
let resp = reqwest::blocking::Client::builder()
.timeout(FETCH_TIMEOUT)
.build()
.context("build HTTP client")?
.get(url)
.send()
.with_context(|| format!("GET {url}"))?;
let status = resp.status();
anyhow::ensure!(status.is_success(), "GET {url} returned {status}");
Ok(resp.bytes().context("read models.dev response")?.to_vec())
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn builtin_endpoints_are_well_formed_and_unique() {
let mut seen = std::collections::BTreeSet::new();
for b in BUILTIN_ENDPOINTS {
assert!(seen.insert(b.id), "duplicate builtin {}", b.id);
assert!(
b.base_url.starts_with("https://"),
"{} base_url is not https",
b.id
);
assert!(
!b.base_url.ends_with('/'),
"{} base_url has a trailing slash",
b.id
);
assert!(!b.key_env.is_empty(), "{} has no key_env", b.id);
}
}
#[test]
fn format_and_split_remote_ref_round_trip() {
let reference = format_remote_ref("openrouter", "qwen/qwen3-coder");
assert_eq!(reference, "llmman.provider/openrouter/qwen/qwen3-coder");
assert_eq!(
split_remote_ref(&reference),
Some(("openrouter", "qwen/qwen3-coder"))
);
assert_eq!(
split_remote_ref("llmman.provider/groq/llama-3.3-70b"),
Some(("groq", "llama-3.3-70b"))
);
}
#[test]
fn split_remote_ref_ignores_local_and_huggingface_references() {
for local in [
"google/gemma-3",
"openai/gpt-oss-120b",
"qwen3.5:0.8b",
"docker.io/ai/gemma4",
"hf.co/unsloth/Qwen3.5-0.8B-GGUF",
"",
] {
assert_eq!(split_remote_ref(local), None, "{local} routed as remote");
assert!(!is_remote_ref(local));
}
}
#[test]
fn split_remote_ref_rejects_incomplete_references() {
assert_eq!(split_remote_ref("llmman.provider/"), None);
assert_eq!(split_remote_ref("llmman.provider/openrouter"), None);
assert_eq!(split_remote_ref("llmman.provider/openrouter/"), None);
assert_eq!(split_remote_ref("llmman.provider//gpt-5"), None);
}
fn catalog_from(json: &str) -> Catalog {
Catalog::from_json(json.as_bytes()).expect("fixture parses")
}
fn anthropic_with(models: &[&str]) -> Catalog {
let models: Vec<String> = models.iter().map(|m| format!("{m:?}: {{}}")).collect();
catalog_from(&format!(
r#"{{"anthropic": {{
"id": "anthropic", "name": "Anthropic",
"npm": "@ai-sdk/anthropic", "env": ["ANTHROPIC_API_KEY"],
"models": {{ {} }}
}}}}"#,
models.join(", ")
))
}
#[test]
fn only_a_catalog_entry_missing_the_model_lacks_it() {
let catalog = anthropic_with(&["claude-sonnet-5"]);
assert!(!catalog.lacks_model("anthropic", "claude-sonnet-5"));
assert!(catalog.lacks_model("anthropic", "claude-sonnet-5-5"));
assert!(!catalog.lacks_model("nope", "claude-sonnet-5-5"));
let configured = Catalog::from_configured(&[configured(
"inferencebox",
"http://10.0.0.5:8000/v1",
Wire::OpenAi,
)]);
assert!(!configured.lacks_model("inferencebox", "anything"));
}
struct Fake {
gate: Gate,
held: std::cell::RefCell<Arc<Catalog>>,
fetches: std::cell::Cell<u32>,
}
impl Fake {
fn new(cooldown: Duration, models: &[&str]) -> Self {
Self {
gate: Gate::new(cooldown),
held: std::cell::RefCell::new(Arc::new(anthropic_with(models))),
fetches: std::cell::Cell::new(0),
}
}
fn listing(&self, model: &str, upstream: Option<&[&str]>) -> Arc<Catalog> {
self.gate
.listing(
"anthropic",
model,
|| Ok(self.held.borrow().clone()),
|| {
self.fetches.set(self.fetches.get() + 1);
self.gate.record();
let models = upstream.ok_or_else(|| anyhow::anyhow!("offline"))?;
let fresh = Arc::new(anthropic_with(models));
*self.held.borrow_mut() = fresh.clone();
Ok(fresh)
},
)
.unwrap()
}
}
const OLD: &[&str] = &["claude-sonnet-5"];
const NEW: &[&str] = &["claude-sonnet-5", "claude-sonnet-5-5"];
#[test]
fn a_model_newer_than_the_snapshot_is_found_by_fetching() {
let fake = Fake::new(Duration::from_secs(60), OLD);
let got = fake.listing("claude-sonnet-5-5", Some(NEW));
assert!(!got.lacks_model("anthropic", "claude-sonnet-5-5"));
assert!(!fake
.held
.borrow()
.lacks_model("anthropic", "claude-sonnet-5-5"));
assert_eq!(fake.fetches.get(), 1);
}
#[test]
fn a_listed_model_does_not_fetch() {
let fake = Fake::new(Duration::from_secs(60), OLD);
fake.listing("claude-sonnet-5", Some(&[]));
assert_eq!(fake.fetches.get(), 0);
}
#[test]
fn a_persistent_miss_fetches_once_per_cooldown() {
let fake = Fake::new(Duration::from_secs(3600), OLD);
for _ in 0..3 {
assert!(fake
.listing("typo", Some(OLD))
.lacks_model("anthropic", "typo"));
}
assert_eq!(fake.fetches.get(), 1);
let fake = Fake::new(Duration::ZERO, OLD);
fake.listing("typo", Some(OLD));
fake.listing("typo", Some(OLD));
assert_eq!(fake.fetches.get(), 2);
}
#[test]
fn a_failed_fetch_keeps_the_held_catalog() {
let fake = Fake::new(Duration::from_secs(3600), OLD);
for _ in 0..2 {
let got = fake.listing("claude-sonnet-5-5", None);
assert!(got.lacks_model("anthropic", "claude-sonnet-5-5"));
assert!(!got.lacks_model("anthropic", "claude-sonnet-5"));
}
assert_eq!(fake.fetches.get(), 1);
}
#[test]
fn an_unknown_provider_does_not_fetch() {
let gate = Gate::new(Duration::ZERO);
let held = Arc::new(anthropic_with(OLD));
gate.listing("nope", "x", || Ok(held.clone()), || panic!("fetched"))
.unwrap();
}
#[test]
fn a_queued_background_refresh_yields_to_a_download_that_ran() {
let gate = Gate::new(Duration::ZERO);
let ran = std::cell::Cell::new(0);
let run = || ran.set(ran.get() + 1);
gate.background_since(Instant::now(), run);
assert_eq!(ran.get(), 1);
let queued = Instant::now();
gate.record();
gate.background_since(queued, run);
assert_eq!(ran.get(), 1, "queued before the download that ran");
gate.background_since(Instant::now() + Duration::from_secs(1), run);
assert_eq!(ran.get(), 2, "queued after it");
}
#[test]
fn openai_compatible_providers_come_from_the_catalog() {
let catalog = catalog_from(
r#"{
"openrouter": {
"id": "openrouter",
"name": "OpenRouter",
"api": "https://openrouter.ai/api/v1",
"npm": "@openrouter/ai-sdk-provider",
"env": ["OPENROUTER_API_KEY"],
"models": {
"z-model": { "cost": { "input": 2.5, "output": 10 }, "limit": { "context": 200000, "output": 32000 } },
"a-model": {}
}
}
}"#,
);
let p = catalog.get("openrouter").expect("openrouter is routable");
assert_eq!(p.name, "OpenRouter");
assert_eq!(p.base_url, "https://openrouter.ai/api/v1");
assert_eq!(p.key_env.as_deref(), Some("OPENROUTER_API_KEY"));
assert_eq!(p.wire, Wire::OpenAi);
assert_eq!(
p.models,
vec![
Model {
id: "a-model".into(),
cost: None,
max_output: None,
max_context: None,
thinking: None,
},
Model {
id: "z-model".into(),
cost: Some(Cost::flat(2.5, 10.0)),
max_output: Some(32000),
max_context: Some(200_000),
thinking: None,
},
]
);
}
#[test]
fn thinking_levels_follow_the_catalogs_reasoning_options() {
let catalog = catalog_from(
r#"{
"anthropic": {
"id": "anthropic", "name": "Anthropic",
"npm": "@ai-sdk/anthropic", "env": ["ANTHROPIC_API_KEY"],
"models": {
"claude-opus-5-5": { "reasoning": true, "limit": { "output": 128000 },
"reasoning_options": [{ "type": "effort", "values": ["low", "medium", "high", "xhigh", "max"] }] },
"claude-sonnet-5": { "reasoning": true, "limit": { "output": 128000 },
"reasoning_options": [{ "type": "toggle" }, { "type": "effort", "values": ["low", "high"] }] },
"claude-haiku-4-5": { "reasoning": true, "limit": { "output": 64000 },
"reasoning_options": [{ "type": "budget_tokens", "min": 1024 }] },
"claude-no-ceiling": { "reasoning": true,
"reasoning_options": [{ "type": "budget_tokens", "min": 1024 }] },
"claude-3-haiku": { "reasoning": false, "limit": { "output": 4096 } }
}
},
"cheap": {
"id": "cheap", "name": "Cheap", "api": "https://cheap.example/v1",
"npm": "@ai-sdk/openai-compatible", "env": ["CHEAP_API_KEY"],
"models": {
"gpt-x": { "reasoning": true,
"reasoning_options": [{ "type": "effort", "values": [null, "low", "low", 3, "", "xhigh"] }] },
"qwen-budget": { "reasoning": true, "limit": { "output": 32000 },
"reasoning_options": [{ "type": "toggle" }, { "type": "budget_tokens", "max": 32768 }] },
"no-reasoning": { "reasoning": false,
"reasoning_options": [{ "type": "toggle" }] },
"switch-off": { "reasoning": true, "reasoning_options": [] },
"unsaid": { "reasoning": true },
"odd": { "reasoning": "yes", "reasoning_options": { "type": "effort" } }
}
}
}"#,
);
let levels = |provider: &str, model: &str| {
catalog
.get(provider)
.and_then(|p| p.models.iter().find(|m| m.id == model))
.unwrap_or_else(|| panic!("{provider}/{model}"))
.thinking
.clone()
};
let some = |levels: &[&str]| Some(levels.iter().map(|l| l.to_string()).collect());
assert_eq!(
levels("anthropic", "claude-opus-5-5"),
some(&["low", "medium", "high", "xhigh", "max"])
);
assert_eq!(
levels("anthropic", "claude-sonnet-5"),
some(&["low", "high"])
);
assert_eq!(
levels("anthropic", "claude-haiku-4-5"),
some(&["high", "max"])
);
assert_eq!(levels("anthropic", "claude-no-ceiling"), None);
assert_eq!(levels("anthropic", "claude-3-haiku"), some(&[]));
assert_eq!(levels("cheap", "gpt-x"), some(&["none", "low", "xhigh"]));
assert_eq!(levels("cheap", "qwen-budget"), None);
assert_eq!(levels("cheap", "no-reasoning"), some(&[]));
assert_eq!(levels("cheap", "switch-off"), some(&[]));
assert_eq!(levels("cheap", "unsaid"), None);
assert_eq!(levels("cheap", "odd"), None);
}
#[test]
fn builtins_supply_endpoints_the_catalog_omits() {
let catalog = catalog_from(
r#"{
"anthropic": {
"id": "anthropic", "name": "Anthropic",
"npm": "@ai-sdk/anthropic", "env": ["ANTHROPIC_API_KEY"],
"models": { "claude-sonnet-4": {} }
},
"google": {
"id": "google", "name": "Google",
"npm": "@ai-sdk/google",
"env": ["GOOGLE_API_KEY", "GOOGLE_GENERATIVE_AI_API_KEY", "GEMINI_API_KEY"],
"models": { "gemini-2.5-pro": {} }
}
}"#,
);
let anthropic = catalog.get("anthropic").expect("anthropic is routable");
assert_eq!(anthropic.base_url, "https://api.anthropic.com/v1");
assert_eq!(anthropic.key_env.as_deref(), Some("ANTHROPIC_API_KEY"));
assert_eq!(anthropic.wire, Wire::Anthropic);
let google = catalog.get("google").expect("google is routable");
assert_eq!(google.key_env.as_deref(), Some("GEMINI_API_KEY"));
assert_eq!(google.wire, Wire::OpenAi);
}
#[test]
fn a_messages_route_is_trimmed_to_its_base() {
assert_eq!(
base_url_of("https://api.anthropic.com/v1/messages/"),
"https://api.anthropic.com/v1"
);
}
#[test]
fn a_concrete_api_overrides_the_builtin_endpoint() {
let catalog = catalog_from(
r#"{
"openai": {
"id": "openai", "name": "OpenAI",
"api": "https://api.openai.example/v2/",
"npm": "@ai-sdk/openai", "env": ["OPENAI_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
);
let p = catalog.get("openai").expect("openai is routable");
assert_eq!(p.base_url, "https://api.openai.example/v2");
}
#[test]
fn unreachable_providers_are_dropped() {
let catalog = catalog_from(
r#"{
"minimax": {
"id": "minimax", "name": "MiniMax",
"api": "https://api.minimax.io/anthropic/v1",
"npm": "@ai-sdk/anthropic", "env": ["MINIMAX_API_KEY"],
"models": { "minimax-m2": {} }
},
"amazon-bedrock": {
"id": "amazon-bedrock", "name": "Amazon Bedrock",
"npm": "@ai-sdk/amazon-bedrock",
"env": ["AWS_ACCESS_KEY_ID", "AWS_SECRET_ACCESS_KEY"],
"models": { "claude": {} }
},
"snowflake-cortex": {
"id": "snowflake-cortex", "name": "Snowflake Cortex",
"api": "https://${SNOWFLAKE_ACCOUNT}.snowflakecomputing.com/api/v2/cortex/v1",
"npm": "@ai-sdk/openai-compatible",
"env": ["SNOWFLAKE_ACCOUNT", "SNOWFLAKE_CORTEX_PAT"],
"models": { "claude": {} }
},
"cloudflare-workers-ai": {
"id": "cloudflare-workers-ai", "name": "Cloudflare Workers AI",
"api": "https://api.cloudflare.com/client/v4/accounts/${CLOUDFLARE_ACCOUNT_ID}/ai/v1",
"npm": "@ai-sdk/openai-compatible",
"env": ["CLOUDFLARE_ACCOUNT_ID", "CLOUDFLARE_API_KEY"],
"models": { "llama": {} }
},
"github-copilot": {
"id": "github-copilot", "name": "GitHub Copilot",
"api": "https://api.githubcopilot.com",
"npm": "@ai-sdk/openai-compatible", "env": ["GITHUB_TOKEN"],
"models": { "gpt-5": {} }
},
"openrouter": {
"id": "openrouter", "name": "OpenRouter",
"api": "https://openrouter.ai/api/v1",
"npm": "@openrouter/ai-sdk-provider", "env": ["OPENROUTER_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
);
assert!(catalog.get("minimax").is_none());
assert!(catalog.get("amazon-bedrock").is_none());
assert!(catalog.get("snowflake-cortex").is_none());
assert!(catalog.get("cloudflare-workers-ai").is_none());
assert!(catalog.get("github-copilot").is_none());
assert_eq!(catalog.len(), 1);
assert!(catalog.get("openrouter").is_some());
}
#[test]
fn plaintext_endpoints_are_never_routed_to() {
let catalog = catalog_from(
r#"{
"openai": {
"id": "openai", "name": "OpenAI",
"api": "http://api.openai.example/v1",
"npm": "@ai-sdk/openai", "env": ["OPENAI_API_KEY"],
"models": { "gpt-5": {} }
},
"lmstudio": {
"id": "lmstudio", "name": "LM Studio",
"api": "http://127.0.0.1:1234/v1",
"npm": "@ai-sdk/openai-compatible", "env": ["LMSTUDIO_API_KEY"],
"models": { "some-model": {} }
}
}"#,
);
assert_eq!(
catalog.get("openai").expect("openai is routable").base_url,
"https://api.openai.com/v1"
);
assert!(catalog.get("lmstudio").is_none());
}
const REAL_CATALOG: &[u8] = include_bytes!("../tests/fixtures/models-dev-providers.json");
#[test]
fn the_real_catalog_yields_a_usable_provider_list() {
let catalog = Catalog::from_json(REAL_CATALOG).expect("real catalog parses");
assert!(
(150..207).contains(&catalog.len()),
"{} of 207 routable — the filter moved a lot",
catalog.len()
);
for p in catalog.iter() {
assert!(
p.base_url.starts_with("https://"),
"{}: {}",
p.id,
p.base_url
);
assert!(!p.base_url.ends_with('/'), "{}: {}", p.id, p.base_url);
assert!(!p.base_url.contains("${"), "{}: {}", p.id, p.base_url);
assert!(
p.key_env.as_deref().is_some_and(|v| !v.is_empty()),
"{} has no key variable",
p.id
);
}
for (id, base_url) in [
("openai", "https://api.openai.com/v1"),
("anthropic", "https://api.anthropic.com/v1"),
(
"google",
"https://generativelanguage.googleapis.com/v1beta/openai",
),
("groq", "https://api.groq.com/openai/v1"),
("openrouter", "https://openrouter.ai/api/v1"),
("perplexity", "https://api.perplexity.ai"),
] {
let p = catalog.get(id).unwrap_or_else(|| panic!("{id} is dropped"));
assert_eq!(p.base_url, base_url, "{id}");
}
for id in [
"amazon-bedrock", "google-vertex", "azure", "lmstudio", ] {
assert!(catalog.get(id).is_none(), "{id} is offered");
}
}
#[test]
fn a_route_specific_api_is_normalized_back_to_its_base() {
let catalog = catalog_from(
r#"{
"bailing": {
"id": "bailing", "name": "Bailing",
"api": "https://api.tbox.cn/api/llm/v1/chat/completions",
"npm": "@ai-sdk/openai-compatible", "env": ["BAILING_API_KEY"],
"models": { "ling-1t": {} }
}
}"#,
);
let p = catalog.get("bailing").expect("bailing is routable");
assert_eq!(p.base_url, "https://api.tbox.cn/api/llm/v1");
assert_eq!(
p.url("/v1/chat/completions"),
"https://api.tbox.cn/api/llm/v1/chat/completions"
);
assert_eq!(
base_url_of("https://x.example/v1/chat/completions/"),
"https://x.example/v1"
);
assert_eq!(
base_url_of("https://x.example/completions"),
"https://x.example/completions"
);
}
#[test]
fn no_real_provider_builds_a_doubled_route() {
for p in Catalog::from_json(REAL_CATALOG).unwrap().iter() {
let url = p.url("/v1/chat/completions");
assert_eq!(
url.matches("/chat/completions").count(),
1,
"{}: {url}",
p.id
);
}
}
#[test]
fn a_body_with_nothing_routable_is_an_error_not_an_empty_catalog() {
for body in [
r#"{"error":"temporarily unavailable"}"#,
r#"{"message":"rate limited","retry_after":30}"#,
"{}",
] {
assert!(
Catalog::from_json(body.as_bytes()).is_err(),
"{body} was accepted as a catalog"
);
}
}
#[test]
fn a_stale_catalog_is_held_no_longer_than_a_failure() {
assert_eq!(Loaded::Fresh(Catalog::default()).good_for(), CACHE_TTL);
assert_eq!(Loaded::Stale(Catalog::default()).good_for(), RETRY_COOLDOWN);
assert!(
RETRY_COOLDOWN < CACHE_TTL,
"a failed refresh outlives a good one"
);
}
#[test]
fn every_builtin_is_for_a_provider_the_catalog_leaves_without_an_api() {
let raw: BTreeMap<String, serde_json::Value> =
serde_json::from_slice(REAL_CATALOG).expect("fixture parses");
for b in BUILTIN_ENDPOINTS {
let entry = raw
.get(b.id)
.unwrap_or_else(|| panic!("builtin {} is not in the catalog at all", b.id));
let api = entry.get("api").and_then(|v| v.as_str()).unwrap_or("");
assert!(
!api.starts_with("https://"),
"builtin {} is unused: the catalog already gives it {api}",
b.id
);
let env: Vec<&str> = entry["env"]
.as_array()
.map(|e| e.iter().filter_map(|v| v.as_str()).collect())
.unwrap_or_default();
assert!(
env.contains(&b.key_env),
"builtin {} names {}, which is not one of the catalog's {env:?}",
b.id,
b.key_env
);
}
}
#[test]
fn a_malformed_entry_does_not_reject_the_whole_catalog() {
let catalog = catalog_from(
r#"{
"broken": { "id": "broken", "name": ["not", "a", "string"] },
"openrouter": {
"id": "openrouter", "name": "OpenRouter",
"api": "https://openrouter.ai/api/v1",
"npm": "@openrouter/ai-sdk-provider",
"env": ["OPENROUTER_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
);
assert!(catalog.get("broken").is_none());
assert!(catalog.get("openrouter").is_some());
}
#[test]
fn multi_variable_auth_is_dropped_without_a_builtin() {
let catalog = catalog_from(
r#"{
"databricks": {
"id": "databricks", "name": "Databricks",
"api": "https://example.cloud.databricks.com/ai-gateway/mlflow/v1",
"npm": "@ai-sdk/openai-compatible",
"env": ["DATABRICKS_HOST", "DATABRICKS_TOKEN"],
"models": { "dbrx": {} }
},
"openrouter": {
"id": "openrouter", "name": "OpenRouter",
"api": "https://openrouter.ai/api/v1",
"npm": "@openrouter/ai-sdk-provider", "env": ["OPENROUTER_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
);
assert!(catalog.get("databricks").is_none());
assert!(catalog.get("openrouter").is_some());
}
#[test]
fn url_appends_routes_to_the_published_base() {
let p = Provider {
id: "groq".into(),
name: "Groq".into(),
base_url: "https://api.groq.com/openai/v1".into(),
key_env: Some("GROQ_API_KEY".into()),
key_optional: false,
wire: Wire::OpenAi,
models: vec![],
};
assert_eq!(
p.url("/v1/chat/completions"),
"https://api.groq.com/openai/v1/chat/completions"
);
assert_eq!(
p.url("/v1/embeddings"),
"https://api.groq.com/openai/v1/embeddings"
);
let gemini = Provider {
base_url: "https://generativelanguage.googleapis.com/v1beta/openai".into(),
..p.clone()
};
assert_eq!(
gemini.url("/v1/chat/completions"),
"https://generativelanguage.googleapis.com/v1beta/openai/chat/completions"
);
let perplexity = Provider {
base_url: "https://api.perplexity.ai".into(),
..p
};
assert_eq!(
perplexity.url("/v1/chat/completions"),
"https://api.perplexity.ai/chat/completions"
);
}
#[test]
fn api_key_reads_the_providers_own_variable() {
let p = Provider {
id: "test".into(),
name: "Test".into(),
base_url: "https://example.invalid/v1".into(),
key_env: Some("LLMMAN_TEST_PROVIDER_KEY_UNSET".into()),
key_optional: false,
wire: Wire::OpenAi,
models: vec![],
};
assert_eq!(p.api_key(), None);
}
#[test]
fn the_environment_beats_the_config_file() {
assert_eq!(
resolve_key(Some("from-env".into()), Some("from-conf")),
Some("from-env".to_string())
);
assert_eq!(
resolve_key(None, Some("from-conf")),
Some("from-conf".to_string())
);
assert_eq!(
resolve_key(Some("from-env".into()), None),
Some("from-env".to_string())
);
assert_eq!(resolve_key(None, None), None);
}
#[test]
fn a_config_file_key_is_trimmed_and_a_blank_one_ignored() {
assert_eq!(
resolve_key(None, Some(" padded ")),
Some("padded".to_string())
);
assert_eq!(resolve_key(None, Some(" ")), None);
assert_eq!(resolve_key(None, Some("")), None);
}
#[test]
fn key_hint_names_the_variable_and_the_command() {
assert_eq!(
key_hint("openrouter", Some("OPENROUTER_API_KEY")),
"set OPENROUTER_API_KEY in the environment, or run \
`llmman config set providers.openrouter.api_key <key>`"
);
assert_eq!(
key_hint("inferencebox", None),
"run `llmman config set providers.inferencebox.api_key <key>`"
);
}
fn configured(id: &str, base_url: &str, wire: Wire) -> crate::config::ConfiguredProvider {
crate::config::ConfiguredProvider {
id: id.into(),
name: id.into(),
base_url: base_url.into(),
wire,
key_env: None,
}
}
#[test]
fn configured_providers_join_the_catalog_with_key_optional() {
let catalog = catalog_from(
r#"{
"openrouter": {
"id": "openrouter", "name": "OpenRouter",
"api": "https://openrouter.ai/api/v1",
"npm": "@openrouter/ai-sdk-provider",
"env": ["OPENROUTER_API_KEY"],
"models": { "m": {} }
}
}"#,
)
.with_configured(&[
configured("inferencebox", "http://inferencebox:8000/v1", Wire::OpenAi),
crate::config::ConfiguredProvider {
id: "relay".into(),
name: "Claude relay".into(),
base_url: "https://relay.example/v1".into(),
wire: Wire::Anthropic,
key_env: Some("RELAY_KEY".into()),
},
]);
assert_eq!(catalog.len(), 3);
assert_eq!(
catalog.ids().collect::<Vec<_>>(),
["inferencebox", "openrouter", "relay"]
);
let inferencebox = catalog.get("inferencebox").unwrap();
assert_eq!(inferencebox.base_url, "http://inferencebox:8000/v1");
assert_eq!(inferencebox.wire, Wire::OpenAi);
assert!(inferencebox.key_optional);
assert_eq!(inferencebox.key_env, None);
assert!(inferencebox.models.is_empty());
assert_eq!(inferencebox.api_key(), None);
assert_eq!(
inferencebox.url("/v1/chat/completions"),
"http://inferencebox:8000/v1/chat/completions"
);
let relay = catalog.get("relay").unwrap();
assert_eq!(relay.name, "Claude relay");
assert_eq!(relay.wire, Wire::Anthropic);
assert_eq!(relay.key_env.as_deref(), Some("RELAY_KEY"));
assert!(relay.key_optional);
let openrouter = catalog.get("openrouter").unwrap();
assert!(!openrouter.key_optional);
assert_eq!(openrouter.models.len(), 1);
}
#[test]
fn a_configured_provider_shadows_the_catalog_entry_with_its_id() {
let catalog = catalog_from(
r#"{
"openai": {
"id": "openai", "name": "OpenAI",
"npm": "@ai-sdk/openai", "env": ["OPENAI_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
)
.with_configured(&[configured(
"openai",
"http://proxy.corp:4000/v1",
Wire::OpenAi,
)]);
assert_eq!(catalog.len(), 1);
let p = catalog.get("openai").unwrap();
assert_eq!(p.base_url, "http://proxy.corp:4000/v1");
assert!(p.key_optional);
assert!(
p.models.is_empty(),
"the catalog's models are not the proxy's"
);
}
#[test]
fn configured_providers_stand_alone_without_the_catalog() {
let catalog = Catalog::from_configured(&[configured(
"inferencebox",
"http://inferencebox:8000/v1",
Wire::OpenAi,
)]);
assert_eq!(catalog.len(), 1);
assert!(catalog.get("inferencebox").is_some());
assert!(Catalog::from_configured(&[]).is_empty());
}
#[test]
fn wire_deserializes_from_its_reported_name() {
#[derive(Deserialize)]
struct W {
wire: Wire,
}
let parse = |s: &str| toml::from_str::<W>(&format!("wire = {s:?}")).map(|w| w.wire);
assert_eq!(parse("openai").unwrap(), Wire::OpenAi);
assert_eq!(parse("anthropic").unwrap(), Wire::Anthropic);
assert!(parse("OpenAI").is_err());
assert!(parse("ollama").is_err());
for wire in [Wire::OpenAi, Wire::Anthropic] {
assert_eq!(parse(wire.as_str()).unwrap(), wire);
}
}
#[test]
fn key_hint_quotes_an_id_that_is_not_a_bare_toml_key() {
assert_eq!(
key_hint("wafer.ai", None),
r#"run `llmman config set 'providers."wafer.ai".api_key' <key>`"#
);
assert_eq!(shell_word("it's"), r"'it'\''s'");
assert_eq!(shell_word(""), "''");
for id in ["z-ai", "wafer.ai", "it's", "a\"b"] {
let key = format!("providers.{}.api_key", crate::config::toml_key(id));
let parts = toml_edit::Key::parse(&key).expect("a valid dotted key");
let parts: Vec<&str> = parts.iter().map(toml_edit::Key::get).collect();
assert_eq!(parts, ["providers", id, "api_key"], "{key}");
}
}
#[test]
fn example_models_lists_a_few_and_counts_the_rest() {
assert_eq!(
example_models("Groq", &["a", "b"]),
"Groq models include: a, b"
);
assert_eq!(
example_models("Groq", &["a", "b", "c", "d", "e", "f", "g"]),
"Groq models include: a, b, c, d, e, … (2 more)"
);
assert_eq!(example_models("Groq", &[]), "Groq lists no models");
}
#[test]
fn a_blank_provider_flag_is_an_error_not_an_absent_one() {
assert_eq!(provider_flag(None).unwrap(), None);
assert_eq!(provider_flag(Some(" openai ")).unwrap(), Some("openai"));
assert!(provider_flag(Some("")).is_err());
assert!(provider_flag(Some(" ")).is_err());
}
#[test]
fn cost_of_takes_both_figures_or_neither() {
let cost = |json: &str| cost_of(&serde_json::from_str(json).unwrap());
assert_eq!(
cost(r#"{"input": 2.5, "output": 10}"#),
Some(Cost::flat(2.5, 10.0))
);
assert_eq!(
cost(r#"{"input": 0, "output": 0}"#),
Some(Cost::flat(0.0, 0.0))
);
assert_eq!(cost(r#"{"input": 2.5}"#), None);
assert_eq!(cost(r#"{"cache_read": 1}"#), None);
assert_eq!(cost(r#"{}"#), None);
assert_eq!(cost(r#"{"input": "2.5", "output": "10"}"#), None);
assert_eq!(cost(r#"{"input": -1, "output": 10}"#), None);
assert_eq!(cost(r#"[]"#), None);
}
#[test]
fn cost_of_keeps_the_cache_rates() {
let cost = |json: &str| cost_of(&serde_json::from_str(json).unwrap()).unwrap();
let sonnet = cost(
r#"{"input": 3, "output": 15, "cache_read": 0.3, "cache_write": 3.75, "reasoning": 20}"#,
);
assert_eq!(sonnet.cache_read, Some(0.3));
assert_eq!(sonnet.cache_write, Some(3.75));
assert_eq!(sonnet.reasoning, Some(20.0));
let partial = cost(r#"{"input": 2.5, "output": 10, "cache_read": "0.25"}"#);
assert_eq!(partial, Cost::flat(2.5, 10.0));
}
#[test]
fn cost_of_reads_context_tiers() {
let cost = |json: &str| cost_of(&serde_json::from_str(json).unwrap()).unwrap();
let gpt = cost(
r#"{"input": 2.5, "output": 15, "cache_read": 0.25,
"tiers": [{"input": 5, "output": 22.5, "cache_read": 0.5, "tier": {"type": "context", "size": 272000}}],
"context_over_200k": {"input": 5, "output": 22.5, "cache_read": 0.5}}"#,
);
assert_eq!(
gpt.tiers,
vec![Tier {
above: 272_000,
price: Cost {
cache_read: Some(0.5),
..Cost::flat(5.0, 22.5)
},
}]
);
let legacy = cost(
r#"{"input": 3, "output": 15, "context_over_200k": {"input": 6, "output": 22.5}}"#,
);
assert_eq!(legacy.tiers.len(), 1);
assert_eq!(legacy.tiers[0].above, 200_000);
let many = cost(
r#"{"input": 1, "output": 2, "tiers": [
{"input": 4, "output": 8, "tier": {"type": "context", "size": 128000}},
{"input": 2, "output": 4, "tier": {"type": "context", "size": 32000}},
{"input": 9, "output": 9, "tier": {"type": "context", "size": 32000}},
{"input": 3, "output": 6, "tier": {"type": "time_of_day", "size": 64000}},
{"input": 3, "tier": {"type": "context", "size": 64000}}]}"#,
);
let above: Vec<u64> = many.tiers.iter().map(|t| t.above).collect();
assert_eq!(above, [32_000, 128_000]);
let unusable = cost(
r#"{"input": 3, "output": 15, "tiers": [{"input": 6, "tier": {"type": "context", "size": 1}}],
"context_over_200k": {"input": 6, "output": 22.5}}"#,
);
assert_eq!(unusable.tiers[0].above, 200_000);
}
#[test]
fn an_unrecognized_cost_shape_keeps_the_provider() {
let catalog = catalog_from(
r#"{
"openrouter": {
"id": "openrouter", "name": "OpenRouter",
"api": "https://openrouter.ai/api/v1",
"npm": "@openrouter/ai-sdk-provider", "env": ["OPENROUTER_API_KEY"],
"models": {
"weird": { "cost": "free, actually" },
"fine": { "cost": { "input": 1, "output": 2 } }
}
}
}"#,
);
let p = catalog.get("openrouter").expect("openrouter is routable");
assert_eq!(p.models.len(), 2);
assert_eq!(p.models[0].id, "fine");
assert!(p.models[1].cost.is_none());
}
#[test]
fn unknown_provider_error_suggests_near_matches() {
let catalog = catalog_from(
r#"{
"togetherai": {
"id": "togetherai", "name": "Together",
"api": "https://api.together.xyz/v1",
"npm": "@ai-sdk/openai-compatible", "env": ["TOGETHER_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
);
let short = unknown_provider_error("together", &catalog).to_string();
assert!(short.contains("unknown provider \"together\""), "{short}");
assert!(short.contains("Did you mean: togetherai?"), "{short}");
assert!(short.contains("llmman providers"), "{short}");
let typo = unknown_provider_error("togethr", &catalog).to_string();
assert!(typo.contains("Did you mean: togetherai?"), "{typo}");
let far = unknown_provider_error("nope", &catalog).to_string();
assert!(!far.contains("Did you mean"), "{far}");
assert!(far.contains("llmman providers"), "{far}");
}
#[test]
fn an_absurdly_long_id_is_reported_without_a_suggestion_pass() {
let catalog = catalog_from(
r#"{
"togetherai": {
"id": "togetherai", "name": "Together",
"api": "https://api.together.xyz/v1",
"npm": "@ai-sdk/openai-compatible", "env": ["TOGETHER_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
);
let huge = format!("togetherai{}", "z".repeat(64 * 1024));
let error = unknown_provider_error(&huge, &catalog).to_string();
assert!(!error.contains("Did you mean"), "suggested for a huge id");
assert!(error.contains("llmman providers"));
}
#[test]
fn suggestions_are_skipped_just_above_the_length_limit() {
let catalog = catalog_from(
r#"{
"togetherai": {
"id": "togetherai", "name": "Together",
"api": "https://api.together.xyz/v1",
"npm": "@ai-sdk/openai-compatible", "env": ["TOGETHER_API_KEY"],
"models": { "gpt-5": {} }
}
}"#,
);
let pad = |len: usize| format!("togetherai{}", "z".repeat(len - "togetherai".len()));
assert_eq!(
suggestions(&pad(MAX_SUGGESTION_LEN), &catalog),
vec!["togetherai"],
"an id at exactly the limit was not searched"
);
assert!(
suggestions(&pad(MAX_SUGGESTION_LEN + 1), &catalog).is_empty(),
"one byte over the limit was still searched"
);
}
}