Skip to main content

session_core/
model_refresh.rs

1//! `ultron update --models` (`refreshModelCatalogs` of package-manager-cli.ts): every provider that refreshes its
2//! catalog and has a credential refreshes it from the network, as `ModelRuntime.refresh({ allowNetwork: true,
3//! force: true })` does: built-in providers revalidate their pi.dev catalog, Radius providers (the built-in one and
4//! models.json `"oauth": "radius"` ones) load `<gateway>/v1/config` with their key (an expired OAuth token is
5//! refreshed first). Results land in models-store.json, which every later start restores.
6//!
7//! Evidence: `crates/ai/fixtures/generate-model-refresh.mjs`; `tests/model_refresh.rs` replays it.
8
9use 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
18/// The whole refresh's time budget (`refreshModelCatalogs`' 15 s abort).
19const REFRESH_BUDGET: Duration = Duration::from_secs(15);
20
21/// [`refresh_catalogs`]' error when its whole budget ran out (`result.aborted` after the timer in TS).
22pub const REFRESH_TIMED_OUT: &str = "Model catalog refresh timed out.";
23
24/// Refresh every provider's stored catalog. `Err` is the message `ultron update --models` prints after `Error: `.
25pub 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
34/// The model runtime's refresh: [`refresh_catalogs_from`] pi.dev, or nothing when offline (`PI_OFFLINE`).
35pub 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
42/// [`refresh_model_catalogs`]' per-provider failures, in provider order; `Err` when the whole refresh timed out.
43/// Without `force`, a pi.dev catalog checked within the last four hours is not asked again (a login's refresh).
44pub 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        // `claude-code` has no catalog to refresh (its models are the CLI's), though its requests always resolve.
55        .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            // `resolveRefreshCredential`: no credential, no network refresh.
62            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}