use crate::RunEnv as Env;
use crate::{ModelFlags, lane};
use ai::model_refresh::{
DEFAULT_CATALOG_BASE_URL, load_radius_gateway_config, radius_models_from_config, refresh_remote_catalog,
};
use serde_json::json;
use std::sync::Arc;
use std::time::Duration;
const REFRESH_BUDGET: Duration = Duration::from_secs(15);
pub const REFRESH_TIMED_OUT: &str = "Model catalog refresh timed out.";
pub fn refresh_model_catalogs(env: &Env) -> Result<(), String> {
let errors = refresh_catalogs_from(env, DEFAULT_CATALOG_BASE_URL, true)?;
if errors.is_empty() {
return Ok(());
}
let details: Vec<String> = errors.iter().map(|(p, e)| format!("{p}: {e}")).collect();
Err(format!("Could not refresh model catalogs: {}", details.join("; ")))
}
pub fn refresh_catalogs(env: &Env) -> Result<Vec<(String, String)>, String> {
if config::env::offline(&*env.var) {
return Ok(Vec::new());
}
refresh_catalogs_from(env, DEFAULT_CATALOG_BASE_URL, false)
}
pub fn refresh_catalogs_from(env: &Env, catalog_base_url: &str, force: bool) -> Result<Vec<(String, String)>, String> {
let user_agent = &ai::model_refresh::management_user_agent();
let registry = lane::registry(env);
let store = config::models_store::ModelsStore::beside(&config::paths::AgentPaths::new(env.agent_dir()).models());
let transport: Arc<dyn ai::Transport> = Arc::new(ai::ReqwestTransport::for_env(&*env.var, None));
let builtin: Vec<&str> = ai::models::builtin_providers().collect();
let providers: Vec<String> = registry
.provider_ids()
.into_iter()
.filter(|p| builtin.contains(&p.as_str()) || registry.radius_gateway(p).is_some())
.filter(|p| p != ai::claude_code::PROVIDER)
.collect();
let now = || jsrt::date::now_ms();
let work = async {
let mut errors: Vec<(String, String)> = Vec::new();
for provider in &providers {
let key = match lane::request_key(&ModelFlags::default(), env, provider) {
Ok(Some(key)) => key,
Ok(None) => continue,
Err(error) => {
errors.push((provider.clone(), error));
continue;
}
};
if let Some((_, gateway)) = registry.radius_gateway(provider) {
match load_radius_gateway_config(&gateway, Some(&key), &*transport).await {
Ok(config) => {
let models = radius_models_from_config(provider, &config).unwrap_or_default();
if let Err(error) = store.write(provider, json!({"models": models, "checkedAt": now()})) {
errors.push((provider.clone(), error));
}
}
Err(error) => errors.push((provider.clone(), error)),
}
continue;
}
let stored = store.read(provider).ok().flatten();
let outcome = refresh_remote_catalog(
provider,
stored.as_ref(),
catalog_base_url,
force,
user_agent,
&now,
&*transport,
)
.await;
if let Some(entry) = outcome.persist
&& let Err(error) = store.write(provider, entry)
{
errors.push((provider.clone(), error));
}
if let Some(error) = outcome.error {
errors.push((provider.clone(), error));
}
}
errors
};
std::thread::scope(|scope| {
scope
.spawn(|| {
let runtime = tokio::runtime::Builder::new_current_thread()
.enable_all()
.build()
.map_err(|e| e.to_string())?;
runtime
.block_on(async { tokio::time::timeout(REFRESH_BUDGET, work).await })
.map_err(|_| REFRESH_TIMED_OUT.to_string())
})
.join()
.unwrap_or_else(|_| Err("Model catalog refresh failed".into()))
})
}