From 00bbc474c031b296789aafee250c2ff08205e4c7 Mon Sep 17 00:00:00 2001 From: Mr0Bread <55754540+Mr0Bread@users.noreply.github.com> Date: Mon, 16 Nov 2026 20:40:13 +0200 Subject: [PATCH] fix(agents): discover per-model effort settings before the first prompt (#3807) ACP discovery learned effort settings only for the session's default model, so picking another model before its first prompt lost the effort control. The shared catalog now discovers a selected model's missing settings in a short-lived ACP session (session/set_config_option, no prompt), tells unknown settings apart from verified no-effort models, shows loading, discards stale discoveries during rapid model changes, and keeps per-model failures and cooldowns separate. Idle-task model switches use the same discovery and keep the previous controls when it fails. Discovery errors keep their cause. Closes #3789 Co-authored-by: Mr0Bread <55754540+Mr0Bread@users.noreply.github.com> --- crates/ide-agent/src/acp/discover.rs | 124 ++++-- crates/ide-agent/src/catalogs.rs | 159 +++++++- crates/ide-agent/src/catalogs/tests.rs | 401 ++++++++++++++++--- crates/ide-agent/src/lib.rs | 128 ++++-- crates/ide-agent/src/tests.rs | 164 +++++++- crates/ide-host/src/ops/agent.rs | 12 +- crates/ide-host/tests/agent_model_refresh.rs | 4 +- docs/en/guide/agents.mdx | 4 +- docs/zh/guide/agents.mdx | 4 +- e2e/agentCycleEffort.spec.ts | 66 +++ src-tauri/src/commands/agent.rs | 3 +- src/bindings.ts | 2 +- src/features/agents/ConfigPickers.tsx | 6 + src/features/agents/HomeEditor.tsx | 45 ++- src/features/agents/modelRefresh.test.tsx | 171 +++++++- src/features/agents/store.ts | 34 +- src/platform/locales/text/en.json | 1 + src/platform/locales/text/zh.json | 1 + 18 files changed, 1173 insertions(+), 156 deletions(-) diff --git a/crates/ide-agent/src/acp/discover.rs b/crates/ide-agent/src/acp/discover.rs index a505b5941..695cb284a 100644 --- a/crates/ide-agent/src/acp/discover.rs +++ b/crates/ide-agent/src/acp/discover.rs @@ -14,20 +14,21 @@ use std::collections::BTreeMap; use std::sync::Arc; use std::time::Duration; +const CONFIG_UPDATE_TIMEOUT: Duration = if cfg!(test) { Duration::from_millis(100) } else { Duration::from_secs(5) }; const DISCOVER_TIMEOUT: Duration = if cfg!(test) { Duration::from_secs(3) } else { Duration::from_secs(120) }; /// Opens `session/new`, reads `configOptions`, and records the `thought_level` choices of the /// session's model: they describe that model only, and other models may offer different ones. -pub(crate) async fn run(shared: &Arc, spec: &ProviderSpec) -> Result { +pub(crate) async fn run(shared: &Arc, spec: &ProviderSpec, model: Option<&str>) -> Result { let prefer_stored = crate::provider::prefer_stored_copilot_auth(); - match run_once(shared, spec, prefer_stored).await { + match run_once(shared, spec, prefer_stored, model).await { Err(err) if !prefer_stored && crate::provider::is_copilot_provider(&spec.id) && crate::provider::has_unconfigured_copilot_ambient_token(&spec.env) && super::auth_required(0, &err) => { - let retry = run_once(shared, spec, true).await; + let retry = run_once(shared, spec, true, model).await; if retry.is_ok() { crate::provider::mark_prefer_stored_copilot_auth(); } @@ -37,7 +38,12 @@ pub(crate) async fn run(shared: &Arc, spec: &ProviderSpec) -> Result, spec: &ProviderSpec, strip_ambient: bool) -> Result { +async fn run_once( + shared: &Arc, + spec: &ProviderSpec, + strip_ambient: bool, + selected_model: Option<&str>, +) -> Result { let root = shared.paths.project_root.clone(); let launch = spec.clone(); let launch = tokio::task::spawn_blocking({ @@ -47,28 +53,63 @@ async fn run_once(shared: &Arc, spec: &ProviderSpec, strip_ambient: bool .await .map_err(|e| e.to_string())?; let cwd = dunce::canonicalize(&root).unwrap_or(root); - let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), commands: Mutex::new(None) }); + let updates = Arc::new(DiscoveryUpdates { provider: spec.id.clone(), ..Default::default() }); let client = Dialect::wrap(updates.clone()); let on_stderr: Box = Box::new(|_| {}); let peer = (shared.connector)(&launch, &cwd, client.clone(), on_stderr) - .map_err(|e| format!("Couldn't start {} (`{}`): {e}", launch.name, launch.command))?; + .map_err(|e| format!("Couldn't start {} for model discovery: {e}", launch.name))?; let _stop = crate::catalogs::KillPeer(peer.clone()); let conn = Conn::new(peer.clone(), client); let work = async { - conn.initialize(&client_info()).await.map_err(|e| e.to_string())?; + conn.initialize(&client_info()).await.map_err(discovery_error)?; let cwd_s = cwd.to_string_lossy().into_owned(); // No project MCP during discovery: Cursor can spend a long time spawning servers. let new: Value = conn .request("session/new", json!({ "cwd": cwd_s, "mcpServers": [] }), None) .await - .map_err(|e| e.to_string())?; + .map_err(discovery_error)?; let mut options = config::options_of(&new); config::add_client_options(&launch.id, &mut options); - let model = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.clone()); - let levels = match (model, levels_for_model_from_slice(&options)) { - (Some(model), Some(effort)) => BTreeMap::from([(model, effort)]), - _ => BTreeMap::new(), - }; + let model_option = options.iter().find(|o| o.category.as_deref() == Some("model")); + let mut levels = BTreeMap::new(); + if new.get("configOptions").is_some_and(Value::is_array) + && let Some(model) = model_option.and_then(|o| o.current.as_ref()) + { + levels.insert(model.clone(), levels_for_model_from_slice(&options)); + } + if let Some(selected) = selected_model + && let Some(option) = model_option.filter(|o| o.values.iter().any(|v| v.value == selected)) + && !levels.contains_key(selected) + { + let session = + new.get("sessionId").and_then(Value::as_str).ok_or("The agent did not return a session ID")?; + let (method, mut params) = config::set_request(option, selected); + params["sessionId"] = json!(session); + updates.config.lock().session = Some(session.to_owned()); + let response: Value = conn.request(method, params, None).await.map_err(discovery_error)?; + let settings = if let Some(settings) = selected_settings(&response, selected) { + settings + } else { + tokio::time::timeout(CONFIG_UPDATE_TIMEOUT, async { + loop { + let notified = updates.changed.notified(); + if let Some(settings) = updates + .config + .lock() + .options + .as_ref() + .and_then(|options| selected_settings(options, selected)) + { + return settings; + } + notified.await; + } + }) + .await + .map_err(|_| "The agent did not report settings for the selected model".to_owned())? + }; + levels.insert(selected.to_owned(), levels_for_model_from_slice(&settings)); + } let commands = updates .commands .lock() @@ -88,16 +129,38 @@ async fn run_once(shared: &Arc, spec: &ProviderSpec, strip_ambient: bool struct DiscoveryUpdates { provider: String, commands: Mutex>>, + config: Mutex, + changed: tokio::sync::Notify, +} + +#[derive(Default)] +struct DiscoveryConfig { + session: Option, + options: Option, } impl ide_jsonrpc::Handler for DiscoveryUpdates { fn on_notification(&self, method: &str, params: Value) { - if method == "session/update" - && let Some(update) = params.get("update") - && update["sessionUpdate"] == "available_commands_update" - { - // Commands are protocol data, not stderr (which may contain credentials). - *self.commands.lock() = Some(config::commands_of(update, &self.provider)); + if method != "session/update" { + return; + } + let Some(update) = params.get("update") else { return }; + match update["sessionUpdate"].as_str() { + Some("available_commands_update") => { + // Commands are protocol data, not stderr (which may contain credentials). + *self.commands.lock() = Some(config::commands_of(update, &self.provider)); + } + Some("config_option_update") => { + let mut config = self.config.lock(); + if config.session.as_deref() == params.get("sessionId").and_then(Value::as_str) + && config.session.is_some() + && update.get("configOptions").is_some_and(Value::is_array) + { + config.options = Some(update.clone()); + self.changed.notify_one(); + } + } + _ => {} } } @@ -106,8 +169,24 @@ impl ide_jsonrpc::Handler for DiscoveryUpdates { } } -fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option> { - let levels: Vec<_> = options +fn discovery_error(error: ide_jsonrpc::RpcError) -> String { + match error { + ide_jsonrpc::RpcError::Server { code, message, .. } if super::auth_required(code, &message) => { + "Sign in required: the agent could not authenticate model discovery".into() + } + other => format!("The agent could not complete model discovery: {other}"), + } +} + +fn selected_settings(response: &Value, model: &str) -> Option> { + response.get("configOptions")?.as_array()?; + let options = config::options_of(response); + let current = options.iter().find(|o| o.category.as_deref() == Some("model")).and_then(|o| o.current.as_deref()); + current.is_none_or(|current| current == model).then_some(options) +} + +fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Vec { + options .iter() .filter(|o| config::is_per_model_option(o)) .cloned() @@ -121,6 +200,5 @@ fn levels_for_model_from_slice(options: &[AgentConfigOption]) -> Option, flight: Option>, abort: Option, + flight_model: Option, + requested_model: Option, + model_failures: HashMap, catalog: Option, } +struct ModelFailure { + completed: Instant, + retry_at_ms: f64, + error: String, +} + #[derive(Clone, Default, Serialize, Deserialize)] #[serde(rename_all = "camelCase")] pub(crate) struct CatalogData { @@ -204,6 +213,24 @@ impl AgentCatalogs { .unwrap_or_else(|| Self::fallback(shared, provider)) } + pub(crate) fn levels(&self, shared: &Shared, provider: &str, model: &str) -> Option> { + let state = self.state.lock(); + if let Some(catalog) = state.entries.get(&Self::key(shared, provider)).and_then(|entry| entry.catalog.as_ref()) + { + return catalog.thought_levels.get(model).cloned(); + } + drop(state); + let cache = shared.known.lock(); + let known = cache.get(provider)?; + known + .catalogs + .get(&shared.root_key()) + .map(|saved| &saved.catalog.thought_levels) + .unwrap_or(&known.thought_levels) + .get(model) + .cloned() + } + pub(crate) fn evict_if_idle(&self, shared: &Shared, provider: &str) { let key = Self::key(shared, provider); let mut state = self.state.lock(); @@ -214,16 +241,27 @@ impl AgentCatalogs { fn snapshot(&self, shared: &Shared, provider: &str, entry: &Entry) -> AgentModelCatalog { let catalog = entry.catalog.clone().unwrap_or_else(|| Self::fallback(shared, provider)); + let model_failure = entry.requested_model.as_ref().and_then(|model| entry.model_failures.get(model)); + let unknown_model = entry + .requested_model + .as_deref() + .is_some_and(|model| catalog.lists(model) && !catalog.thought_levels.contains_key(model)); AgentModelCatalog { provider: provider.to_owned(), config: shared.config_for_new_task(catalog.config, provider), thought_levels: catalog.thought_levels, refreshing: entry.flight.is_some(), refreshed_at_ms: catalog.refreshed_at_ms, - retry_at_ms: entry - .retry_at_ms - .filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)), - error: entry.error.clone(), + retry_at_ms: model_failure + .filter(|failure| self.now().duration_since(failure.completed) < COOLDOWN) + .map(|failure| failure.retry_at_ms) + .or_else(|| { + (!unknown_model) + .then_some(entry.retry_at_ms) + .flatten() + .filter(|_| entry.completed.is_some_and(|at| self.now().duration_since(at) < COOLDOWN)) + }), + error: model_failure.map(|failure| failure.error.clone()).or_else(|| entry.error.clone()), } } @@ -233,6 +271,7 @@ impl AgentCatalogs { shared: &Arc, spec: provider::ProviderSpec, force: bool, + model: Option<&str>, ) -> (AgentModelCatalog, Option>) { let key = Self::key(shared, &spec.id); let context = LaunchContext::new(spec.clone(), &shared.paths.project_root); @@ -264,6 +303,7 @@ impl AgentCatalogs { let mut catalog = saved.catalog; if !matching { catalog.refreshed_at_ms = None; + catalog.thought_levels.clear(); } catalog }); @@ -279,31 +319,73 @@ impl AgentCatalogs { error: None, flight: None, abort: None, + flight_model: None, + requested_model: None, + model_failures: HashMap::new(), }, ); } + let fallback = + state.entries.get(&key).filter(|entry| entry.catalog.is_none()).map(|_| Self::fallback(shared, &spec.id)); + state.generation += 1; + let generation = state.generation; let entry = state.entries.get_mut(&key).expect("catalog entry"); - let cooling = entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN); + let catalog = entry.catalog.as_ref().or(fallback.as_ref()).expect("cached catalog"); let fresh = entry.successful.is_some_and(|at| now.duration_since(at) < FRESH_FOR); + let target = model + .filter(|model| { + (catalog.lists(model) && !catalog.thought_levels.contains_key(*model)) + || (!fresh && catalog.model_option().is_none()) + }) + .map(str::to_owned); + if model.is_some() && entry.requested_model.as_deref() != model { + entry.requested_model = model.map(str::to_owned); + } + let superseded = model.is_some() + && entry.flight.is_some() + && (entry.flight_model.is_some() || target.is_some()) + && entry.flight_model.as_deref() != target.as_deref(); + if superseded { + if let Some(abort) = entry.abort.take() { + abort.abort(); + } + entry.flight = None; + entry.generation = generation; + entry.flight_model = None; + } + let cooling = match target.as_ref() { + Some(model) => entry.model_failures.get(model).is_some_and(|f| now.duration_since(f.completed) < COOLDOWN), + None => entry.completed.is_some_and(|at| now.duration_since(at) < COOLDOWN), + }; + let eligible = !cooling && (target.is_some() || force || !fresh); let mut start = None; - if entry.flight.is_none() && !cooling && (force || !fresh) { + if entry.flight.is_none() && eligible { let (done, ready) = watch::channel(false); entry.flight = Some(ready); + entry.flight_model = target.clone(); entry.error = None; + if let Some(model) = target.as_ref() { + entry.model_failures.remove(model); + } entry.retry_at_ms = None; - start = Some((entry.generation, done)); + // Every flight has its own generation, including superseded model selections. + entry.generation = generation; + start = Some((entry.generation, target, done)); } let snapshot = self.snapshot(shared, &spec.id, entry); let flight = entry.flight.clone(); drop(state); - if let Some((generation, done)) = start { + if superseded && start.is_none() { + self.broadcast(shared, &snapshot); + } + if let Some((generation, model, done)) = start { self.broadcast(shared, &snapshot); let coordinator = self.clone(); let shared = shared.clone(); let flight_key = key.clone(); let task = shared.runtime.clone().spawn(async move { - let result = discover(&shared, spec).await; - coordinator.complete(&shared, flight_key, generation, result); + let result = discover(&shared, spec, model.as_deref()).await; + coordinator.complete(&shared, flight_key, generation, model, result); let _ = done.send(true); }); // A subscriber can re-enter and change configuration during the start event. @@ -319,7 +401,14 @@ impl AgentCatalogs { (snapshot, flight) } - fn complete(&self, shared: &Shared, key: Key, generation: u64, result: Result) { + fn complete( + &self, + shared: &Shared, + key: Key, + generation: u64, + model: Option, + result: Result, + ) { let current = provider::load(shared.paths.custom_agents_dir.as_deref(), shared.env_secrets()) .into_iter() .find(|spec| spec.id == key.2) @@ -330,6 +419,7 @@ impl AgentCatalogs { if current.as_ref() != Some(&entry.context) { entry.flight = None; entry.abort = None; + entry.flight_model = None; entry.completed = None; entry.retry_at_ms = None; entry.error = None; @@ -340,12 +430,16 @@ impl AgentCatalogs { return; } let now = self.now(); - entry.completed = Some(now); - entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64); + if model.is_none() { + entry.completed = Some(now); + entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64); + } entry.flight = None; entry.abort = None; + entry.flight_model = None; let success = match result { Ok(found) => { + let previous = entry.catalog.take().unwrap_or_else(|| Self::fallback(shared, &key.2)); let mut cache = shared.known.lock(); let known = cache.entry(key.2.clone()).or_default(); let mut catalog = CatalogData { @@ -354,7 +448,7 @@ impl AgentCatalogs { refreshed_at_ms: Some(self.epoch_ms()), }; // Efforts sessions reported for models discovery doesn't read stay while listed. - for (model, levels) in entry.catalog.take().map(|old| old.thought_levels).unwrap_or_default() { + for (model, levels) in previous.thought_levels { if catalog.lists(&model) && !catalog.thought_levels.contains_key(&model) { catalog.thought_levels.insert(model, levels); } @@ -373,11 +467,30 @@ impl AgentCatalogs { entry.catalog = Some(catalog); shared.persist_known(&cache); entry.successful = Some(now); + entry.completed = Some(now); + entry.retry_at_ms = Some(self.epoch_ms() + COOLDOWN.as_millis() as f64); + entry.model_failures.retain(|model, _| { + entry + .catalog + .as_ref() + .is_some_and(|catalog| catalog.lists(model) && !catalog.thought_levels.contains_key(model)) + }); entry.error = None; true } Err(error) => { - entry.error = Some(error); + if let Some(model) = model { + entry.model_failures.insert( + model, + ModelFailure { + completed: now, + retry_at_ms: self.epoch_ms() + COOLDOWN.as_millis() as f64, + error, + }, + ); + } else { + entry.error = Some(error); + } false } }; @@ -448,18 +561,22 @@ impl AgentCatalogs { impl crate::AgentManager { /// Return cached choices immediately and schedule discovery when eligible. - pub fn refresh_models(&self, provider: &str, force: bool) -> IdeResult { + pub fn refresh_models(&self, provider: &str, force: bool, model: Option<&str>) -> IdeResult { // Settings and environment secrets can change while this window is open. *self.shared.providers.write() = provider::load(self.shared.paths.custom_agents_dir.as_deref(), self.shared.env_secrets()); let spec = self.shared.spec(provider).ok_or_else(|| IdeError::invalid(format!("unknown agent {provider}")))?; - Ok(self.shared.paths.catalogs.request(&self.shared, spec, force).0) + Ok(self.shared.paths.catalogs.request(&self.shared, spec, force, model).0) } } -async fn discover(shared: &Arc, spec: provider::ProviderSpec) -> Result { +async fn discover( + shared: &Arc, + spec: provider::ProviderSpec, + model: Option<&str>, +) -> Result { match spec.driver { - provider::Driver::Acp => acp::discover::run(shared, &spec).await, + provider::Driver::Acp => acp::discover::run(shared, &spec, model).await, provider::Driver::Codex => native::codex::discover(spec, shared.paths.project_root.clone()).await, provider::Driver::Claude => { let found = native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await?; @@ -484,7 +601,7 @@ async fn discover(shared: &Arc, spec: provider::ProviderSpec) -> Result< provider::Driver::Copilot => { if shared.uses_copilot_acp_fallback(&spec) { let acp_spec = native::copilot::acp_fallback_spec(&spec); - return acp::discover::run(shared, &acp_spec).await; + return acp::discover::run(shared, &acp_spec, model).await; } match native::copilot::discover(spec.clone(), shared.paths.project_root.clone()).await { Ok(found) => Ok(Discovered { @@ -513,7 +630,7 @@ async fn discover(shared: &Arc, spec: provider::ProviderSpec) -> Result< ); shared.mark_copilot_acp_fallback(&spec); let acp_spec = native::copilot::acp_fallback_spec(&spec); - acp::discover::run(shared, &acp_spec).await + acp::discover::run(shared, &acp_spec, model).await } Err(err) => Err(err.message), } diff --git a/crates/ide-agent/src/catalogs/tests.rs b/crates/ide-agent/src/catalogs/tests.rs index 7fc3e79f6..2f6105a41 100644 --- a/crates/ide-agent/src/catalogs/tests.rs +++ b/crates/ide-agent/src/catalogs/tests.rs @@ -11,8 +11,10 @@ const PROVIDER: &str = "catalog-test"; #[derive(Debug)] struct Pending { + method: String, params: Value, reply: oneshot::Sender>, + notifications: mpsc::UnboundedSender, } struct Harness { @@ -31,6 +33,10 @@ impl Drop for Live { impl Harness { fn new() -> Self { + Self::with_initialize(json!({ "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] })) + } + + fn with_initialize(initialize: Value) -> Self { let (pending_tx, pending) = mpsc::unbounded_channel(); let launches = Arc::new(AtomicUsize::new(0)); let live = Arc::new(AtomicUsize::new(0)); @@ -42,26 +48,53 @@ impl Harness { live.fetch_add(1, Ordering::SeqCst); let guard = Live(live.clone()); let pending = pending_tx.clone(); + let initialize = initialize.clone(); + let (notifications_tx, mut notifications) = mpsc::unbounded_channel::(); let (client_io, server_io) = tokio::io::duplex(1 << 16); let (read, mut write) = tokio::io::split(server_io); tokio::spawn(async move { let _guard = guard; let mut lines = BufReader::new(read).lines(); - while let Some(line) = lines.next_line().await.unwrap() { + loop { + let line = tokio::select! { + line = lines.next_line() => match line.unwrap() { + Some(line) => line, + None => break, + }, + Some(notification) = notifications.recv() => { + if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() { + break; + } + continue; + } + }; let request: Value = serde_json::from_str(&line).unwrap(); let id = &request["id"]; if id.is_null() { continue; } let response = match request["method"].as_str().unwrap() { - "initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": { - "protocolVersion": 1, "agentCapabilities": {}, "authMethods": [] } }), - "session/new" => { - let (reply, result) = oneshot::channel(); - pending.send(Pending { params: request["params"].clone(), reply }).unwrap(); - let result = tokio::select! { - result = result => result.unwrap(), - _ = lines.next_line() => break, + "initialize" => json!({ "id": id, "jsonrpc": "2.0", "result": initialize }), + "session/new" | "session/set_config_option" | "session/set_model" => { + let (reply, mut result) = oneshot::channel(); + pending + .send(Pending { + method: request["method"].as_str().unwrap().to_owned(), + params: request["params"].clone(), + reply, + notifications: notifications_tx.clone(), + }) + .unwrap(); + let result = loop { + tokio::select! { + result = &mut result => break result.unwrap(), + _ = lines.next_line() => return, + Some(notification) = notifications.recv() => { + if write.write_all(format!("{notification}\n").as_bytes()).await.is_err() { + return; + } + } + } }; match result { Ok(result) => json!({ "id": id, "jsonrpc": "2.0", "result": result }), @@ -190,7 +223,7 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_ let mut events = events(&manager); let old = config::options_of(&response(&["old", "retained"], &["low", "high"])); manager.shared.remember(PROVIDER, Some(&old), None, Some("old")); - let cached = manager.refresh_models(PROVIDER, false).unwrap(); + let cached = manager.refresh_models(PROVIDER, false, None).unwrap(); assert!(cached.refreshing); assert_eq!(model_values(&cached), ["old", "retained"]); assert!(cached.refreshed_at_ms.is_none(), "session reports are not fresh discovery"); @@ -204,13 +237,13 @@ async fn successful_refresh_replaces_models_and_efforts_and_old_sessions_cannot_ assert_eq!(fresh.thought_levels["retained"][0].values[0].value, "medium"); assert!(fresh.refreshed_at_ms.is_some() && fresh.retry_at_ms.is_some()); manager.shared.remember(PROVIDER, Some(&old), None, Some("old")); - assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config); + assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config); let provider = manager.providers().into_iter().find(|p| p.id == PROVIDER).unwrap(); assert_eq!(provider.config, fresh.config); let persisted = std::fs::read_to_string(tmp.path().join("models.json")).unwrap(); assert!(!persisted.contains("secret-one") && !persisted.contains("TOKEN")); let restored = make_manager(tmp.path(), Arc::default(), &harness); - let restored_snapshot = restored.refresh_models(PROVIDER, false).unwrap(); + let restored_snapshot = restored.refresh_models(PROVIDER, false, None).unwrap(); assert!(!restored_snapshot.refreshing, "matching persisted launch context remains fresh"); assert_eq!(restored_snapshot.refreshed_at_ms, fresh.refreshed_at_ms); let provider = restored.providers().into_iter().find(|p| p.id == PROVIDER).unwrap(); @@ -229,7 +262,7 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() { let catalogs = Arc::new(AgentCatalogs::default()); let manager = make_manager(tmp.path(), catalogs.clone(), &harness); let mut events = events(&manager); - manager.refresh_models(PROVIDER, false).unwrap(); + manager.refresh_models(PROVIDER, false, None).unwrap(); harness.next().await.reply.send(Ok(response(&["first", "second"], &["low", "high"]))).unwrap(); completed(&mut events).await; // A session on "second" reports its own efforts; one on a model the catalog lacks, or on @@ -241,16 +274,16 @@ async fn a_session_adds_the_efforts_of_a_model_discovery_did_not_read() { let efforts = |catalog: &AgentModelCatalog, model: &str| -> Vec { catalog.thought_levels[model][0].values.iter().map(|v| v.value.clone()).collect() }; - let catalog = manager.refresh_models(PROVIDER, false).unwrap(); + let catalog = manager.refresh_models(PROVIDER, false, None).unwrap(); assert_eq!(catalog.thought_levels.keys().map(String::as_str).collect::>(), ["first", "second"]); assert_eq!(efforts(&catalog, "first"), ["low", "high"]); assert_eq!(efforts(&catalog, "second"), ["off", "auto"]); - let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false).unwrap(); + let restored = make_manager(tmp.path(), Arc::default(), &harness).refresh_models(PROVIDER, false, None).unwrap(); assert_eq!(efforts(&restored, "second"), ["off", "auto"], "persisted with the project's catalog"); // Discovery again reads "first" only; "second" keeps what its session reported. advance(&catalogs, 60); while events.try_recv().is_ok() {} - manager.refresh_models(PROVIDER, true).unwrap(); + manager.refresh_models(PROVIDER, true, None).unwrap(); harness.next().await.reply.send(Ok(response(&["first", "second"], &["medium"]))).unwrap(); let fresh = completed(&mut events).await; assert_eq!(efforts(&fresh, "first"), ["medium"]); @@ -273,7 +306,7 @@ async fn legacy_cache_loads_without_claiming_authoritative_freshness() { let mut harness = Harness::new(); let manager = make_manager(tmp.path(), Arc::default(), &harness); let mut events = events(&manager); - let cached = manager.refresh_models(PROVIDER, false).unwrap(); + let cached = manager.refresh_models(PROVIDER, false, None).unwrap(); assert_eq!(model_values(&cached), ["legacy"]); assert!(cached.refreshing && cached.refreshed_at_ms.is_none()); harness.next().await.reply.send(Err("Sign in required".into())).unwrap(); @@ -292,11 +325,11 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co let second = make_manager(tmp.path(), catalogs.clone(), &harness); let mut first_events = events(&first); let mut second_events = events(&second); - assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing); let pending = harness.next().await; for _ in 0..10 { - assert!(second.refresh_models(PROVIDER, true).unwrap().refreshing); - assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing); + assert!(second.refresh_models(PROVIDER, true, None).unwrap().refreshing); + assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing); } let commands = tokio::spawn({ let first = first.clone(); @@ -309,21 +342,21 @@ async fn concurrent_windows_commands_and_manual_requests_share_one_flight_and_co assert_eq!(completed(&mut second_events).await, done); commands.await.unwrap().unwrap(); for force in [false, true, false, true] { - assert!(!second.refresh_models(PROVIDER, force).unwrap().refreshing); + assert!(!second.refresh_models(PROVIDER, force, None).unwrap().refreshing); } advance(&catalogs, 29); - assert!(!first.refresh_models(PROVIDER, true).unwrap().refreshing); + assert!(!first.refresh_models(PROVIDER, true, None).unwrap().refreshing); advance(&catalogs, 1); - assert!(!first.refresh_models(PROVIDER, false).unwrap().refreshing, "automatic refresh remains fresh"); - assert!(first.refresh_models(PROVIDER, true).unwrap().refreshing); + assert!(!first.refresh_models(PROVIDER, false, None).unwrap().refreshing, "automatic refresh remains fresh"); + assert!(first.refresh_models(PROVIDER, true, None).unwrap().refreshing); harness.next().await.reply.send(Ok(response(&["two"], &["high"]))).unwrap(); let newer = completed(&mut first_events).await; assert_eq!(model_values(&newer), ["two"]); assert_eq!(completed(&mut second_events).await, newer); advance(&catalogs, 15 * 60 - 1); - assert!(!second.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(!second.refresh_models(PROVIDER, false, None).unwrap().refreshing); advance(&catalogs, 1); - assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing); harness.next().await.reply.send(Ok(response(&["three"], &["low"]))).unwrap(); completed(&mut first_events).await; assert_eq!(harness.launches.load(Ordering::SeqCst), 3); @@ -337,25 +370,25 @@ async fn failure_keeps_successful_choices_and_throttles_manual_and_auto_retries( let mut harness = Harness::new(); let manager = make_manager(tmp.path(), catalogs.clone(), &harness); let mut events = events(&manager); - manager.refresh_models(PROVIDER, true).unwrap(); + manager.refresh_models(PROVIDER, true, None).unwrap(); harness.next().await.reply.send(Ok(response(&["cached"], &["low"]))).unwrap(); let success = completed(&mut events).await; let disk = std::fs::read(tmp.path().join("models.json")).unwrap(); advance(&catalogs, 15 * 60); - manager.refresh_models(PROVIDER, false).unwrap(); + manager.refresh_models(PROVIDER, false, None).unwrap(); harness.next().await.reply.send(Err("Authentication expired".into())).unwrap(); let failed = completed(&mut events).await; assert_eq!(failed.config, success.config); assert_eq!(failed.thought_levels, success.thought_levels); assert_eq!(failed.refreshed_at_ms, success.refreshed_at_ms); - assert!(failed.error.as_deref().unwrap().contains("Authentication expired")); + assert!(failed.error.as_deref().unwrap().contains("Sign in required")); assert_eq!(std::fs::read(tmp.path().join("models.json")).unwrap(), disk); - assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing); - assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing); + assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing); + assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing); advance(&catalogs, 29); - assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing); + assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing); advance(&catalogs, 1); - assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing); harness.next().await.reply.send(Ok(response(&["recovered"], &["high"]))).unwrap(); let recovered = completed(&mut events).await; assert_eq!(model_values(&recovered), ["recovered"]); @@ -370,21 +403,21 @@ async fn timeout_cleans_up_and_enters_the_same_failure_cooldown() { let mut harness = Harness::new(); let manager = make_manager(tmp.path(), catalogs.clone(), &harness); let mut events = events(&manager); - manager.refresh_models(PROVIDER, false).unwrap(); + manager.refresh_models(PROVIDER, false, None).unwrap(); let pending = harness.next().await; tokio::time::pause(); tokio::time::advance(Duration::from_secs(4)).await; let failed = completed(&mut events).await; assert!(failed.error.as_deref().unwrap().contains("time")); assert!(failed.retry_at_ms.is_some()); - assert!(!manager.refresh_models(PROVIDER, true).unwrap().refreshing); - assert!(!manager.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(!manager.refresh_models(PROVIDER, true, None).unwrap().refreshing); + assert!(!manager.refresh_models(PROVIDER, false, None).unwrap().refreshing); tokio::time::resume(); stopped(&harness).await; assert_eq!(harness.live.load(Ordering::SeqCst), 0, "timed-out connection must close"); assert!(pending.reply.is_closed()); advance(&catalogs, 30); - assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing); harness.next().await.reply.send(Ok(response(&["retry"], &["low"]))).unwrap(); completed(&mut events).await; } @@ -398,16 +431,16 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() { let first = make_manager(tmp.path(), catalogs.clone(), &harness); let second = make_manager(tmp.path(), catalogs.clone(), &harness); let mut events = events(&second); - first.refresh_models(PROVIDER, false).unwrap(); + first.refresh_models(PROVIDER, false, None).unwrap(); let obsolete = harness.next().await; configure(tmp.path(), "two"); - assert!(second.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(second.refresh_models(PROVIDER, false, None).unwrap().refreshing); let latest = harness.next().await; latest.reply.send(Ok(response(&["latest"], &["high"]))).unwrap(); let fresh = completed(&mut events).await; let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))); stopped(&harness).await; - let shown = first.refresh_models(PROVIDER, false).unwrap(); + let shown = first.refresh_models(PROVIDER, false, None).unwrap(); assert_eq!(shown.config, fresh.config); assert_eq!(shown.refreshed_at_ms, fresh.refreshed_at_ms); assert!(!shown.refreshing); @@ -415,7 +448,7 @@ async fn changed_effective_config_supersedes_old_completion_without_queueing() { assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete")); // A changed configuration also invalidates successful freshness/cooldown. configure(tmp.path(), "three"); - assert!(first.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(first.refresh_models(PROVIDER, false, None).unwrap().refreshing); harness.next().await.reply.send(Ok(response(&["new-config"], &["medium"]))).unwrap(); completed(&mut events).await; } @@ -425,7 +458,7 @@ async fn invalid_provider_is_a_request_error_and_does_not_launch() { let tmp = tempfile::tempdir().unwrap(); let harness = Harness::new(); let manager = make_manager(tmp.path(), Arc::default(), &harness); - assert!(manager.refresh_models("missing-provider", true).is_err()); + assert!(manager.refresh_models("missing-provider", true, None).is_err()); assert_eq!(harness.launches.load(Ordering::SeqCst), 0); } @@ -437,18 +470,18 @@ async fn replacing_the_executable_at_the_same_path_invalidates_freshness_and_obs let mut harness = Harness::new(); let manager = make_manager(tmp.path(), catalogs, &harness); let mut events = events(&manager); - manager.refresh_models(PROVIDER, false).unwrap(); + manager.refresh_models(PROVIDER, false, None).unwrap(); let obsolete = harness.next().await; std::fs::write(tmp.path().join("catalog-test-bin"), "replacement executable with different size").unwrap(); - manager.refresh_models(PROVIDER, false).unwrap(); + manager.refresh_models(PROVIDER, false, None).unwrap(); let latest = harness.next().await; latest.reply.send(Ok(response(&["updated"], &["high"]))).unwrap(); let fresh = completed(&mut events).await; let _ = obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))); stopped(&harness).await; - assert_eq!(manager.refresh_models(PROVIDER, false).unwrap().config, fresh.config); + assert_eq!(manager.refresh_models(PROVIDER, false, None).unwrap().config, fresh.config); std::fs::write(tmp.path().join("catalog-test-bin"), "another executable").unwrap(); - assert!(manager.refresh_models(PROVIDER, false).unwrap().refreshing); + assert!(manager.refresh_models(PROVIDER, false, None).unwrap().refreshing); harness.next().await.reply.send(Ok(response(&["new-install"], &["medium"]))).unwrap(); assert_eq!(model_values(&completed(&mut events).await), ["new-install"]); assert_eq!(harness.launches.load(Ordering::SeqCst), 3); @@ -468,18 +501,18 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts() let second = make_manager_at(&b, &models_file, catalogs, &harness); let mut first_events = events(&first); let mut second_events = events(&second); - first.refresh_models(PROVIDER, false).unwrap(); + first.refresh_models(PROVIDER, false, None).unwrap(); harness.next().await.reply.send(Ok(response(&["account-a-model"], &["low"]))).unwrap(); let a_catalog = completed(&mut first_events).await; - second.refresh_models(PROVIDER, false).unwrap(); + second.refresh_models(PROVIDER, false, None).unwrap(); harness.next().await.reply.send(Ok(response(&["account-b-model"], &["high"]))).unwrap(); let b_catalog = completed(&mut second_events).await; - assert_eq!(first.refresh_models(PROVIDER, false).unwrap().config, a_catalog.config); - assert_eq!(second.refresh_models(PROVIDER, false).unwrap().config, b_catalog.config); + assert_eq!(first.refresh_models(PROVIDER, false, None).unwrap().config, a_catalog.config); + assert_eq!(second.refresh_models(PROVIDER, false, None).unwrap().config, b_catalog.config); assert_eq!(first.providers().into_iter().find(|p| p.id == PROVIDER).unwrap().config, a_catalog.config); for (root, expected) in [(&a, &a_catalog), (&b, &b_catalog)] { let restored = make_manager_at(root, &models_file, Arc::default(), &harness); - let cached = restored.refresh_models(PROVIDER, false).unwrap(); + let cached = restored.refresh_models(PROVIDER, false, None).unwrap(); assert!(!cached.refreshing, "matching persisted context should retain freshness"); assert_eq!(cached.config, expected.config); assert_eq!(cached.refreshed_at_ms, expected.refreshed_at_ms); @@ -488,7 +521,7 @@ async fn project_catalogs_and_persisted_freshness_do_not_leak_between_contexts() configure(&a, "new-account"); let changed = make_manager_at(&a, &models_file, Arc::default(), &harness); let mut events = events(&changed); - let stale = changed.refresh_models(PROVIDER, false).unwrap(); + let stale = changed.refresh_models(PROVIDER, false, None).unwrap(); assert!(stale.refreshing, "a different launch environment cannot reuse persisted freshness"); assert!(stale.refreshed_at_ms.is_none()); assert_eq!(stale.config, a_catalog.config, "stale cached choices remain selectable"); @@ -505,7 +538,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove let mut harness = Harness::new(); let manager = make_manager(tmp.path(), Arc::default(), &harness); let mut events = events(&manager); - manager.refresh_models(PROVIDER, false).unwrap(); + manager.refresh_models(PROVIDER, false, None).unwrap(); let obsolete = harness.next().await; configure(tmp.path(), "after"); obsolete.reply.send(Ok(response(&["obsolete"], &["low"]))).unwrap(); @@ -513,7 +546,7 @@ async fn configuration_changed_without_another_request_also_discards_old_discove assert!(model_values(&discarded).is_empty()); assert!(discarded.refreshed_at_ms.is_none()); assert!(!tmp.path().join("models.json").exists()); - manager.refresh_models(PROVIDER, false).unwrap(); + manager.refresh_models(PROVIDER, false, None).unwrap(); harness.next().await.reply.send(Ok(response(&["current"], &["high"]))).unwrap(); assert_eq!(model_values(&completed(&mut events).await), ["current"]); } @@ -526,13 +559,269 @@ async fn successful_empty_catalog_removes_all_previous_models_and_efforts() { let mut harness = Harness::new(); let manager = make_manager(tmp.path(), catalogs.clone(), &harness); let mut events = events(&manager); - manager.refresh_models(PROVIDER, true).unwrap(); + manager.refresh_models(PROVIDER, true, None).unwrap(); harness.next().await.reply.send(Ok(response(&["removed"], &["low"]))).unwrap(); completed(&mut events).await; advance(&catalogs, 30); - manager.refresh_models(PROVIDER, true).unwrap(); + manager.refresh_models(PROVIDER, true, None).unwrap(); harness.next().await.reply.send(Ok(response(&[], &[]))).unwrap(); let empty = completed(&mut events).await; assert!(model_values(&empty).is_empty() && empty.thought_levels.is_empty()); assert!(empty.refreshed_at_ms.is_some() && empty.error.is_none()); } + +fn selected_response(model: &str, effort: &[&str]) -> Value { + let mut result = response(&[model], effort); + if effort.is_empty() { + result["configOptions"].as_array_mut().unwrap().retain(|option| option["id"] != "effort"); + } + result +} + +fn config_notification(session: &str, result: &Value) -> Value { + json!({ "jsonrpc": "2.0", "method": "session/update", "params": { + "sessionId": session, + "update": { "sessionUpdate": "config_option_update", "configOptions": result["configOptions"] } + } }) +} + +fn efforts<'a>(catalog: &'a AgentModelCatalog, model: &str) -> Vec<&'a str> { + catalog.thought_levels[model] + .iter() + .filter(|option| option.category.as_deref() == Some("thought_level")) + .flat_map(|option| option.values.iter().map(|value| value.value.as_str())) + .collect() +} + +#[tokio::test] +async fn selected_models_report_their_own_controls_before_any_task_or_prompt() { + let tmp = tempfile::tempdir().unwrap(); + configure(tmp.path(), "one"); + let catalogs = Arc::new(AgentCatalogs::default()); + let mut harness = Harness::new(); + let manager = make_manager(tmp.path(), catalogs.clone(), &harness); + let mut events = events(&manager); + manager.refresh_models(PROVIDER, false, None).unwrap(); + let models = ["default", "second", "plain", "unknown"]; + harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap(); + let original = completed(&mut events).await; + assert!(!original.thought_levels.contains_key("second")); + + // A fresh catalog and its global cooldown must not delay an unknown selection. + assert!(manager.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing); + harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap(); + let pending = harness.next().await; + assert_eq!(pending.method, "session/set_config_option"); + assert_eq!(pending.params, json!({ "sessionId": "discovery-only", "configId": "model", "value": "second" })); + let mut second = selected_response("second", &["off", "auto", "max"]); + second["configOptions"].as_array_mut().unwrap().push(json!({ + "id": "context_tier", "type": "select", "currentValue": "large", + "options": [{ "value": "normal" }, { "value": "large" }] + })); + pending.reply.send(Ok(second)).unwrap(); + let learned = completed(&mut events).await; + assert_eq!(learned.config, original.config, "selection discovery never changes the default model"); + assert_eq!(efforts(&learned, "default"), ["low", "high"]); + assert_eq!(efforts(&learned, "second"), ["off", "auto", "max"]); + assert!(learned.thought_levels["second"].iter().any(|option| option.id == "context_tier")); + assert!(!learned.thought_levels.contains_key("unknown")); + + manager.refresh_models(PROVIDER, false, Some("plain")).unwrap(); + harness.next().await.reply.send(Ok(response(&models, &["low", "high"]))).unwrap(); + harness.next().await.reply.send(Ok(selected_response("plain", &[]))).unwrap(); + let plain = completed(&mut events).await; + assert!(plain.thought_levels["plain"].is_empty(), "an authoritative no-control result is cached"); + for model in ["default", "second", "plain"] { + assert!(!manager.refresh_models(PROVIDER, false, Some(model)).unwrap().refreshing); + } + let restored = make_manager(tmp.path(), Arc::default(), &harness); + let cached = restored.refresh_models(PROVIDER, false, Some("plain")).unwrap(); + assert!(!cached.refreshing); + assert!(cached.thought_levels["plain"].is_empty()); + assert_eq!(efforts(&cached, "second"), ["off", "auto", "max"]); + assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "never iterate unselected models"); + assert!(!tmp.path().join("store").exists(), "no task or prompt is needed"); +} + +#[tokio::test] +async fn missing_or_failed_selected_settings_remain_unknown_and_have_model_scoped_retry_cooldowns() { + for reply in [Ok(json!({})), Ok(selected_response("default", &["wrong"])), Err("token=secret-one".into())] { + let tmp = tempfile::tempdir().unwrap(); + configure(tmp.path(), "one"); + let catalogs = Arc::new(AgentCatalogs::default()); + let mut harness = Harness::new(); + let manager = make_manager(tmp.path(), catalogs.clone(), &harness); + let mut events = events(&manager); + let models = ["default", "unsupported", "other"]; + manager.refresh_models(PROVIDER, false, None).unwrap(); + harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap(); + let original = completed(&mut events).await; + manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap(); + harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap(); + harness.next().await.reply.send(reply).unwrap(); + let failed = completed(&mut events).await; + assert_eq!(failed.config, original.config); + assert!(!failed.thought_levels.contains_key("unsupported")); + assert!(failed.error.is_some() && failed.retry_at_ms.is_some()); + assert!(!failed.error.as_deref().unwrap().contains("secret-one")); + assert!(!manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing); + // The failed model cannot block another model, and its cooldown survives that success. + assert!(manager.refresh_models(PROVIDER, false, Some("other")).unwrap().refreshing); + harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap(); + harness.next().await.reply.send(Ok(selected_response("other", &[]))).unwrap(); + assert!(completed(&mut events).await.error.is_none()); + assert!(!manager.refresh_models(PROVIDER, false, Some("unsupported")).unwrap().refreshing); + advance(&catalogs, 30); + assert!(manager.refresh_models(PROVIDER, true, Some("unsupported")).unwrap().refreshing); + harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap(); + harness.next().await.reply.send(Ok(selected_response("unsupported", &["high"]))).unwrap(); + let retried = completed(&mut events).await; + assert_eq!(efforts(&retried, "unsupported"), ["high"]); + assert!(retried.error.is_none()); + } +} + +#[tokio::test] +async fn rapid_model_selections_share_the_current_flight_and_discard_superseded_results() { + let tmp = tempfile::tempdir().unwrap(); + configure(tmp.path(), "one"); + let catalogs = Arc::new(AgentCatalogs::default()); + let mut harness = Harness::new(); + let first = make_manager(tmp.path(), catalogs.clone(), &harness); + let second = make_manager(tmp.path(), catalogs.clone(), &harness); + let mut events = events(&first); + let models = ["default", "second", "third"]; + first.refresh_models(PROVIDER, false, None).unwrap(); + harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap(); + completed(&mut events).await; + first.refresh_models(PROVIDER, false, Some("second")).unwrap(); + harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap(); + let obsolete = harness.next().await; + for _ in 0..5 { + assert!(second.refresh_models(PROVIDER, false, Some("second")).unwrap().refreshing); + } + assert_eq!(harness.launches.load(Ordering::SeqCst), 2); + second.refresh_models(PROVIDER, false, Some("third")).unwrap(); + harness.next().await.reply.send(Ok(response(&models, &["low"]))).unwrap(); + let current = harness.next().await; + assert_eq!(current.params["value"], "third"); + current.reply.send(Ok(selected_response("third", &["max"]))).unwrap(); + let fresh = completed(&mut events).await; + let _ = obsolete.reply.send(Ok(selected_response("second", &["obsolete"]))); + stopped(&harness).await; + let cached = first.refresh_models(PROVIDER, false, Some("third")).unwrap(); + assert_eq!(cached, fresh); + assert_eq!(efforts(&cached, "third"), ["max"]); + assert!(!cached.thought_levels.contains_key("second")); + assert_eq!(harness.launches.load(Ordering::SeqCst), 3, "no stale requests are queued"); + assert!(!std::fs::read_to_string(tmp.path().join("models.json")).unwrap().contains("obsolete")); +} + +#[tokio::test] +async fn switching_back_to_a_known_model_cancels_the_unknown_model_flight() { + let tmp = tempfile::tempdir().unwrap(); + configure(tmp.path(), "one"); + let mut harness = Harness::new(); + let manager = make_manager(tmp.path(), Arc::default(), &harness); + let mut events = events(&manager); + manager.refresh_models(PROVIDER, false, None).unwrap(); + harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap(); + completed(&mut events).await; + manager.refresh_models(PROVIDER, false, Some("second")).unwrap(); + let obsolete = harness.next().await; + let known = manager.refresh_models(PROVIDER, false, Some("default")).unwrap(); + assert!(!known.refreshing); + assert_eq!(completed(&mut events).await, known, "other subscribers also leave loading state"); + let _ = obsolete.reply.send(Err("late failure".into())); + stopped(&harness).await; + let cached = manager.refresh_models(PROVIDER, false, Some("default")).unwrap(); + assert!(cached.error.is_none() && !cached.thought_levels.contains_key("second")); + assert_eq!(harness.launches.load(Ordering::SeqCst), 2); +} + +#[tokio::test] +async fn selected_model_uses_legacy_set_model_and_authoritative_notifications() { + let tmp = tempfile::tempdir().unwrap(); + configure(tmp.path(), "one"); + let mut harness = Harness::new(); + let manager = make_manager(tmp.path(), Arc::default(), &harness); + let mut events = events(&manager); + // No cache is needed: the selected model is resolved in the same short-lived session. + manager.refresh_models(PROVIDER, false, Some("second")).unwrap(); + harness + .next() + .await + .reply + .send(Ok(json!({ + "sessionId": "discovery-only", + "models": { "currentModelId": "default", "availableModels": [ + { "modelId": "default", "name": "Default" }, { "modelId": "second", "name": "Second" } + ] } + }))) + .unwrap(); + let selected = harness.next().await; + assert_eq!(selected.method, "session/set_model"); + assert_eq!(selected.params, json!({ "sessionId": "discovery-only", "modelId": "second" })); + let notifications = selected.notifications; + selected.reply.send(Ok(json!({}))).unwrap(); + notifications.send(config_notification("different-session", &selected_response("second", &["wrong"]))).unwrap(); + notifications + .send(config_notification("discovery-only", &selected_response("second", &["medium", "high"]))) + .unwrap(); + let catalog = completed(&mut events).await; + assert_eq!(efforts(&catalog, "second"), ["medium", "high"]); + assert_eq!(catalog.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("default")); + assert!(!catalog.thought_levels.contains_key("default"), "legacy model lists alone do not assert no controls"); +} + +#[tokio::test] +async fn catalog_replacement_removes_selected_metadata_for_models_no_longer_listed() { + let tmp = tempfile::tempdir().unwrap(); + configure(tmp.path(), "one"); + let catalogs = Arc::new(AgentCatalogs::default()); + let mut harness = Harness::new(); + let manager = make_manager(tmp.path(), catalogs.clone(), &harness); + let mut events = events(&manager); + manager.refresh_models(PROVIDER, false, Some("second")).unwrap(); + harness.next().await.reply.send(Ok(response(&["default", "second"], &["low"]))).unwrap(); + harness.next().await.reply.send(Ok(selected_response("second", &["max"]))).unwrap(); + completed(&mut events).await; + advance(&catalogs, 30); + manager.refresh_models(PROVIDER, true, None).unwrap(); + harness.next().await.reply.send(Ok(response(&["default", "new"], &["medium"]))).unwrap(); + let replaced = completed(&mut events).await; + assert_eq!(model_values(&replaced), ["default", "new"]); + assert_eq!(efforts(&replaced, "default"), ["medium"]); + assert!(!replaced.thought_levels.contains_key("second") && !replaced.thought_levels.contains_key("new")); +} + +#[tokio::test] +async fn selected_model_discovery_uses_the_negotiated_v2_wire_format_and_config_updates() { + let tmp = tempfile::tempdir().unwrap(); + configure(tmp.path(), "one"); + let mut harness = Harness::with_initialize(json!({ + "protocolVersion": 2, "info": { "name": "V2 Catalog Test" }, "capabilities": { "session": {} } + })); + let manager = make_manager(tmp.path(), Arc::default(), &harness); + let mut events = events(&manager); + manager.refresh_models(PROVIDER, false, Some("second")).unwrap(); + let mut initial = response(&["default", "second"], &["low"]); + for option in initial["configOptions"].as_array_mut().unwrap() { + option["configId"] = option.as_object_mut().unwrap().remove("id").unwrap(); + } + harness.next().await.reply.send(Ok(initial)).unwrap(); + let selected = harness.next().await; + assert_eq!(selected.method, "session/set_config_option"); + assert_eq!( + selected.params, + json!({ + "sessionId": "discovery-only", "configId": "model", "value": "second", "type": "id" + }) + ); + // Notifications may arrive before the request response as well as after it. + selected.notifications.send(config_notification("discovery-only", &selected_response("second", &[]))).unwrap(); + selected.reply.send(Ok(json!({}))).unwrap(); + let catalog = completed(&mut events).await; + assert!(catalog.thought_levels["second"].is_empty()); + assert_eq!(efforts(&catalog, "default"), ["low"]); +} diff --git a/crates/ide-agent/src/lib.rs b/crates/ide-agent/src/lib.rs index 2f9b1c2fc..78ab95026 100644 --- a/crates/ide-agent/src/lib.rs +++ b/crates/ide-agent/src/lib.rs @@ -363,6 +363,7 @@ struct TaskState { session_id: Option, conversation: Conversation, wanted: Vec, + model_choice: u64, before: Arc>, saved: Option, /// See `TaskFile::touched`. @@ -621,7 +622,7 @@ impl AgentManager { .into_iter() .find(|spec| spec.id == provider) { - let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false); + let (_, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, None); if let Some(mut ready) = flight { while !*ready.borrow_and_update() { if ready.changed().await.is_err() { @@ -954,19 +955,36 @@ impl AgentManager { /// Changes a session setting (model, mode…): right away when the agent runs, else when it next starts. pub async fn set_config(&self, id: &str, option: &str, value: String) -> IdeResult<()> { let task = self.task(id)?; - let target = { - let s = task.state.lock(); - let o = - s.task.config.iter().find(|o| o.id == option).ok_or_else(|| IdeError::not_found("no such setting"))?; - if !o.values.iter().any(|v| v.value == value) { - return Err(IdeError::invalid(format!("{} has no value {value}", o.name))); + let (target, model_choice, previous_levels) = { + let mut s = task.state.lock(); + let target = s + .task + .config + .iter() + .find(|o| o.id == option) + .ok_or_else(|| IdeError::not_found("no such setting"))? + .clone(); + if !target.values.iter().any(|v| v.value == value) { + return Err(IdeError::invalid(format!("{} has no value {value}", target.name))); } - o.clone() + if target.category.as_deref() == Some("model") { + s.model_choice += 1; + } + let previous_levels = + if target.category.as_deref() == Some("model") && target.current.as_deref() != Some(value.as_str()) { + Some(s.task.config.extract_if(.., |o| config::is_per_model_option(o)).collect::>()) + } else { + None + }; + s.wanted.retain(|c| c.id != option); + s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.clone() }); + s.task.config.iter_mut().find(|o| o.id == option).expect("selected setting").current = Some(value.clone()); + s.task.model = model_of(&s.task.config).or(s.task.model.take()); + (target, s.model_choice, previous_levels) }; let previous = target.current.clone(); // Cursor's `session/set_config_option` (Fast, effort) can take seconds. Show the // choice first so the switch and slider move immediately. - apply_config_choice(&task, option, &value); task.persist(); task.emit_task(); @@ -976,36 +994,77 @@ impl AgentManager { let mut model_options = (target.category.as_deref() != Some("model") || previous.as_deref() == Some(value.as_str())) && task.state.lock().task.config.iter().any(config::is_per_model_option); + if live.is_none() + && target.category.as_deref() == Some("model") + && (previous.as_deref() != Some(value.as_str()) || !model_options) + { + let provider = task.state.lock().task.provider.clone(); + let mut levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value); + let mut error = None; + if levels.is_none() + && let Some(spec) = self.shared.spec(&provider) + { + let (catalog, flight) = self.shared.paths.catalogs.request(&self.shared, spec, false, Some(&value)); + error = catalog.error; + if let Some(mut ready) = flight { + while !*ready.borrow_and_update() { + if ready.changed().await.is_err() { + break; + } + } + } + levels = self.shared.paths.catalogs.levels(&self.shared, &provider, &value); + } + // Another selection may have superseded this discovery while it was waiting. + if task.state.lock().model_choice != model_choice { + return Ok(()); + } + let Some(levels) = levels else { + restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels); + task.persist(); + task.emit_task(); + return Err(IdeError::unavailable( + error.unwrap_or_else(|| "The agent did not report settings for the selected model".into()), + )); + }; + let mut s = task.state.lock(); + if s.model_choice != model_choice { + return Ok(()); + } + s.task.config.retain(|o| !config::is_per_model_option(o)); + s.task.config.extend(levels); + model_options = true; + } if let Some(live) = live.filter(|_| option != config::CURSOR_APPROVAL) { let (method, mut params) = config::set_request(&target, &value); params["sessionId"] = json!(live.session); let reply: Value = match live.peer.request(method, params, None).await { Ok(reply) => reply, Err(e) => { - { - let mut s = task.state.lock(); - s.wanted.retain(|c| c.id != option); - if let Some(prev) = previous.clone() { - s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: prev }); - } - if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) { - o.current = previous.clone(); - } - s.task.model = model_of(&s.task.config).or(s.task.model.take()); - } + restore_config_choice(&task, &target, &value, previous.as_deref(), model_choice, previous_levels); task.persist(); task.emit_task(); return Err(IdeError::internal(task.describe(e))); } }; + if target.category.as_deref() == Some("model") && task.state.lock().model_choice != model_choice { + return Ok(()); + } if let Some(options) = reply.get("configOptions") { config::merge_update(&mut task.state.lock().task.config, options); model_options = true; + } else if target.category.as_deref() == Some("model") { + // Old model controls were removed above, so these came from an update + // that preceded the response. + model_options = task.state.lock().task.config.iter().any(config::is_per_model_option); } } { let mut s = task.state.lock(); - if !model_options { + if target.category.as_deref() == Some("model") && s.model_choice != model_choice { + return Ok(()); + } + if !model_options && target.category.as_deref() == Some("model") { s.task.config.retain(|o| !config::is_per_model_option(o)); } if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) { @@ -1583,6 +1642,7 @@ impl Task { session_id: file.session_id, conversation, wanted: file.wanted, + model_choice: 0, before: Arc::new(file.before), saved: file.saved, touched: file.touched.map(Arc::new), @@ -3093,12 +3153,32 @@ fn retry_of(update: &Value, now: f64) -> Option { }) } -fn apply_config_choice(task: &Task, option: &str, value: &str) { +fn restore_config_choice( + task: &Task, + target: &AgentConfigOption, + value: &str, + previous: Option<&str>, + model_choice: u64, + previous_levels: Option>, +) { + let option = target.id.as_str(); + let is_model = target.category.as_deref() == Some("model"); let mut s = task.state.lock(); + if (is_model && s.model_choice != model_choice) + || !s.task.config.iter().any(|o| o.id == option && o.current.as_deref() == Some(value)) + { + return; + } s.wanted.retain(|c| c.id != option); - s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: value.to_owned() }); + if let Some(previous) = previous { + s.wanted.push(AgentConfigChoice { id: option.to_owned(), value: previous.to_owned() }); + } if let Some(o) = s.task.config.iter_mut().find(|o| o.id == option) { - o.current = Some(value.to_owned()); + o.current = previous.map(str::to_owned); + } + if let Some(levels) = previous_levels { + s.task.config.retain(|o| !config::is_per_model_option(o)); + s.task.config.extend(levels); } s.task.model = model_of(&s.task.config).or(s.task.model.take()); } diff --git a/crates/ide-agent/src/tests.rs b/crates/ide-agent/src/tests.rs index 898bdc3cd..8e376e84a 100644 --- a/crates/ide-agent/src/tests.rs +++ b/crates/ide-agent/src/tests.rs @@ -51,6 +51,7 @@ struct FakeAgent { /// Config options `session/new` reports after the model one (per-model efforts, say). extra_options: Mutex>, model_options: Mutex>>, + model_config_gate: Mutex>>, /// Advertises steering as OMP does (`_meta.steering` at the top of `initialize`) /// instead of `_meta.openidea.steer`. session_steering: bool, @@ -231,6 +232,12 @@ impl Handler for FakeAgent { std::thread::sleep(self.delay_config); } self.calls.lock().push(format!("{method} {}", params.get("value").or(params.get("modeId")).unwrap())); + if params["configId"] == "model" { + let gate = self.model_config_gate.lock().take(); + if let Some(gate) = gate { + gate.recv().unwrap(); + } + } if params["configId"] == "model" && !self.model_options.lock().is_empty() { return Ok(json!({"configOptions": self.options_for(params["value"].as_str().unwrap())})); } @@ -590,6 +597,7 @@ for line in sys.stdin: assert_eq!(names, ["compact", "clear", "model", "context", "triage"]); assert_eq!(first[0].hint.as_deref(), Some("[instructions]")); let restored = manager(root, Arc::new(FakeAgent::default())); + restored.set_builtin_command("claude", Some(script.to_string_lossy().into_owned())).unwrap(); assert_eq!(first, restored.commands("claude", None).await.unwrap()); // The same handshake lists the models, so the composer has them before any task. for mgr in [&mgr, &restored] { @@ -1931,8 +1939,7 @@ async fn thinking_levels_are_remembered_per_provider_and_model() { #[tokio::test(flavor = "multi_thread")] async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() { - // After a model switch no session reported, picking that model again or changing - // another setting must not record the task's effort-less copy as the model's levels. + // Idle selections use cached model controls or discover them before the next prompt. for (option, value) in [("mode", "code"), ("model", "big")] { let tmp = tempfile::tempdir().unwrap(); let agent = Arc::new(FakeAgent::default()); @@ -1945,7 +1952,7 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() { .create(NewAgentTask { project_root: None, prompt: text("again"), - provider: "claude".into(), + provider: "claude-acp".into(), config: vec![], isolation: Isolation::Local, base: None, @@ -1957,18 +1964,165 @@ async fn changing_an_idle_tasks_settings_keeps_its_models_effort_levels() { mgr.shutdown(); let restored = manager(tmp.path(), agent); restored.set_config(&task.id, "model", "small".into()).await.unwrap(); + { + let small = restored.task(&task.id).unwrap(); + let small = small.state.lock(); + let effort = small.task.config.iter().find(|option| option.id == "effort").unwrap(); + assert_eq!( + effort.values.iter().map(|value| value.value.as_str()).collect::>(), + ["minimal", "medium"] + ); + } restored.set_config(&task.id, "model", "big".into()).await.unwrap(); restored.set_config(&task.id, option, value.into()).await.unwrap(); - let p = restored.providers().into_iter().find(|p| p.id == "claude").unwrap(); + let p = restored.providers().into_iter().find(|p| p.id == "claude-acp").unwrap(); let big = p.thought_levels.get("big").and_then(|levels| levels.first()); assert_eq!(big.map(|o| o.values.len()), Some(2), "{option}: {:?}", p.thought_levels); let saved: HashMap = serde_json::from_slice(&std::fs::read(&restored.shared.paths.models_file).unwrap()).unwrap(); - assert_eq!(saved["claude"].thought_levels, p.thought_levels, "{option}"); + assert_eq!(saved["claude-acp"].thought_levels, p.thought_levels, "{option}"); restored.shutdown(); } } +#[tokio::test(flavor = "multi_thread")] +async fn idle_model_switches_discover_controls_and_no_control_models_without_another_prompt() { + let tmp = tempfile::tempdir().unwrap(); + let agent = Arc::new(FakeAgent::default()); + *agent.model_options.lock() = HashMap::from([ + ("big".into(), effort_options(&["low", "high"], "high")), + ("small".into(), effort_options(&["minimal", "medium"], "minimal")), + ("plain".into(), vec![]), + ]); + let mgr = manager(tmp.path(), agent.clone()); + let task = mgr + .create(NewAgentTask { + prompt: text("again"), + provider: "claude-acp".into(), + isolation: Isolation::Local, + ..Default::default() + }) + .await + .unwrap(); + wait_for(&mgr, &task.id, AgentStatus::Ready).await; + mgr.shutdown(); + let restored = manager(tmp.path(), agent.clone()); + assert!( + !restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small") + ); + agent.calls.lock().clear(); + restored.set_config(&task.id, "model", "small".into()).await.unwrap(); + let current = restored.task(&task.id).unwrap(); + let config = current.state.lock().task.config.clone(); + let effort = config.iter().find(|option| option.id == "effort").unwrap(); + assert_eq!(effort.values.iter().map(|value| value.value.as_str()).collect::>(), ["minimal", "medium"]); + restored.set_config(&task.id, "effort", "medium".into()).await.unwrap(); + restored.set_config(&task.id, "model", "plain".into()).await.unwrap(); + assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option)); + let known = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp"); + assert!(known.thought_levels["plain"].is_empty()); + assert_eq!(known.config.iter().find(|option| option.id == "model").unwrap().current.as_deref(), Some("big")); + { + let mut calls = agent.calls.lock(); + assert!(!calls.iter().any(|call| call == "session/prompt" || call == "session/load")); + assert_eq!(calls.iter().filter(|call| *call == "session/new").count(), 2); + calls.clear(); + } + restored.set_config(&task.id, "model", "small".into()).await.unwrap(); + assert!(agent.calls.lock().is_empty(), "a known model remains a cache-only selection"); + assert!(current.live.lock().is_none(), "discovery never mutates a task's live session"); + restored.shutdown(); +} + +#[tokio::test(flavor = "multi_thread")] +async fn idle_model_discovery_failure_restores_the_previous_choice_without_claiming_no_controls() { + let tmp = tempfile::tempdir().unwrap(); + let agent = Arc::new(FakeAgent::default()); + *agent.extra_options.lock() = effort_options(&["low", "high"], "low"); + let mgr = manager(tmp.path(), agent.clone()); + let task = mgr + .create(NewAgentTask { + prompt: text("again"), + provider: "claude-acp".into(), + isolation: Isolation::Local, + ..Default::default() + }) + .await + .unwrap(); + wait_for(&mgr, &task.id, AgentStatus::Ready).await; + mgr.shutdown(); + let restored = manager(tmp.path(), agent.clone()); + agent.calls.lock().clear(); + assert!(restored.set_config(&task.id, "model", "small".into()).await.is_err()); + let current = restored.task(&task.id).unwrap(); + assert_eq!(current.state.lock().task.model.as_deref(), Some("big")); + assert!(current.state.lock().task.config.iter().any(|option| option.id == "effort")); + assert!( + !restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp").thought_levels.contains_key("small") + ); + assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt")); + restored.shutdown(); +} + +#[tokio::test(flavor = "multi_thread")] +async fn rapid_idle_model_switches_share_discovery_and_never_apply_a_stale_completion() { + let tmp = tempfile::tempdir().unwrap(); + let agent = Arc::new(FakeAgent::default()); + *agent.model_options.lock() = HashMap::from([ + ("big".into(), effort_options(&["low", "high"], "high")), + ("small".into(), effort_options(&["minimal", "medium"], "minimal")), + ("plain".into(), vec![]), + ]); + let mgr = manager(tmp.path(), agent.clone()); + let task = mgr + .create(NewAgentTask { + prompt: text("again"), + provider: "claude-acp".into(), + isolation: Isolation::Local, + ..Default::default() + }) + .await + .unwrap(); + wait_for(&mgr, &task.id, AgentStatus::Ready).await; + mgr.shutdown(); + let restored = Arc::new(manager(tmp.path(), agent.clone())); + agent.calls.lock().clear(); + let (release, gate) = std::sync::mpsc::channel(); + *agent.model_config_gate.lock() = Some(gate); + let first = tokio::spawn({ + let restored = restored.clone(); + let id = task.id.clone(); + async move { restored.set_config(&id, "model", "small".into()).await } + }); + tokio::time::timeout(Duration::from_secs(5), async { + while agent.model_config_gate.lock().is_some() { + tokio::task::yield_now().await; + } + }) + .await + .unwrap(); + let duplicate = restored.set_config(&task.id, "model", "small".into()); + tokio::pin!(duplicate); + tokio::select! { + biased; + result = &mut duplicate => panic!("duplicate selection must join the pending discovery: {result:?}"), + _ = tokio::task::yield_now() => {} + } + restored.set_config(&task.id, "model", "plain".into()).await.unwrap(); + release.send(()).unwrap(); + first.await.unwrap().unwrap(); + duplicate.await.unwrap(); + let current = restored.task(&task.id).unwrap(); + assert_eq!(current.state.lock().task.model.as_deref(), Some("plain")); + assert!(!current.state.lock().task.config.iter().any(config::is_per_model_option)); + let catalog = restored.shared.paths.catalogs.cached(&restored.shared, "claude-acp"); + assert!(catalog.thought_levels["plain"].is_empty()); + assert!(!catalog.thought_levels.contains_key("small"), "obsolete discovery cannot populate model settings"); + assert_eq!(agent.calls.lock().iter().filter(|call| *call == "session/new").count(), 2); + assert!(!agent.calls.lock().iter().any(|call| call == "session/prompt")); + restored.shutdown(); +} + #[tokio::test(flavor = "multi_thread")] async fn upfront_effort_is_validated_after_changing_model_before_the_prompt() { for (effort, applied) in [("medium", true), ("high", false)] { diff --git a/crates/ide-host/src/ops/agent.rs b/crates/ide-host/src/ops/agent.rs index 4c51145ee..83a1fc8c0 100644 --- a/crates/ide-host/src/ops/agent.rs +++ b/crates/ide-host/src/ops/agent.rs @@ -30,9 +30,15 @@ pub fn providers(host: &Host, window: &str) -> IdeResult> { } /// Refreshes the selected agent's model catalog without sending a prompt. -pub fn refresh_models(host: &Host, window: &str, provider: String, force: bool) -> IdeResult { +pub fn refresh_models( + host: &Host, + window: &str, + provider: String, + force: bool, + model: Option, +) -> IdeResult { host.require_trust(window)?; - host.project(window)?.agents.refresh_models(&provider, force) + host.project(window)?.agents.refresh_models(&provider, force, model.as_deref()) } /// Overrides built-in agent `id`'s command with `command` (its agent file keeps the @@ -832,7 +838,7 @@ pub(crate) fn register(d: &mut Dispatcher) { d.add("agent_subscribe", |c| async move { subscribe(&c.host, &c.window, c.channel("onEvent")?) }); d.add("agent_providers", |c| async move { providers(&c.host, &c.window) }); d.add("agent_refresh_models", |c| async move { - refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?) + refresh_models(&c.host, &c.window, c.arg("provider")?, c.arg("force")?, c.arg("model")?) }); d.add("agent_set_command", |c| async move { set_command(&c.host, &c.window, c.arg("id")?, c.arg("command")?) }); d.add("agent_set_env", |c| async move { set_env(&c.host, &c.window, c.arg("id")?, c.arg("env")?) }); diff --git a/crates/ide-host/tests/agent_model_refresh.rs b/crates/ide-host/tests/agent_model_refresh.rs index ed7afa2e4..0eee45aa4 100644 --- a/crates/ide-host/tests/agent_model_refresh.rs +++ b/crates/ide-host/tests/agent_model_refresh.rs @@ -68,7 +68,7 @@ done } for _ in 0..20 { for window in ["first", "second"] { - let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap(); + let state = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap(); assert!(state.refreshing); } } @@ -87,7 +87,7 @@ done assert!(completed.is_ok(), "both windows must receive the completed catalog"); for _ in 0..20 { for window in ["first", "second"] { - let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true).unwrap(); + let catalog = ops::agent::refresh_models(&host, window, "catalog-test".into(), true, None).unwrap(); assert!(!catalog.refreshing); assert!(catalog.retry_at_ms.is_some()); let models = catalog.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap(); diff --git a/docs/en/guide/agents.mdx b/docs/en/guide/agents.mdx index 4bd8c8149..34fbf45cb 100644 --- a/docs/en/guide/agents.mdx +++ b/docs/en/guide/agents.mdx @@ -54,7 +54,9 @@ Codex keeps its own project trust decision. If it disables the current project's Choose the agent, and its model, mode and other options when it offers them. Cached models appear immediately; the selected agent's catalog refreshes in the background when it is more than 15 minutes old, without sending a prompt or attaching project MCP servers. - After changing the agent CLI or account, open the model picker and choose **Refresh models**. Refreshes share one lookup and have a 30-second cooldown after completion, including failures. Cached choices remain usable while refreshing or after a failure. + Model-specific effort levels and context options are looked up when you select a model whose settings are not cached, even before its first task. **Loading model settings…** appears beside the model during this short-lived lookup; no prompt is sent and existing tasks are not changed. Each model keeps its own choices, and models that report no effort control do not borrow another model's levels. + + After changing the agent CLI or account, open the model picker and choose **Refresh models**. Refreshes share one lookup and have a 30-second cooldown after completion, including failures. Selecting an uncached model's settings does not wait for another model's cooldown. Cached choices remain usable while refreshing or after a failure; use **Refresh models** to retry a failed lookup after its cooldown. Available models depend on the installed agent and account. If a selected model is removed, choose another before starting. Refreshing does not change running tasks. diff --git a/docs/zh/guide/agents.mdx b/docs/zh/guide/agents.mdx index 79a4809ef..a5e739a73 100644 --- a/docs/zh/guide/agents.mdx +++ b/docs/zh/guide/agents.mdx @@ -54,7 +54,9 @@ Codex 有自己的项目信任设置。如果它禁用了当前项目的 `.codex 选择 agent,以及它提供的模型、模式等选项。缓存的模型会立即显示;所选 agent 的模型列表超过 15 分钟未更新时,会在后台刷新,不发送提示词,也不接入项目 MCP 服务器。 - 更改 agent CLI 或账号后,打开模型选择器并单击 **刷新模型**。并发刷新会共用一次查询;每次查询完成后(包括失败)都有 30 秒冷却时间。刷新中或刷新失败后,缓存选项仍可使用。 + 选择尚未缓存设置的模型时,会按需查询该模型的思考强度和上下文选项,无需先运行任务。短暂查询期间,模型旁会显示**正在加载模型设置…**;查询不发送提示词,也不更改现有任务。每个模型分别保留你选择的设置;明确不提供思考强度的模型不会沿用其他模型的强度选项。 + + 更改 agent CLI 或账号后,打开模型选择器并单击 **刷新模型**。并发刷新会共用一次查询;每次查询完成后(包括失败)都有 30 秒冷却时间。查询其他未缓存模型的设置无需等待前一个模型的冷却时间。刷新中或刷新失败后,缓存选项仍可使用;查询失败后,可在冷却结束后用**刷新模型**重试。 可用模型取决于已安装的 agent 和账号。如果已选模型被移除,需要先选择其他模型才能开始任务。刷新不会更改正在运行的任务。 diff --git a/e2e/agentCycleEffort.spec.ts b/e2e/agentCycleEffort.spec.ts index ce0f1be13..c6fbea0c3 100644 --- a/e2e/agentCycleEffort.spec.ts +++ b/e2e/agentCycleEffort.spec.ts @@ -533,3 +533,69 @@ for (const setting of ["effort", "model"] as const) { await page.evaluate(() => document.dispatchEvent(new Event("release-config"))); }); } + +test("New Task discovers uncached model effort before the first prompt", async ({ workbench: page }, testInfo) => { + await seed(page, "editor", "new"); + await expect + .poll(() => + page.evaluate(async () => { + // The store must be loaded in the page's Vite realm, not Playwright's Node process. + const storePath = "/src/features/agents/store.ts"; + const { useAgents } = await import(storePath); + return useAgents.getState().modelRequests.size; + }), + ) + .toBe(0); + await page.evaluate( + async ({ provider, swift }) => { + // Static Node imports cannot update the browser workbench's store. + const storePath = "/src/features/agents/store.ts"; + const { useAgents } = await import(storePath); + const thoughtLevels = { ...provider.thoughtLevels }; + delete thoughtLevels.swift; + const cached = { ...provider, thoughtLevels }; + window.__ipc.handlers.agent_providers = () => [cached]; + window.__ipc.handlers.agent_refresh_models = async ({ model }) => { + if (model === "swift") { + const { promise, resolve } = Promise.withResolvers(); + document.addEventListener("test:model-settings-ready", () => resolve(), { once: true }); + await promise; + thoughtLevels.swift = [swift]; + } + return { + provider: cached.id, + config: cached.config, + thoughtLevels: { ...thoughtLevels }, + refreshing: false, + refreshedAtMs: Date.now(), + retryAtMs: null, + error: null, + }; + }; + useAgents.setState({ providers: [cached], modelCatalogs: new Map() }); + }, + { provider, swift }, + ); + await expectEffort(page, "Gentle"); + await box(page).fill("Keep this first task unsent"); + await chooseModel(page, "Swift"); + try { + await expect + .poll(async () => (await ipcCalls(page, "agent_refresh_models")).filter((call) => call.model === "swift")) + .toEqual([{ provider: provider.id, force: false, model: "swift" }]); + await expect(page.getByRole("status").filter({ hasText: "Loading model settings…" })).toBeVisible(); + await expect(effortButton(page)).toHaveCount(0); + await page.screenshot({ path: testInfo.outputPath("model-settings-loading.png") }); + await page.evaluate(() => document.dispatchEvent(new Event("test:model-settings-ready"))); + await expectEffort(page, "Quick"); + await effortButton(page).click(); + await expect(page.getByRole("option", { name: "Quick", exact: true })).toBeVisible(); + await expect(page.getByRole("option", { name: "Thorough", exact: true })).toBeVisible(); + await expect(page.getByRole("option", { name: "Gentle", exact: true })).toHaveCount(0); + await expect(box(page)).toHaveText("Keep this first task unsent"); + await expectNoSubmission(page); + expect(await ipcCalls(page, "agent_set_config")).toEqual([]); + } finally { + await page.screenshot({ path: testInfo.outputPath("uncached-model-effort.png") }); + } +}); diff --git a/src-tauri/src/commands/agent.rs b/src-tauri/src/commands/agent.rs index 5a3fc5504..e0b4ec967 100644 --- a/src-tauri/src/commands/agent.rs +++ b/src-tauri/src/commands/agent.rs @@ -46,8 +46,9 @@ pub fn agent_refresh_models( state: State<'_, AppState>, provider: String, force: bool, + model: Option, ) -> IdeResult { - agent::refresh_models(&state.host, window.label(), provider, force) + agent::refresh_models(&state.host, window.label(), provider, force, model) } /// Overrides built-in agent `id`'s command with `command` (its agent file keeps the diff --git a/src/bindings.ts b/src/bindings.ts index f6e3c1185..463624f32 100644 --- a/src/bindings.ts +++ b/src/bindings.ts @@ -148,7 +148,7 @@ export const commands = { agentSubscribe: (onEvent: Channel) => typedError(__TAURI_INVOKE("agent_subscribe", { onEvent })), agentProviders: () => typedError(__TAURI_INVOKE("agent_providers")), /** Refreshes the model catalog; force bypasses freshness, not the cooldown. */ - agentRefreshModels: (provider: string, force: boolean) => typedError(__TAURI_INVOKE("agent_refresh_models", { provider, force })), + agentRefreshModels: (provider: string, force: boolean, model: string | null) => typedError(__TAURI_INVOKE("agent_refresh_models", { provider, force, model })), /** * Overrides built-in agent `id`'s command with `command` (its agent file keeps the * built-in's driver and arguments), or returns it to auto-detection with `None`. diff --git a/src/features/agents/ConfigPickers.tsx b/src/features/agents/ConfigPickers.tsx index 82fbb519b..bc034e8cc 100644 --- a/src/features/agents/ConfigPickers.tsx +++ b/src/features/agents/ConfigPickers.tsx @@ -72,6 +72,7 @@ const selected = (option: AgentConfigOption, value: string | null) => interface ModelRefresh { refreshing: boolean; + loadingSettings?: boolean; retryAtMs: number | null; error: string | null; onRefresh: () => void; @@ -151,6 +152,11 @@ export function ConfigPickers({ ) : ( )} + {o === model && modelRefresh?.loadingSettings && ( + + Loading model settings… + + )} ))} {secondary.length > 0 && ( diff --git a/src/features/agents/HomeEditor.tsx b/src/features/agents/HomeEditor.tsx index 5f286123c..68069dc2e 100644 --- a/src/features/agents/HomeEditor.tsx +++ b/src/features/agents/HomeEditor.tsx @@ -92,16 +92,47 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input? const probe = useProbe(provider?.installed ? provider.id : null, provider?.command, shown); const catalog = useAgents((s) => s.modelCatalogs.get(provider?.id ?? "")); const requestingModels = useAgents((s) => s.modelRequests.has(provider?.id ?? "")); + const requestTarget = useAgents((s) => s.modelRequestTargets.get(provider?.id ?? "")); + const { defaults, fitWindowWidth } = useAgentSettings(); + const config = draftConfig(provider, draft, (provider && defaults[provider.id]) || {}); + const model = config.find((o) => o.category === "model"); + const selectedModel = model?.current ?? null; + const selectedModelRef = useRef(selectedModel); + useEffect(() => { + selectedModelRef.current = selectedModel; + }, [selectedModel]); + const attemptedModels = useRef(new Set()); const launch = provider && JSON.stringify([provider.program, provider.args, provider.env, provider.command]); useEffect(() => { if (!provider?.installed) return; - const refresh = () => void refreshModels(provider.id, false); + const refresh = () => void refreshModels(provider.id, false, selectedModelRef.current); refresh(); window.addEventListener("focus", refresh); return () => window.removeEventListener("focus", refresh); }, [provider?.id, provider?.installed, launch, project?.root]); - const { defaults, fitWindowWidth } = useAgentSettings(); - const config = draftConfig(provider, draft, (provider && defaults[provider.id]) || {}); + const unknownModelSettings = + !!selectedModel && + !!model?.values.some((v) => v.value === selectedModel) && + !Object.hasOwn((catalog ?? provider)?.thoughtLevels ?? {}, selectedModel); + useEffect(() => { + if (!provider?.installed || !selectedModel || !unknownModelSettings) return; + const key = JSON.stringify([provider.id, launch, project?.root, selectedModel]); + if (requestTarget === selectedModel) attemptedModels.current.add(key); + if (requestingModels || catalog?.refreshing || attemptedModels.current.has(key)) return; + attemptedModels.current.add(key); + void refreshModels(provider.id, false, selectedModel); + }, [ + provider?.id, + provider?.installed, + launch, + project?.root, + selectedModel, + unknownModelSettings, + requestingModels, + catalog, + requestTarget, + ]); + const currentModelRequest = requestTarget === undefined || requestTarget === selectedModel; const homeRoot = useRef(null); const { zoomStyle } = useAgentFontZoomSurface(homeRoot, input?.key ?? HOME_KEY, docked); const unavailableModel = config.some( @@ -194,8 +225,12 @@ export function HomeEditor({ docked = false, input }: { docked?: boolean; input? provider?.installed ? { refreshing: requestingModels || (catalog?.refreshing ?? false), - retryAtMs: catalog?.retryAtMs ?? null, - error: catalog?.error ?? null, + loadingSettings: unknownModelSettings && (requestingModels || (catalog?.refreshing ?? false)), + retryAtMs: + currentModelRequest || (!unknownModelSettings && !catalog?.error) + ? (catalog?.retryAtMs ?? null) + : null, + error: !requestingModels && currentModelRequest ? (catalog?.error ?? null) : null, onRefresh: () => void executeAction("agents.refreshModels"), } : undefined diff --git a/src/features/agents/modelRefresh.test.tsx b/src/features/agents/modelRefresh.test.tsx index 5a81de972..2c7afd08e 100644 --- a/src/features/agents/modelRefresh.test.tsx +++ b/src/features/agents/modelRefresh.test.tsx @@ -39,7 +39,8 @@ vi.mock("@/platform/ipc", async (original) => ({ return ok([]); }, agentProviders: async () => ok(backend.providers), - agentRefreshModels: (provider: string, force: boolean) => backend.refresh(provider, force), + agentRefreshModels: (provider: string, force: boolean, model: string | null) => + backend.refresh(provider, force, model), agentProbe: async () => ok(null), agentCommands: async () => ok([]), vcsBranchInfo: async () => ok({ head: "main" }), @@ -85,7 +86,7 @@ const provider = (id: string): AgentProvider => ({ commands: [], source: { kind: "custom" }, config: [option("model", "model", ["big", "small"])], - thoughtLevels: { big: [option("effort", "thought_level", ["low", "high"], "high")] }, + thoughtLevels: { big: [option("effort", "thought_level", ["low", "high"], "high")], small: [] }, }); function catalog(id = "first", patch: Partial = {}): AgentModelCatalog { const offered = backend.providers.find((p) => p.id === id)!; @@ -155,6 +156,8 @@ it("keeps cached choices usable while refreshing and shares the completion/coold fireEvent.click(screen.getByRole("button", { name: "Model" })); expect(screen.getByRole("button", { name: /Refresh in \d+s/ })).toBeDisabled(); expect(screen.getByRole("button", { name: "Model" })).toHaveTextContent("small"); + await act(async () => executeAction("agents.refreshModels")); + expect(backend.refresh).toHaveBeenCalledTimes(1); fireEvent.click(screen.getByRole("button", { name: "Start" })); await waitFor(() => expect(backend.create).toHaveBeenCalled()); expect(backend.create.mock.calls[0]![0].config).toEqual([{ id: "model", value: "small" }]); @@ -166,7 +169,7 @@ it("uses the same popup for model-only agents and coalesces repeated manual acti render(); fireEvent.click(screen.getByRole("button", { name: "Model" })); await screen.findByRole("button", { name: "Refresh models" }); - expect(backend.refresh).toHaveBeenCalledExactlyOnceWith("first", false); + expect(backend.refresh).toHaveBeenCalledExactlyOnceWith("first", false, "big"); const pending = deferred(); backend.refresh.mockReturnValueOnce(pending.promise); fireEvent.click(screen.getByRole("button", { name: "Refresh models" })); @@ -176,7 +179,7 @@ it("uses the same popup for model-only agents and coalesces repeated manual acti await executeAction("agents.refreshModels"); }); expect(backend.refresh).toHaveBeenCalledTimes(2); - expect(backend.refresh).toHaveBeenLastCalledWith("first", true); + expect(backend.refresh).toHaveBeenLastCalledWith("first", true, "big"); await act(async () => pending.resolve(ok(catalog("first", { refreshing: true })))); await act(async () => executeAction("agents.refreshModels")); expect(backend.refresh).toHaveBeenCalledTimes(2); @@ -201,7 +204,7 @@ it("shows initial loading and inline discovery failure/retry without blocking a expect(screen.getByText("No models reported by this agent.")).toBeVisible(); expect(screen.getByRole("button", { name: "Refresh models" })).toBeEnabled(); fireEvent.click(screen.getByRole("button", { name: "Refresh models" })); - expect(backend.refresh).toHaveBeenLastCalledWith("first", true); + expect(backend.refresh).toHaveBeenLastCalledWith("first", true, null); expect(screen.getByRole("button", { name: "Refreshing…" })).toBeDisabled(); fireEvent.click(screen.getByRole("button", { name: "Start" })); await waitFor(() => expect(backend.create).toHaveBeenCalled()); @@ -290,7 +293,7 @@ it("ignores a delayed refresh after switching agents and preserves the new draft render(); fireEvent.click(screen.getByRole("button", { name: "Agent" })); fireEvent.click(screen.getByRole("option", { name: "second" })); - await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("second", false)); + await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("second", false, "big")); fireEvent.click(screen.getByRole("button", { name: "Model" })); fireEvent.click(screen.getByRole("option", { name: "small" })); await act(async () => pending.resolve(ok(catalog("first", { config: [option("model", "model", ["obsolete"])] })))); @@ -321,7 +324,7 @@ it("does not let a delayed command snapshot replace a newer catalog event", asyn const pending = deferred(); backend.refresh.mockReturnValueOnce(pending.promise); render(); - emit(catalog("first", { config: [option("model", "model", ["latest"])] })); + emit(catalog("first", { config: [option("model", "model", ["latest"])], thoughtLevels: { latest: [] } })); await act(async () => pending.resolve(ok(catalog("first", { refreshing: true })))); fireEvent.click(screen.getByRole("button", { name: "Model" })); expect(screen.getByRole("option", { name: "latest" })).toBeVisible(); @@ -349,3 +352,157 @@ it("requests freshness on focus without a retry timer, and counts down only the act(() => vi.advanceTimersByTime(60_000)); expect(backend.refresh).toHaveBeenCalledTimes(2); }); + +it("discovers an uncached model's own settings before its first task and restores its draft choices", async () => { + delete backend.providers[0]!.thoughtLevels!.small; + await connect(); + render(); + await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0)); + const pending = deferred(); + backend.refresh.mockReturnValueOnce(pending.promise); + fireEvent.click(screen.getByRole("button", { name: "Model" })); + fireEvent.click(screen.getByRole("option", { name: "small" })); + await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("first", false, "small")); + expect(screen.getByText("Loading model settings…")).toHaveAttribute("role", "status"); + expect(screen.queryByRole("button", { name: "Reasoning" })).not.toBeInTheDocument(); + expect(backend.create).not.toHaveBeenCalled(); + await act(async () => + pending.resolve( + ok( + catalog("first", { + thoughtLevels: { + ...catalog().thoughtLevels, + small: [ + option("effort", "thought_level", ["minimal", "medium", "max"], "medium"), + option("context_tier", "model_config", ["default", "long_context"]), + ], + }, + }), + ), + ), + ); + expect(screen.queryByText("Loading model settings…")).not.toBeInTheDocument(); + expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("medium"); + fireEvent.click(screen.getByRole("button", { name: "Reasoning" })); + fireEvent.click(screen.getByRole("option", { name: "max" })); + fireEvent.click(screen.getByRole("button", { name: "Model" })); + expect(screen.getByRole("radio", { name: "long_context" })).toBeVisible(); + fireEvent.click(screen.getByRole("radio", { name: "long_context" })); + fireEvent.click(screen.getByRole("option", { name: "big" })); + expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("high"); + fireEvent.click(screen.getByRole("button", { name: "Model" })); + fireEvent.click(screen.getByRole("option", { name: "small" })); + expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("max"); + expect(backend.refresh).toHaveBeenCalledTimes(2); + fireEvent.click(screen.getByRole("button", { name: "Start" })); + await waitFor(() => expect(backend.create).toHaveBeenCalled()); + expect(backend.create.mock.calls[0]![0].config).toEqual([ + { id: "model", value: "small" }, + { id: "effort", value: "max" }, + { id: "context_tier", value: "long_context" }, + ]); +}); + +it("does not rediscover a model that explicitly reports no per-model controls", async () => { + backend.providers[0]!.thoughtLevels!.small = []; + await connect(); + render(); + await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0)); + for (const model of ["small", "big", "small"]) { + fireEvent.click(screen.getByRole("button", { name: "Model" })); + fireEvent.click(screen.getByRole("option", { name: model })); + } + expect(backend.refresh).toHaveBeenCalledExactlyOnceWith("first", false, "big"); + expect(screen.queryByText("Loading model settings…")).not.toBeInTheDocument(); + expect(screen.queryByRole("button", { name: "Reasoning" })).not.toBeInTheDocument(); +}); + +it("waits for an unrelated lookup and discovers only the latest selected model", async () => { + backend.providers[0]!.config = [option("model", "model", ["big", "small", "latest"])]; + await connect(); + const pending = deferred(); + backend.refresh.mockReturnValueOnce(pending.promise); + render(); + for (const model of ["small", "latest"]) { + fireEvent.click(screen.getByRole("button", { name: "Model" })); + fireEvent.click(screen.getByRole("option", { name: model })); + } + expect(backend.refresh).toHaveBeenCalledTimes(1); + const latest = deferred(); + backend.refresh.mockReturnValueOnce(latest.promise); + await act(async () => + pending.resolve(ok(catalog("first", { retryAtMs: Date.now() + 30_000, error: "previous model failed" }))), + ); + await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("first", false, "latest")); + fireEvent.click(screen.getByRole("button", { name: "Model" })); + expect(screen.queryByRole("alert")).not.toBeInTheDocument(); + fireEvent.keyDown(document, { key: "Escape" }); + await act(async () => + latest.resolve( + ok(catalog("first", { thoughtLevels: { latest: [option("effort", "thought_level", ["medium", "max"])] } })), + ), + ); + expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("medium"); + expect(backend.refresh).toHaveBeenCalledTimes(2); + expect(backend.create).not.toHaveBeenCalled(); +}); + +it("does not loop after an unknown-model failure and permits a manual retry after cooldown", async () => { + delete backend.providers[0]!.thoughtLevels!.small; + await connect(); + render(); + await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0)); + backend.refresh.mockResolvedValueOnce( + ok(catalog("first", { retryAtMs: Date.now() + 30_000, error: "settings unavailable" })), + ); + fireEvent.click(screen.getByRole("button", { name: "Model" })); + fireEvent.click(screen.getByRole("option", { name: "small" })); + await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0)); + expect(backend.refresh).toHaveBeenCalledTimes(2); + fireEvent.click(screen.getByRole("button", { name: "Model" })); + expect(screen.getByRole("alert")).toHaveTextContent("settings unavailable"); + expect(screen.getByRole("button", { name: /Refresh in \d+s/ })).toBeDisabled(); + emit(catalog("first", { retryAtMs: Date.now() - 1, error: "settings unavailable" })); + expect(backend.refresh).toHaveBeenCalledTimes(2); + backend.refresh.mockResolvedValueOnce(ok(catalog("first", { thoughtLevels: { small: [] } }))); + fireEvent.click(screen.getByRole("button", { name: "Refresh models" })); + await waitFor(() => expect(backend.refresh).toHaveBeenLastCalledWith("first", true, "small")); + await waitFor(() => expect(screen.queryByRole("alert")).not.toBeInTheDocument()); + expect(backend.refresh).toHaveBeenCalledTimes(3); +}); + +it("does not leak a delayed model's levels or failure into a newer selection", async () => { + delete backend.providers[0]!.thoughtLevels!.small; + await connect(); + useAgents.setState({ + draft: savedDraft({ provider: "first", config: { model: "big" }, thoughtLevels: { big: { effort: "low" } } }), + }); + render(); + await waitFor(() => expect(useAgents.getState().modelRequests.size).toBe(0)); + const pending = deferred(); + backend.refresh.mockReturnValueOnce(pending.promise); + for (const model of ["small", "big"]) { + fireEvent.click(screen.getByRole("button", { name: "Model" })); + fireEvent.click(screen.getByRole("option", { name: model })); + } + await act(async () => + pending.resolve( + ok( + catalog("first", { + thoughtLevels: { + ...catalog().thoughtLevels, + small: [option("effort", "thought_level", ["minimal", "max"], "max")], + }, + retryAtMs: Date.now() + 30_000, + error: "small lookup failed", + }), + ), + ), + ); + expect(screen.getByRole("button", { name: "Model" })).toHaveTextContent("big"); + expect(screen.getByRole("button", { name: "Reasoning" })).toHaveTextContent("low"); + fireEvent.click(screen.getByRole("button", { name: "Model" })); + expect(screen.queryByRole("alert")).not.toBeInTheDocument(); + expect(screen.getByRole("button", { name: "Refresh models" })).toBeEnabled(); + expect(backend.refresh).toHaveBeenCalledTimes(2); +}); diff --git a/src/features/agents/store.ts b/src/features/agents/store.ts index fc8e76366..b2490493c 100644 --- a/src/features/agents/store.ts +++ b/src/features/agents/store.ts @@ -102,6 +102,8 @@ interface AgentsState { providers: AgentProvider[]; modelCatalogs: Map; modelRequests: Set; + /** Last New Task discovery target, so another model never inherits its error/cooldown. */ + modelRequestTargets: Map; /** The usage limits each agent last reported for its account, by provider. */ limits: Map; draft: Draft; @@ -187,6 +189,7 @@ export const useAgents = create(() => ({ limits: new Map(), modelCatalogs: new Map(), modelRequests: new Set(), + modelRequestTargets: new Map(), draft: savedDraft(load>(DRAFT_KEY, {})), composers: new Map(), lastComposer: HOME, @@ -391,18 +394,29 @@ function applyModelCatalog(catalog: AgentModelCatalog) { } /** Refreshes only the New Task agent; discovery failures stay beside the cached choices. */ -export async function refreshModels(provider = selectedProvider()?.id, force = true): Promise { +export async function refreshModels( + provider = selectedProvider()?.id, + force = true, + model?: string | null, +): Promise { const selected = selectedProvider(); if (!provider || !selected?.installed || selected.id !== provider || useProject.getState().project?.trusted === false) return; const state = useAgents.getState(); const catalog = state.modelCatalogs.get(provider); + model ??= draftConfig(selected, state.draft).find((o) => o.category === "model")?.current ?? null; + const missingModelSettings = + model !== null && !Object.hasOwn(catalog?.thoughtLevels ?? selected.thoughtLevels ?? {}, model); + const requestTarget = state.modelRequestTargets.get(provider); const launch = launchKey(selected); const pending = modelFlights.get(provider); if ( (pending?.launch === launch && pending.generation === generation && pending.draftGeneration === draftGeneration) || catalog?.refreshing || - (force && catalog?.retryAtMs != null && catalog.retryAtMs > Date.now()) + (force && + (requestTarget === undefined || requestTarget === model || (!missingModelSettings && !catalog?.error)) && + catalog?.retryAtMs != null && + catalog.retryAtMs > Date.now()) ) return; const gen = generation; @@ -410,7 +424,10 @@ export async function refreshModels(provider = selectedProvider()?.id, force = t const root = useProject.getState().project?.root; const flight = { launch, generation: gen, draftGeneration: draftGen }; modelFlights.set(provider, flight); - useAgents.setState((s) => ({ modelRequests: new Set(s.modelRequests).add(provider) })); + useAgents.setState((s) => ({ + modelRequests: new Set(s.modelRequests).add(provider), + modelRequestTargets: new Map(s.modelRequestTargets).set(provider, model), + })); const current = () => gen === generation && root === useProject.getState().project?.root && @@ -418,7 +435,7 @@ export async function refreshModels(provider = selectedProvider()?.id, force = t selectedProvider()?.id === provider && launchKey(selectedProvider()!) === launch; try { - const result = await call(commands.agentRefreshModels(provider, force)); + const result = await call(commands.agentRefreshModels(provider, force, model)); // A streamed status/completion is newer than the snapshot returned by the command. if (current() && useAgents.getState().modelCatalogs.get(provider) === catalog) applyModelCatalog(result); } catch (e) { @@ -545,6 +562,7 @@ export function disconnect() { groupedChanges: new Map(), modelCatalogs: new Map(), modelRequests: new Set(), + modelRequestTargets: new Map(), organize: EMPTY_ORGANIZE, organizeRoot: null, docked: null, @@ -785,12 +803,16 @@ export async function refreshProviders() { if (!providers || gen !== generation || root !== useProject.getState().project?.root) return; useAgents.setState((s) => { const modelCatalogs = new Map(s.modelCatalogs); + const modelRequestTargets = new Map(s.modelRequestTargets); for (const [id] of modelCatalogs) { const previous = s.providers.find((p) => p.id === id); const provider = providers.find((p) => p.id === id); - if (!provider || (previous && launchKey(previous) !== launchKey(provider))) modelCatalogs.delete(id); + if (!provider || (previous && launchKey(previous) !== launchKey(provider))) { + modelCatalogs.delete(id); + modelRequestTargets.delete(id); + } } - return { providers, modelCatalogs }; + return { providers, modelCatalogs, modelRequestTargets }; }); } diff --git a/src/platform/locales/text/en.json b/src/platform/locales/text/en.json index eb290135d..8d2baf796 100644 --- a/src/platform/locales/text/en.json +++ b/src/platform/locales/text/en.json @@ -75,6 +75,7 @@ "Refreshing…": "Refreshing…", "Refresh in {seconds}s": "Refresh in {seconds}s", "Loading models…": "Loading models…", + "Loading model settings…": "Loading model settings…", "No models reported by this agent.": "No models reported by this agent.", "Could not refresh models: {detail}": "Could not refresh models: {detail}", "{model} (unavailable)": "{model} (unavailable)", diff --git a/src/platform/locales/text/zh.json b/src/platform/locales/text/zh.json index a0bb07421..3d6e6d333 100644 --- a/src/platform/locales/text/zh.json +++ b/src/platform/locales/text/zh.json @@ -66,6 +66,7 @@ "Refreshing…": "正在刷新…", "Refresh in {seconds}s": "{seconds} 秒后可刷新", "Loading models…": "正在加载模型…", + "Loading model settings…": "正在加载模型设置…", "No models reported by this agent.": "此 Agent 未提供模型。", "Could not refresh models: {detail}": "无法刷新模型:{detail}", "{model} (unavailable)": "{model}(不可用)",