session_core/
model_refresh.rs1use crate::RunEnv as Env;
10use crate::{ModelFlags, lane};
11use ai::model_refresh::{
12 DEFAULT_CATALOG_BASE_URL, load_radius_gateway_config, radius_models_from_config, refresh_remote_catalog,
13};
14use serde_json::json;
15use std::sync::Arc;
16use std::time::Duration;
17
18const REFRESH_BUDGET: Duration = Duration::from_secs(15);
20
21pub const REFRESH_TIMED_OUT: &str = "Model catalog refresh timed out.";
23
24pub fn refresh_model_catalogs(env: &Env) -> Result<(), String> {
26 let errors = refresh_catalogs_from(env, DEFAULT_CATALOG_BASE_URL, true)?;
27 if errors.is_empty() {
28 return Ok(());
29 }
30 let details: Vec<String> = errors.iter().map(|(p, e)| format!("{p}: {e}")).collect();
31 Err(format!("Could not refresh model catalogs: {}", details.join("; ")))
32}
33
34pub fn refresh_catalogs(env: &Env) -> Result<Vec<(String, String)>, String> {
36 if config::env::offline(&*env.var) {
37 return Ok(Vec::new());
38 }
39 refresh_catalogs_from(env, DEFAULT_CATALOG_BASE_URL, false)
40}
41
42pub fn refresh_catalogs_from(env: &Env, catalog_base_url: &str, force: bool) -> Result<Vec<(String, String)>, String> {
45 let user_agent = &ai::model_refresh::management_user_agent();
46 let registry = lane::registry(env);
47 let store = config::models_store::ModelsStore::beside(&config::paths::AgentPaths::new(env.agent_dir()).models());
48 let transport: Arc<dyn ai::Transport> = Arc::new(ai::ReqwestTransport::for_env(&*env.var, None));
49 let builtin: Vec<&str> = ai::models::builtin_providers().collect();
50 let providers: Vec<String> = registry
51 .provider_ids()
52 .into_iter()
53 .filter(|p| builtin.contains(&p.as_str()) || registry.radius_gateway(p).is_some())
54 .filter(|p| p != ai::claude_code::PROVIDER)
56 .collect();
57 let now = || jsrt::date::now_ms();
58 let work = async {
59 let mut errors: Vec<(String, String)> = Vec::new();
60 for provider in &providers {
61 let key = match lane::request_key(&ModelFlags::default(), env, provider) {
63 Ok(Some(key)) => key,
64 Ok(None) => continue,
65 Err(error) => {
66 errors.push((provider.clone(), error));
67 continue;
68 }
69 };
70 if let Some((_, gateway)) = registry.radius_gateway(provider) {
71 match load_radius_gateway_config(&gateway, Some(&key), &*transport).await {
72 Ok(config) => {
73 let models = radius_models_from_config(provider, &config).unwrap_or_default();
74 if let Err(error) = store.write(provider, json!({"models": models, "checkedAt": now()})) {
75 errors.push((provider.clone(), error));
76 }
77 }
78 Err(error) => errors.push((provider.clone(), error)),
79 }
80 continue;
81 }
82 let stored = store.read(provider).ok().flatten();
83 let outcome = refresh_remote_catalog(
84 provider,
85 stored.as_ref(),
86 catalog_base_url,
87 force,
88 user_agent,
89 &now,
90 &*transport,
91 )
92 .await;
93 if let Some(entry) = outcome.persist
94 && let Err(error) = store.write(provider, entry)
95 {
96 errors.push((provider.clone(), error));
97 }
98 if let Some(error) = outcome.error {
99 errors.push((provider.clone(), error));
100 }
101 }
102 errors
103 };
104 std::thread::scope(|scope| {
105 scope
106 .spawn(|| {
107 let runtime = tokio::runtime::Builder::new_current_thread()
108 .enable_all()
109 .build()
110 .map_err(|e| e.to_string())?;
111 runtime
112 .block_on(async { tokio::time::timeout(REFRESH_BUDGET, work).await })
113 .map_err(|_| REFRESH_TIMED_OUT.to_string())
114 })
115 .join()
116 .unwrap_or_else(|_| Err("Model catalog refresh failed".into()))
117 })
118}