From 4dea9b483efbd2541d43500b8ed3c044c65e6d2f Mon Sep 17 00:00:00 2001 From: Jack Amadeo Date: Mon, 28 Sep 2026 19:46:13 +0000 Subject: [PATCH] feat: fetch model metadata from models.dev live with bundled fallback (#12560) --- Justfile | 2 +- crates/goose-cli/Cargo.toml | 2 + crates/goose-cli/src/main.rs | 3 + crates/goose-provider-types/src/base.rs | 4 +- crates/goose-provider-types/src/canonical.rs | 7 +- .../src/canonical/models_dev.rs | 243 ++++++++++++++++ .../src/canonical/name_builder.rs | 120 ++++---- .../src/canonical/registry.rs | 196 ++++++++++--- crates/goose/Cargo.toml | 1 + .../goose/src/bin/build_canonical_models.rs | 273 +----------------- crates/goose/src/lib.rs | 2 + crates/goose/src/model_catalog.rs | 22 ++ 12 files changed, 505 insertions(+), 370 deletions(-) create mode 100644 crates/goose-provider-types/src/canonical/models_dev.rs create mode 100644 crates/goose/src/model_catalog.rs diff --git a/Justfile b/Justfile index a5dbf3ecd..4b234d6cb 100644 --- a/Justfile +++ b/Justfile @@ -170,7 +170,7 @@ build-lean: cargo build -p goose --bin goose-acp \ --profile lean \ --no-default-features \ - --features native-tls + --features native-tls,online-model-meta # Budgets are per-platform. ELF carries several MiB that Mach-O does not for the # same code: DWARF .eh_frame instead of compact unwind info, and a .rela.dyn diff --git a/crates/goose-cli/Cargo.toml b/crates/goose-cli/Cargo.toml index 7dee0f1b9..892bff33f 100644 --- a/crates/goose-cli/Cargo.toml +++ b/crates/goose-cli/Cargo.toml @@ -109,7 +109,9 @@ default = [ "platform-apps", "chat-recall", "acp-http", + "online-model-meta", ] +online-model-meta = ["goose/online-model-meta"] roaming = ["dep:goose-roaming", "dep:qrcode", "dep:fs2", "dep:agent-client-protocol"] code-mode = ["goose/code-mode"] tree-sitter = ["goose/tree-sitter"] diff --git a/crates/goose-cli/src/main.rs b/crates/goose-cli/src/main.rs index b5b3c19d5..63ccf64f2 100644 --- a/crates/goose-cli/src/main.rs +++ b/crates/goose-cli/src/main.rs @@ -21,6 +21,9 @@ async fn run() -> Result<()> { eprintln!("Warning: Failed to initialize logging: {}", e); } + #[cfg(feature = "online-model-meta")] + goose::model_catalog::initialize(); + let result = cli().await; #[cfg(feature = "otel")] diff --git a/crates/goose-provider-types/src/base.rs b/crates/goose-provider-types/src/base.rs index 1c737332b..d73ed8b9b 100644 --- a/crates/goose-provider-types/src/base.rs +++ b/crates/goose-provider-types/src/base.rs @@ -583,7 +583,7 @@ pub trait Provider: Send + Sync { let mut models_with_dates: Vec<(String, Option)> = all_models .iter() .filter_map(|model| { - let canonical_model = map_to_canonical_model(provider_name, model, registry) + let canonical_model = map_to_canonical_model(provider_name, model, ®istry) .and_then(|canonical_id| { let (provider, model_name) = canonical_id.split_once('/')?; registry.get(provider, model_name) @@ -653,7 +653,7 @@ pub trait Provider: Send + Sync { Ok(map_to_canonical_model( self.get_name(), provider_model, - registry, + ®istry, )) } diff --git a/crates/goose-provider-types/src/canonical.rs b/crates/goose-provider-types/src/canonical.rs index 21c50df4d..a2c69e539 100644 --- a/crates/goose-provider-types/src/canonical.rs +++ b/crates/goose-provider-types/src/canonical.rs @@ -1,5 +1,6 @@ pub mod catalog; mod model; +pub mod models_dev; mod name_builder; mod registry; @@ -7,7 +8,7 @@ pub use model::{CanonicalModel, Limit, Modalities, Modality, Pricing, ThinkingMo pub use name_builder::{ canonical_name, map_provider_name, map_to_canonical_model, strip_version_suffix, }; -pub use registry::CanonicalModelRegistry; +pub use registry::{load_cached_catalog, refresh_remote_catalog, CanonicalModelRegistry}; #[derive(Debug, Clone, serde::Serialize, serde::Deserialize)] pub struct ModelMapping { @@ -166,7 +167,7 @@ fn should_clear_catalog_pricing(provider: &str) -> bool { pub fn maybe_get_canonical_model(provider: &str, model: &str) -> Option { let registry = CanonicalModelRegistry::bundled().ok()?; - let canonical_id = map_to_canonical_model(provider, model, registry)?; + let canonical_id = map_to_canonical_model(provider, model, ®istry)?; let mut canonical = if let Some((canon_provider, canon_model)) = canonical_id.split_once('/') { registry.get(canon_provider, canon_model).cloned()? } else { @@ -181,7 +182,7 @@ pub fn maybe_get_canonical_model(provider: &str, model: &str) -> Option &str { + match provider { + "llama" => "meta-llama", + "xai" => "x-ai", + "mistral" => "mistralai", + _ => provider, + } +} + +fn get_string(value: &Value, field: &str) -> Option { + value.get(field).and_then(|v| v.as_str()).map(String::from) +} + +fn get_thinking_mode(canonical_id: &str, value: &Value) -> Option { + value + .get("thinking_mode") + .and_then(|v| v.as_str()) + .and_then(|mode| serde_json::from_value(Value::String(mode.to_string())).ok()) + .or_else(|| inferred_thinking_mode(canonical_id)) +} + +fn inferred_thinking_mode(canonical_id: &str) -> Option { + match canonical_id { + "anthropic/claude-fable-5" => Some(ThinkingMode::AlwaysOnAdaptive), + "anthropic/claude-fable-5.1" => Some(ThinkingMode::AlwaysOnAdaptive), + "anthropic/claude-opus-5" => Some(ThinkingMode::Adaptive), + "anthropic/claude-opus-5.5" => Some(ThinkingMode::AlwaysOnAdaptive), + "anthropic/claude-opus-4.6" => Some(ThinkingMode::Adaptive), + "anthropic/claude-opus-4.7" => Some(ThinkingMode::Adaptive), + "anthropic/claude-opus-4.8" => Some(ThinkingMode::Adaptive), + "anthropic/claude-sonnet-4.6" => Some(ThinkingMode::Adaptive), + "anthropic/claude-sonnet-5" => Some(ThinkingMode::Adaptive), + _ => None, + } +} + +fn parse_modalities(model_data: &Value, field: &str) -> Vec { + model_data + .get("modalities") + .and_then(|m| m.get(field)) + .and_then(|v| v.as_array()) + .map(|arr| { + arr.iter() + .filter_map(|v| v.as_str()) + .filter_map(|s| { + serde_json::from_value(serde_json::Value::String(s.to_string())).ok() + }) + .collect() + }) + .unwrap_or_else(|| vec![Modality::Text]) +} + +fn process_model( + model_id: &str, + model_data: &Value, + normalized_provider: &str, +) -> Result<(String, CanonicalModel)> { + let name = model_data["name"] + .as_str() + .with_context(|| format!("Model {} missing name", model_id))?; + + let canonical_id = canonical_name(normalized_provider, model_id); + + let modalities = Modalities { + input: parse_modalities(model_data, "input"), + output: parse_modalities(model_data, "output"), + }; + + let cost = match model_data.get("cost") { + Some(c) if !c.is_null() => Pricing { + input: c.get("input").and_then(|v| v.as_f64()), + output: c.get("output").and_then(|v| v.as_f64()), + cache_read: c.get("cache_read").and_then(|v| v.as_f64()), + cache_write: c.get("cache_write").and_then(|v| v.as_f64()), + }, + _ => Pricing { + input: None, + output: None, + cache_read: None, + cache_write: None, + }, + }; + + let limit = Limit { + context: model_data + .get("limit") + .and_then(|l| l.get("context")) + .and_then(|v| v.as_u64()) + .unwrap_or(DEFAULT_CONTEXT_LIMIT as u64) as usize, + output: model_data + .get("limit") + .and_then(|l| l.get("output")) + .and_then(|v| v.as_u64()) + .map(|v| v as usize), + }; + + let canonical_model = CanonicalModel { + id: canonical_id.clone(), + name: name.to_string(), + family: get_string(model_data, "family"), + attachment: model_data.get("attachment").and_then(|v| v.as_bool()), + reasoning: model_data.get("reasoning").and_then(|v| v.as_bool()), + thinking_mode: get_thinking_mode(&canonical_id, model_data), + tool_call: model_data + .get("tool_call") + .and_then(|v| v.as_bool()) + .unwrap_or(false), + temperature: model_data.get("temperature").and_then(|v| v.as_bool()), + knowledge: get_string(model_data, "knowledge"), + release_date: get_string(model_data, "release_date"), + last_updated: get_string(model_data, "last_updated"), + modalities, + open_weights: model_data.get("open_weights").and_then(|v| v.as_bool()), + cost, + limit, + }; + + let model_name = canonical_id + .strip_prefix(&format!("{}/", normalized_provider)) + .unwrap_or(model_id) + .to_string(); + + Ok((model_name, canonical_model)) +} + +fn pick_winning_variant(variants: &[(String, CanonicalModel)]) -> usize { + variants + .iter() + .enumerate() + .min_by(|(_, (id_a, a)), (_, (id_b, b))| { + id_a.len() + .cmp(&id_b.len()) + .then_with(|| b.last_updated.cmp(&a.last_updated)) + .then_with(|| b.release_date.cmp(&a.release_date)) + .then_with(|| id_a.cmp(id_b)) + }) + .map(|(idx, _)| idx) + .unwrap_or(0) +} + +pub fn from_models_dev(content: &str) -> Result { + let json: Value = serde_json::from_str(content)?; + let providers = json + .as_object() + .context("Expected object in models.dev response")?; + let mut registry = CanonicalModelRegistry::new(); + for (provider_key, provider_data) in providers { + let models = match provider_data.get("models").and_then(Value::as_object) { + Some(models) => models, + None => continue, + }; + let provider = normalize_provider_name(provider_key); + let mut candidates: BTreeMap> = BTreeMap::new(); + for (model_id, model_data) in models { + let (name, model) = process_model(model_id, model_data, provider)?; + candidates + .entry(name) + .or_default() + .push((model_id.clone(), model)); + } + for (name, variants) in candidates { + let winner = pick_winning_variant(&variants); + registry.register(provider, &name, variants[winner].1.clone()); + } + } + if registry.count() == 0 { + anyhow::bail!("models.dev catalog is empty"); + } + Ok(registry) +} + +#[cfg(test)] +mod tests { + use super::*; + + fn variant(id: &str, release: Option<&str>, updated: Option<&str>) -> (String, CanonicalModel) { + ( + id.to_string(), + CanonicalModel { + id: format!("openai/{id}"), + name: id.to_string(), + family: None, + attachment: None, + reasoning: None, + thinking_mode: None, + tool_call: false, + temperature: None, + knowledge: None, + release_date: release.map(String::from), + last_updated: updated.map(String::from), + modalities: Modalities::default(), + open_weights: None, + cost: Pricing::default(), + limit: Limit::default(), + }, + ) + } + + #[test] + fn shortest_variant_wins() { + let variants = vec![ + variant("gpt-4o-2024-08-06", Some("2024-08-06"), Some("2024-08-06")), + variant("gpt-4o", Some("2024-05-13"), Some("2024-08-06")), + variant("gpt-4o-2024-11-20", Some("2024-11-20"), Some("2024-11-20")), + variant("gpt-4o-2024-05-13", Some("2024-05-13"), Some("2024-05-13")), + ]; + assert_eq!(variants[pick_winning_variant(&variants)].0, "gpt-4o"); + + let variants = vec![ + variant( + "claude-haiku-4-5-20251001", + Some("2025-10-16"), + Some("2025-10-16"), + ), + variant("claude-haiku-4-5", Some("2025-10-16"), Some("2025-10-16")), + ]; + assert_eq!( + variants[pick_winning_variant(&variants)].0, + "claude-haiku-4-5" + ); + } + + #[test] + fn converts_provider_models_and_rejects_empty_catalog() { + let json = r#"{"openai":{"models":{"gpt-4o":{"name":"GPT-4o","tool_call":true,"limit":{"context":128000,"output":4096},"cost":{"input":2.5}}}}}"#; + let registry = from_models_dev(json).unwrap(); + let model = registry.get("openai", "gpt-4o").unwrap(); + assert_eq!(model.id, "openai/gpt-4o"); + assert_eq!(model.limit.context, 128000); + assert_eq!(model.cost.input, Some(2.5)); + assert!(from_models_dev("{}").is_err()); + } +} diff --git a/crates/goose-provider-types/src/canonical/name_builder.rs b/crates/goose-provider-types/src/canonical/name_builder.rs index 389bd53d4..7914ac183 100644 --- a/crates/goose-provider-types/src/canonical/name_builder.rs +++ b/crates/goose-provider-types/src/canonical/name_builder.rs @@ -334,262 +334,262 @@ mod tests { // === Direct provider (non-hosting) === assert_eq!( - map_to_canonical_model("anthropic", "claude-sonnet-4-5-20250929", r), + map_to_canonical_model("anthropic", "claude-sonnet-4-5-20250929", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("openai", "gpt-4o-latest", r), + map_to_canonical_model("openai", "gpt-4o-latest", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("xai_oauth", "grok-4.5", r), + map_to_canonical_model("xai_oauth", "grok-4.5", &r), Some("x-ai/grok-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("openai", "gpt-4-turbo-2024-04-09", r), + map_to_canonical_model("openai", "gpt-4-turbo-2024-04-09", &r), Some("openai/gpt-4-turbo".to_string()) ); assert_eq!( - map_to_canonical_model("chatgpt_codex", "gpt-5.6-sol", r), + map_to_canonical_model("chatgpt_codex", "gpt-5.6-sol", &r), Some("openai/gpt-5.6-sol".to_string()) ); assert_eq!( - map_to_canonical_model("opencode_go", "kimi-k2.6", r), + map_to_canonical_model("opencode_go", "kimi-k2.6", &r), Some("opencode-go/kimi-k2.6".to_string()) ); assert_eq!( - map_to_canonical_model("opencode_zen", "kimi-k3", r), + map_to_canonical_model("opencode_zen", "kimi-k3", &r), Some("opencode/kimi-k3".to_string()) ); // === OpenRouter === assert_eq!( - map_to_canonical_model("openrouter", "anthropic/claude-sonnet-4.5", r), + map_to_canonical_model("openrouter", "anthropic/claude-sonnet-4.5", &r), Some("openrouter/anthropic/claude-sonnet-4.5".to_string()) ); // === Anthropic Claude - basic === assert_eq!( - map_to_canonical_model("databricks", "claude-sonnet-4-5", r), + map_to_canonical_model("databricks", "claude-sonnet-4-5", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "claude-sonnet-4-5-20250929", r), + map_to_canonical_model("databricks", "claude-sonnet-4-5-20250929", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "claude-sonnet-4-5-latest", r), + map_to_canonical_model("databricks", "claude-sonnet-4-5-latest", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); // 4.x: {version}-{model} → {model}-{version} assert_eq!( - map_to_canonical_model("databricks", "claude-sonnet-4-5", r), + map_to_canonical_model("databricks", "claude-sonnet-4-5", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); // 4.x with minor version + prefix stripping assert_eq!( - map_to_canonical_model("databricks", "raml-claude-opus-4-5", r), + map_to_canonical_model("databricks", "raml-claude-opus-4-5", &r), Some("anthropic/claude-opus-4.5".to_string()) ); // === Claude with platform suffixes === assert_eq!( - map_to_canonical_model("databricks", "claude-sonnet-4-5-bedrock", r), + map_to_canonical_model("databricks", "claude-sonnet-4-5-bedrock", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "goose-claude-sonnet-4-5-bedrock", r), + map_to_canonical_model("databricks", "goose-claude-sonnet-4-5-bedrock", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("bedrock", "claude-sonnet-4-5", r), + map_to_canonical_model("bedrock", "claude-sonnet-4-5", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("aws_bedrock", "global.anthropic.claude-sonnet-5", r), + map_to_canonical_model("aws_bedrock", "global.anthropic.claude-sonnet-5", &r), Some("amazon-bedrock/global.anthropic.claude-sonnet-5".to_string()) ); assert_eq!( - map_to_canonical_model("anthropic", "claude-sonnet-5", r), + map_to_canonical_model("anthropic", "claude-sonnet-5", &r), Some("anthropic/claude-sonnet-5".to_string()) ); // === OpenAI GPT === assert_eq!( - map_to_canonical_model("databricks", "gpt-4o", r), + map_to_canonical_model("databricks", "gpt-4o", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "gpt-4o-2024-11-20", r), + map_to_canonical_model("databricks", "gpt-4o-2024-11-20", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "gpt-4o-latest", r), + map_to_canonical_model("databricks", "gpt-4o-latest", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "kgoose-gpt-4o", r), + map_to_canonical_model("databricks", "kgoose-gpt-4o", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("azure", "gpt-4o", r), + map_to_canonical_model("azure", "gpt-4o", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("azure_foundry", "gpt-4o", r), + map_to_canonical_model("azure_foundry", "gpt-4o", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("azure_foundry", "Phi-4", r), + map_to_canonical_model("azure_foundry", "Phi-4", &r), Some("azure/phi-4".to_string()) ); // === OpenAI O-series === assert_eq!( - map_to_canonical_model("databricks", "goose-o1", r), + map_to_canonical_model("databricks", "goose-o1", &r), Some("openai/o1".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "kgoose-o3", r), + map_to_canonical_model("databricks", "kgoose-o3", &r), Some("openai/o3".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "headless-goose-o3-mini", r), + map_to_canonical_model("databricks", "headless-goose-o3-mini", &r), Some("openai/o3-mini".to_string()) ); // === Google Gemini === assert_eq!( - map_to_canonical_model("databricks", "gemini-2-5-flash", r), + map_to_canonical_model("databricks", "gemini-2-5-flash", &r), Some("google/gemini-2.5-flash".to_string()) ); // === Meta Llama === assert_eq!( - map_to_canonical_model("databricks", "meta-llama-3-3-70b-instruct", r), + map_to_canonical_model("databricks", "meta-llama-3-3-70b-instruct", &r), Some("meta-llama/llama-3.3-70b-instruct".to_string()) ); // === Mistral variants === assert_eq!( - map_to_canonical_model("databricks", "codestral", r), + map_to_canonical_model("databricks", "codestral", &r), Some("mistralai/codestral".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "ministral-3b", r), + map_to_canonical_model("databricks", "ministral-3b", &r), Some("mistralai/ministral-3b".to_string()) ); // === DeepSeek === assert_eq!( - map_to_canonical_model("databricks", "databricks-deepseek-v4-flash", r), + map_to_canonical_model("databricks", "databricks-deepseek-v4-flash", &r), Some("deepseek/deepseek-v4-flash".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "deepseek-v4-pro", r), + map_to_canonical_model("databricks", "deepseek-v4-pro", &r), Some("deepseek/deepseek-v4-pro".to_string()) ); // === Grok (X.AI) === assert_eq!( - map_to_canonical_model("databricks", "grok-4.3", r), + map_to_canonical_model("databricks", "grok-4.3", &r), Some("x-ai/grok-4.3".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "databricks-grok-4.3", r), + map_to_canonical_model("databricks", "databricks-grok-4.3", &r), Some("x-ai/grok-4.3".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "kgoose-grok-4.3", r), + map_to_canonical_model("databricks", "kgoose-grok-4.3", &r), Some("x-ai/grok-4.3".to_string()) ); // === Cohere Command === // Note: version suffix "-2024" is stripped by canonical_name assert_eq!( - map_to_canonical_model("databricks", "command-r-plus-08-2024", r), + map_to_canonical_model("databricks", "command-r-plus-08-2024", &r), Some("cohere/command-r-plus-08".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "goose-command-r-08-2024", r), + map_to_canonical_model("databricks", "goose-command-r-08-2024", &r), Some("cohere/command-r-08".to_string()) ); // === Provider-prefixed extraction === assert_eq!( - map_to_canonical_model("databricks", "anthropic-claude-sonnet-4-5", r), + map_to_canonical_model("databricks", "anthropic-claude-sonnet-4-5", &r), Some("anthropic/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "openai-gpt-4o", r), + map_to_canonical_model("databricks", "openai-gpt-4o", &r), Some("openai/gpt-4o".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "google-gemini-2-5-flash", r), + map_to_canonical_model("databricks", "google-gemini-2-5-flash", &r), Some("google/gemini-2.5-flash".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "mistralai-codestral", r), + map_to_canonical_model("databricks", "mistralai-codestral", &r), Some("mistralai/codestral".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "deepseek-deepseek-v4-flash", r), + map_to_canonical_model("databricks", "deepseek-deepseek-v4-flash", &r), Some("deepseek/deepseek-v4-flash".to_string()) ); assert_eq!( - map_to_canonical_model("databricks", "x-ai-grok-4.3", r), + map_to_canonical_model("databricks", "x-ai-grok-4.3", &r), Some("x-ai/grok-4.3".to_string()) ); // === Zhipu AI === assert_eq!( - map_to_canonical_model("zhipu", "glm-4.7", r), + map_to_canonical_model("zhipu", "glm-4.7", &r), Some("zhipuai/glm-4.7".to_string()) ); assert_eq!( - map_to_canonical_model("zhipu", "glm-5", r), + map_to_canonical_model("zhipu", "glm-5", &r), Some("zhipuai/glm-5".to_string()) ); // === Kimi Code === assert_eq!( - map_to_canonical_model("kimi_code", "kimi-for-coding", r), + map_to_canonical_model("kimi_code", "kimi-for-coding", &r), Some("kimi-code-plan-cn/kimi-for-coding".to_string()) ); assert_eq!( - map_to_canonical_model("kimi_code", "kimi-for-coding-highspeed", r), + map_to_canonical_model("kimi_code", "kimi-for-coding-highspeed", &r), Some("kimi-code-plan-cn/kimi-for-coding-highspeed".to_string()) ); assert_eq!( - map_to_canonical_model("kimi_code", "k3", r), + map_to_canonical_model("kimi_code", "k3", &r), Some("kimi-code-plan-cn/k3".to_string()) ); // === GCP Vertex AI === assert_eq!( - map_to_canonical_model("gcp_vertex_ai", "gemini-2.5-flash", r), + map_to_canonical_model("gcp_vertex_ai", "gemini-2.5-flash", &r), Some("google-vertex/gemini-2.5-flash".to_string()) ); assert_eq!( - map_to_canonical_model("gcp_vertex_ai", "gemini-2.5-pro", r), + map_to_canonical_model("gcp_vertex_ai", "gemini-2.5-pro", &r), Some("google-vertex/gemini-2.5-pro".to_string()) ); assert_eq!( - map_to_canonical_model("gcp_vertex_ai", "claude-sonnet-4@20250514", r), + map_to_canonical_model("gcp_vertex_ai", "claude-sonnet-4@20250514", &r), Some("google-vertex/claude-sonnet-4".to_string()) ); assert_eq!( - map_to_canonical_model("gcp_vertex_ai", "claude-sonnet-4-5@20250929", r), + map_to_canonical_model("gcp_vertex_ai", "claude-sonnet-4-5@20250929", &r), Some("google-vertex/claude-sonnet-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("gcp_vertex_ai", "claude-opus-4-5@20251101", r), + map_to_canonical_model("gcp_vertex_ai", "claude-opus-4-5@20251101", &r), Some("google-vertex/claude-opus-4.5".to_string()) ); assert_eq!( - map_to_canonical_model("gcp_vertex_ai", "claude-haiku-4-5@20251001", r), + map_to_canonical_model("gcp_vertex_ai", "claude-haiku-4-5@20251001", &r), Some("google-vertex/claude-haiku-4.5".to_string()) ); } @@ -603,16 +603,16 @@ mod tests { let r = super::super::CanonicalModelRegistry::bundled().unwrap(); assert_eq!( - map_to_canonical_model("databricks_v2", "databricks-gpt-oss-120b", r), + map_to_canonical_model("databricks_v2", "databricks-gpt-oss-120b", &r), Some("databricks/databricks-gpt-oss-120b".to_string()) ); assert_eq!( - map_to_canonical_model("databricks_v2", "databricks-gpt-oss-20b", r), + map_to_canonical_model("databricks_v2", "databricks-gpt-oss-20b", &r), Some("databricks/databricks-gpt-oss-20b".to_string()) ); // Legacy provider name resolves identically. assert_eq!( - map_to_canonical_model("databricks", "databricks-gpt-oss-120b", r), + map_to_canonical_model("databricks", "databricks-gpt-oss-120b", &r), Some("databricks/databricks-gpt-oss-120b".to_string()) ); @@ -621,7 +621,7 @@ mod tests { // first-party "anthropic/*" entry (which carries thinking_mode used for // adaptive thinking), not the metadata-poor "databricks/databricks-*" one. assert_eq!( - map_to_canonical_model("databricks", "databricks-claude-opus-4-7", r), + map_to_canonical_model("databricks", "databricks-claude-opus-4-7", &r), Some("anthropic/claude-opus-4.7".to_string()) ); } diff --git a/crates/goose-provider-types/src/canonical/registry.rs b/crates/goose-provider-types/src/canonical/registry.rs index 4e52fd651..a51b68c78 100644 --- a/crates/goose-provider-types/src/canonical/registry.rs +++ b/crates/goose-provider-types/src/canonical/registry.rs @@ -1,35 +1,39 @@ use super::CanonicalModel; -use anyhow::{Context, Result}; +use anyhow::{bail, Context, Result}; +use futures::StreamExt; use once_cell::sync::Lazy; -use std::collections::HashMap; -use std::path::Path; +use reqwest::header::{ETAG, IF_NONE_MATCH}; +use std::collections::{HashMap, HashSet}; +use std::ops::Deref; +use std::path::{Path, PathBuf}; +use std::sync::{RwLock, RwLockReadGuard}; +use std::time::Duration; -/// Cached bundled canonical model registry -static BUNDLED_REGISTRY: Lazy> = Lazy::new(|| { - const CANONICAL_MODELS_ZSTD: &[u8] = - include_bytes!(concat!(env!("OUT_DIR"), "/canonical_models.json.zst")); +const MAX_CATALOG_BYTES: usize = 32 * 1024 * 1024; +const CATALOG_FILENAME: &str = "models_dev_api.json"; +const ETAG_FILENAME: &str = "models_dev_api.etag"; - let json = zstd::decode_all(CANONICAL_MODELS_ZSTD) - .context("Failed to decompress bundled canonical models JSON")?; - let models: Vec = - serde_json::from_slice(&json).context("Failed to parse bundled canonical models JSON")?; - - let mut registry = CanonicalModelRegistry::new(); - for model in models { - // Extract provider and model from id (format: "provider/model") - if let Some((provider, model_name)) = model.id.split_once('/') { - let provider = provider.to_string(); - let model_name = model_name.to_string(); - registry.register(&provider, &model_name, model); - } - } - - Ok(registry) +static ACTIVE_REGISTRY: Lazy>> = Lazy::new(|| { + let bundled = zstd::decode_all( + include_bytes!(concat!(env!("OUT_DIR"), "/canonical_models.json.zst")).as_slice(), + ) + .context("Failed to decompress bundled canonical models JSON") + .and_then(|json| CanonicalModelRegistry::from_json(std::str::from_utf8(&json)?)); + RwLock::new(bundled) }); +pub struct CanonicalModelRegistryGuard(RwLockReadGuard<'static, Result>); + +impl Deref for CanonicalModelRegistryGuard { + type Target = CanonicalModelRegistry; + + fn deref(&self) -> &Self::Target { + self.0.as_ref().expect("validated registry") + } +} + #[derive(Debug, Clone)] pub struct CanonicalModelRegistry { - // Key: (provider, model) tuple models: HashMap<(String, String), CanonicalModel>, } @@ -40,40 +44,50 @@ impl CanonicalModelRegistry { } } - pub fn bundled() -> Result<&'static Self> { - BUNDLED_REGISTRY - .as_ref() - .map_err(|e| anyhow::anyhow!("{}", e)) + pub fn bundled() -> Result { + let guard = ACTIVE_REGISTRY + .read() + .map_err(|_| anyhow::anyhow!("canonical model registry lock poisoned"))?; + if let Err(error) = &*guard { + anyhow::bail!("{error}"); + } + Ok(CanonicalModelRegistryGuard(guard)) + } + + pub fn from_json(content: &str) -> Result { + let models: Vec = + serde_json::from_str(content).context("Failed to parse canonical models JSON")?; + if models.is_empty() { + bail!("canonical model catalog is empty"); + } + + let mut seen = HashSet::new(); + let mut registry = Self::new(); + for model in models { + if !seen.insert(model.id.clone()) { + bail!("duplicate canonical model id: {}", model.id); + } + let (provider, model_name) = model + .id + .split_once('/') + .with_context(|| format!("invalid canonical model id: {}", model.id))?; + registry.register(provider, model_name, model.clone()); + } + Ok(registry) } pub fn from_file(path: impl AsRef) -> Result { let content = std::fs::read_to_string(path.as_ref()) .context("Failed to read canonical models file")?; - - let models: Vec = - serde_json::from_str(&content).context("Failed to parse canonical models JSON")?; - - let mut registry = Self::new(); - for model in models { - if let Some((provider, model_name)) = model.id.split_once('/') { - let provider = provider.to_string(); - let model_name = model_name.to_string(); - registry.register(&provider, &model_name, model); - } - } - - Ok(registry) + Self::from_json(&content) } pub fn to_file(&self, path: impl AsRef) -> Result<()> { let mut models: Vec<&CanonicalModel> = self.models.values().collect(); models.sort_by(|a, b| a.id.cmp(&b.id)); - let json = serde_json::to_string_pretty(&models) .context("Failed to serialize canonical models")?; - std::fs::write(path.as_ref(), json).context("Failed to write canonical models file")?; - Ok(()) } @@ -108,3 +122,95 @@ impl Default for CanonicalModelRegistry { Self::new() } } + +fn activate(registry: CanonicalModelRegistry) -> Result<()> { + *ACTIVE_REGISTRY + .write() + .map_err(|_| anyhow::anyhow!("canonical model registry lock poisoned"))? = Ok(registry); + Ok(()) +} + +pub fn load_cached_catalog(cache_dir: &Path) -> Result { + let path = cache_dir.join(CATALOG_FILENAME); + if !path.exists() { + return Ok(false); + } + let content = std::fs::read_to_string(path)?; + activate(super::models_dev::from_models_dev(&content)?)?; + Ok(true) +} + +pub async fn refresh_remote_catalog(url: &str, cache_dir: &Path) -> Result { + let client = reqwest::Client::builder() + .timeout(Duration::from_secs(15)) + .build()?; + let etag_path = cache_dir.join(ETAG_FILENAME); + let mut request = client.get(url).header( + "User-Agent", + "goose/model-catalog (https://github.com/aaif-goose/goose)", + ); + if let Ok(etag) = std::fs::read_to_string(&etag_path) { + request = request.header(IF_NONE_MATCH, etag); + } + + let response = request.send().await?.error_for_status()?; + if response.status() == reqwest::StatusCode::NOT_MODIFIED { + return Ok(false); + } + if response + .content_length() + .is_some_and(|length| length > MAX_CATALOG_BYTES as u64) + { + bail!("remote canonical model catalog exceeds size limit"); + } + let etag = response + .headers() + .get(ETAG) + .and_then(|value| value.to_str().ok()) + .map(str::to_owned); + let mut body = Vec::new(); + let mut stream = response.bytes_stream(); + while let Some(chunk) = stream.next().await { + let chunk = chunk?; + if body.len() + chunk.len() > MAX_CATALOG_BYTES { + bail!("remote canonical model catalog exceeds size limit"); + } + body.extend_from_slice(&chunk); + } + let content = std::str::from_utf8(&body).context("canonical model catalog is not UTF-8")?; + let registry = super::models_dev::from_models_dev(content)?; + + std::fs::create_dir_all(cache_dir)?; + atomic_write(cache_dir.join(CATALOG_FILENAME), &body)?; + if let Some(etag) = etag { + atomic_write(etag_path, etag.as_bytes())?; + } + activate(registry)?; + Ok(true) +} + +fn atomic_write(destination: PathBuf, content: &[u8]) -> Result<()> { + let temporary = destination.with_extension(format!("tmp-{}", uuid::Uuid::new_v4())); + std::fs::write(&temporary, content)?; + if let Err(error) = std::fs::rename(&temporary, &destination) { + let _ = std::fs::remove_file(&temporary); + return Err(error.into()); + } + Ok(()) +} + +#[cfg(test)] +mod tests { + use super::*; + + #[test] + fn rejects_empty_duplicate_and_malformed_catalogs() { + assert!(CanonicalModelRegistry::from_json("[]").is_err()); + let model = r#"{"id":"openai/test","name":"Test","tool_call":true}"#; + assert!(CanonicalModelRegistry::from_json(&format!("[{model},{model}]")).is_err()); + assert!(CanonicalModelRegistry::from_json( + r#"[{"id":"invalid","name":"Test","tool_call":true}]"# + ) + .is_err()); + } +} diff --git a/crates/goose/Cargo.toml b/crates/goose/Cargo.toml index 2628a599a..1ad06cf14 100644 --- a/crates/goose/Cargo.toml +++ b/crates/goose/Cargo.toml @@ -10,6 +10,7 @@ description.workspace = true [features] default = [] +online-model-meta = [] telemetry = [] otel = [ "dep:tracing-opentelemetry", diff --git a/crates/goose/src/bin/build_canonical_models.rs b/crates/goose/src/bin/build_canonical_models.rs index 3697d59a2..9445d6092 100644 --- a/crates/goose/src/bin/build_canonical_models.rs +++ b/crates/goose/src/bin/build_canonical_models.rs @@ -10,10 +10,7 @@ use anyhow::{Context, Result}; use clap::Parser; use goose::providers::create_with_named_model; -use goose_providers::canonical::{ - canonical_name, CanonicalModel, CanonicalModelRegistry, Limit, Modalities, Modality, - ModelMapping, Pricing, ThinkingMode, -}; +use goose_providers::canonical::ModelMapping; use serde::{Deserialize, Serialize}; use serde_json::Value; use std::collections::{BTreeMap, BTreeSet, HashMap}; @@ -31,7 +28,6 @@ struct ProviderMetadata { } const MODELS_DEV_API_URL: &str = "https://models.dev/api.json"; -const DEFAULT_CONTEXT_LIMIT: usize = 128_000; const SEPARATOR: &str = "================================================================================"; const SUBSEPARATOR: &str = @@ -342,122 +338,6 @@ async fn fetch_models_dev() -> Result { .context("Failed to parse models.dev response") } -fn get_string(value: &Value, field: &str) -> Option { - value.get(field).and_then(|v| v.as_str()).map(String::from) -} - -fn get_thinking_mode(canonical_id: &str, value: &Value) -> Option { - value - .get("thinking_mode") - .and_then(|v| v.as_str()) - .and_then(|mode| serde_json::from_value(Value::String(mode.to_string())).ok()) - .or_else(|| inferred_thinking_mode(canonical_id)) -} - -fn inferred_thinking_mode(canonical_id: &str) -> Option { - match canonical_id { - "anthropic/claude-fable-5" => Some(ThinkingMode::AlwaysOnAdaptive), - "anthropic/claude-fable-5.1" => Some(ThinkingMode::AlwaysOnAdaptive), - "anthropic/claude-opus-5" => Some(ThinkingMode::Adaptive), - "anthropic/claude-opus-5.5" => Some(ThinkingMode::AlwaysOnAdaptive), - "anthropic/claude-opus-4.6" => Some(ThinkingMode::Adaptive), - "anthropic/claude-opus-4.7" => Some(ThinkingMode::Adaptive), - "anthropic/claude-opus-4.8" => Some(ThinkingMode::Adaptive), - "anthropic/claude-sonnet-4.6" => Some(ThinkingMode::Adaptive), - "anthropic/claude-sonnet-5" => Some(ThinkingMode::Adaptive), - _ => None, - } -} - -fn parse_modalities(model_data: &Value, field: &str) -> Vec { - model_data - .get("modalities") - .and_then(|m| m.get(field)) - .and_then(|v| v.as_array()) - .map(|arr| { - arr.iter() - .filter_map(|v| v.as_str()) - .filter_map(|s| { - serde_json::from_value(serde_json::Value::String(s.to_string())).ok() - }) - .collect() - }) - .unwrap_or_else(|| vec![Modality::Text]) -} - -fn process_model( - model_id: &str, - model_data: &Value, - normalized_provider: &str, -) -> Result<(String, CanonicalModel)> { - let name = model_data["name"] - .as_str() - .with_context(|| format!("Model {} missing name", model_id))?; - - let canonical_id = canonical_name(normalized_provider, model_id); - - let modalities = Modalities { - input: parse_modalities(model_data, "input"), - output: parse_modalities(model_data, "output"), - }; - - let cost = match model_data.get("cost") { - Some(c) if !c.is_null() => Pricing { - input: c.get("input").and_then(|v| v.as_f64()), - output: c.get("output").and_then(|v| v.as_f64()), - cache_read: c.get("cache_read").and_then(|v| v.as_f64()), - cache_write: c.get("cache_write").and_then(|v| v.as_f64()), - }, - _ => Pricing { - input: None, - output: None, - cache_read: None, - cache_write: None, - }, - }; - - let limit = Limit { - context: model_data - .get("limit") - .and_then(|l| l.get("context")) - .and_then(|v| v.as_u64()) - .unwrap_or(DEFAULT_CONTEXT_LIMIT as u64) as usize, - output: model_data - .get("limit") - .and_then(|l| l.get("output")) - .and_then(|v| v.as_u64()) - .map(|v| v as usize), - }; - - let canonical_model = CanonicalModel { - id: canonical_id.clone(), - name: name.to_string(), - family: get_string(model_data, "family"), - attachment: model_data.get("attachment").and_then(|v| v.as_bool()), - reasoning: model_data.get("reasoning").and_then(|v| v.as_bool()), - thinking_mode: get_thinking_mode(&canonical_id, model_data), - tool_call: model_data - .get("tool_call") - .and_then(|v| v.as_bool()) - .unwrap_or(false), - temperature: model_data.get("temperature").and_then(|v| v.as_bool()), - knowledge: get_string(model_data, "knowledge"), - release_date: get_string(model_data, "release_date"), - last_updated: get_string(model_data, "last_updated"), - modalities, - open_weights: model_data.get("open_weights").and_then(|v| v.as_bool()), - cost, - limit, - }; - - let model_name = canonical_id - .strip_prefix(&format!("{}/", normalized_provider)) - .unwrap_or(model_id) - .to_string(); - - Ok((model_name, canonical_model)) -} - fn collect_provider_metadata( providers_obj: &serde_json::Map, ) -> Vec { @@ -525,99 +405,25 @@ fn collect_provider_metadata( metadata_list } -fn pick_winning_variant(variants: &[(String, CanonicalModel)]) -> usize { - variants - .iter() - .enumerate() - .min_by(|(_, (id_a, a)), (_, (id_b, b))| { - id_a.len() - .cmp(&id_b.len()) - .then_with(|| b.last_updated.cmp(&a.last_updated)) - .then_with(|| b.release_date.cmp(&a.release_date)) - .then_with(|| id_a.cmp(id_b)) - }) - .map(|(idx, _)| idx) - .unwrap_or(0) -} async fn build_canonical_models() -> Result<()> { let json = fetch_models_dev().await?; + let registry = goose_providers::canonical::models_dev::from_models_dev(&json.to_string())?; + let output_path = data_file_path("canonical_models.json"); + registry.to_file(&output_path)?; + println!( + "Wrote {} models to {}", + registry.count(), + output_path.display() + ); let providers_obj = json .as_object() .context("Expected object in models.dev response")?; - - let mut registry = CanonicalModelRegistry::new(); - let mut total_models = 0; - - for (provider_key, provider_data) in providers_obj { - let models = match provider_data.get("models").and_then(|v| v.as_object()) { - Some(m) => m, - None => continue, - }; - - let normalized_provider = normalize_provider_name(provider_key); - - println!( - "\nProcessing {} ({} models)...", - normalized_provider, - models.len() - ); - - let mut candidates: BTreeMap> = BTreeMap::new(); - for (model_id, model_data) in models { - let (model_name, canonical_model) = - process_model(model_id, model_data, normalized_provider)?; - candidates - .entry(model_name) - .or_default() - .push((model_id.clone(), canonical_model)); - } - - for (canonical_key, mut variants) in candidates { - let winner = if variants.len() == 1 { - variants.pop().unwrap().1 - } else { - let chosen_idx = pick_winning_variant(&variants); - let chosen_id = variants[chosen_idx].0.clone(); - println!( - " ⚠ {} variants collide on key '{}/{}': [{}] — keeping '{}'", - variants.len(), - normalized_provider, - canonical_key, - variants - .iter() - .map(|(id, _)| id.as_str()) - .collect::>() - .join(", "), - chosen_id, - ); - variants.swap_remove(chosen_idx).1 - }; - registry.register(normalized_provider, &canonical_key, winner); - total_models += 1; - } - } - - let output_path = data_file_path("canonical_models.json"); - registry.to_file(&output_path)?; - println!( - "\n✓ Wrote {} models to {}", - total_models, - output_path.display() - ); - - println!("\n\nCollecting provider metadata from models.dev..."); - let provider_metadata_list = collect_provider_metadata(providers_obj); - - let provider_metadata_path = data_file_path("provider_metadata.json"); - let provider_metadata_json = serde_json::to_string_pretty(&provider_metadata_list)?; - std::fs::write(&provider_metadata_path, provider_metadata_json)?; - println!( - "✓ Wrote {} providers metadata to {}", - provider_metadata_list.len(), - provider_metadata_path.display() - ); - + let metadata = collect_provider_metadata(providers_obj); + std::fs::write( + data_file_path("provider_metadata.json"), + serde_json::to_string_pretty(&metadata)?, + )?; Ok(()) } @@ -733,54 +539,3 @@ async fn main() -> Result<()> { Ok(()) } - -#[cfg(test)] -mod tests { - use super::*; - - fn variant(id: &str, release: Option<&str>, updated: Option<&str>) -> (String, CanonicalModel) { - ( - id.to_string(), - CanonicalModel { - id: format!("openai/{}", id), - name: id.to_string(), - family: None, - attachment: None, - reasoning: None, - thinking_mode: None, - tool_call: false, - temperature: None, - knowledge: None, - release_date: release.map(String::from), - last_updated: updated.map(String::from), - modalities: Modalities::default(), - open_weights: None, - cost: Pricing::default(), - limit: Limit::default(), - }, - ) - } - - #[test] - fn shortest_variant_wins() { - let variants = vec![ - variant("gpt-4o-2024-08-06", Some("2024-08-06"), Some("2024-08-06")), - variant("gpt-4o", Some("2024-05-13"), Some("2024-08-06")), - variant("gpt-4o-2024-11-20", Some("2024-11-20"), Some("2024-11-20")), - variant("gpt-4o-2024-05-13", Some("2024-05-13"), Some("2024-05-13")), - ]; - let idx = pick_winning_variant(&variants); - assert_eq!(variants[idx].0, "gpt-4o"); - - let variants = vec![ - variant( - "claude-haiku-4-5-20251001", - Some("2025-10-16"), - Some("2025-10-16"), - ), - variant("claude-haiku-4-5", Some("2025-10-16"), Some("2025-10-16")), - ]; - let idx = pick_winning_variant(&variants); - assert_eq!(variants[idx].0, "claude-haiku-4-5"); - } -} diff --git a/crates/goose/src/lib.rs b/crates/goose/src/lib.rs index b12472528..db2d8131c 100644 --- a/crates/goose/src/lib.rs +++ b/crates/goose/src/lib.rs @@ -28,6 +28,8 @@ pub mod instance_id; mod live_voice; pub mod logging; pub mod mcp_utils; +#[cfg(feature = "online-model-meta")] +pub mod model_catalog; pub mod model_config; pub mod oauth; #[cfg(feature = "otel")] diff --git a/crates/goose/src/model_catalog.rs b/crates/goose/src/model_catalog.rs new file mode 100644 index 000000000..75f682b1a --- /dev/null +++ b/crates/goose/src/model_catalog.rs @@ -0,0 +1,22 @@ +use crate::config::paths::Paths; +use goose_providers::canonical::{load_cached_catalog, refresh_remote_catalog}; +use std::path::PathBuf; + +const CATALOG_URL: &str = "https://models.dev/api.json"; + +fn cache_dir() -> PathBuf { + Paths::in_data_dir("model_catalog") +} + +pub fn initialize() { + let cache_dir = cache_dir(); + if let Err(error) = load_cached_catalog(&cache_dir) { + tracing::warn!(%error, "ignoring invalid cached model catalog"); + } + + tokio::spawn(async move { + if let Err(error) = refresh_remote_catalog(CATALOG_URL, &cache_dir).await { + tracing::warn!(%error, "failed to refresh remote model catalog"); + } + }); +}