The IDE you know, rebuilt in Rust. IntelliJ IDEA–style keymap, tool windows and search-everywhere in a fast native app: editor, code insight, debugger, Git, terminal, database and HTTP clients for 60+ languages.
TypeScript code-editorcross-platformdapdatabase-clientdebuggerdesktop-appdeveloper-toolsgithttp-clientideintellijlsprusttauriterminal
feat(agents): load Claude's models and effort before the first task (#2212)
SunZhiQiang1f2d86f793ae
diff --git a/crates/ide-agent/src/lib.rs b/crates/ide-agent/src/lib.rsindex 4f3400d70..73e311b20 100644--- a/crates/ide-agent/src/lib.rs+++ b/crates/ide-agent/src/lib.rs@@ -100,7 +100,7 @@ struct Shared {providers: RwLock<Vec<provider::ProviderSpec>>,/// Last probe of each provider.probes: Mutex<HashMap<String, AgentProbe>>,- /// One pre-session command lookup per provider, including failed attempts.+ /// One pre-session lookup of commands and settings per provider, including failed attempts.command_fetches: Mutex<HashMap<String, tokio::sync::watch::Receiver<bool>>>,/// [`IDLE_RELEASE`], in milliseconds (shorter in tests).idle_release_ms: AtomicU64,@@ -153,7 +153,7 @@ impl Shared {cache.get(provider).and_then(|k| k.commands.get(&self.root_key())).cloned().unwrap_or_default()}- async fn fetch_commands(self: &Arc<Self>, spec: provider::ProviderSpec) {+ async fn fetch_settings(self: &Arc<Self>, spec: provider::ProviderSpec) {let mut ready = {let mut fetches = self.command_fetches.lock();fetches@@ -163,14 +163,14 @@ impl Shared {let shared = self.clone();// Keep the lookup alive if a composer unmounts while it is waiting.self.runtime.spawn(async move {- if let Ok(commands) =- native::claude::commands(spec.clone(), shared.paths.project_root.clone()).await+ if let Ok((commands, options)) =+ native::claude::discover(spec.clone(), shared.paths.project_root.clone()).await{let commands = config::commands_of(&json!({ "availableCommands": commands }), &spec.id);+ let options = config::options_of(&json!({ "configOptions": options }));let _ = tokio::task::spawn_blocking(move || {- if shared.known_commands(&spec.id).is_empty() {- shared.remember(&spec.id, None, Some(&commands), None);- }+ shared.remember_discovered(&spec.id, &options, &commands);+ shared.emit(AgentEvent::Providers);}).await;}@@ -187,6 +187,10 @@ impl Shared {}}+ fn has_config(&self, provider: &str) -> bool {+ self.known.lock().get(provider).is_some_and(|k| !k.config.is_empty())+ }+fn root_key(&self) -> String {self.paths.project_root.to_string_lossy().into_owned()}@@ -199,37 +203,52 @@ impl Shared {commands: Option<&[AgentCommand]>,model: Option<&str>,) {- let snapshot = {- let mut cache = self.known.lock();- let known = cache.entry(provider.to_owned()).or_default();- let mut changed = false;- if let Some(c) = config {- if let Some(model) = model {- let levels: Vec<_> =- c.iter().filter(|o| o.category.as_deref() == Some("thought_level")).cloned().collect();- if known.thought_levels.get(model) != Some(&levels) {- known.thought_levels.insert(model.to_owned(), levels);- changed = true;- }- }- if !c.is_empty() && known.config != c {- known.config = c.to_vec();+ self.remember_inner(provider, config, commands, model, false);+ }++ fn remember_discovered(&self, provider: &str, config: &[AgentConfigOption], commands: &[AgentCommand]) {+ self.remember_inner(provider, Some(config), Some(commands), model_of(config).as_deref(), true);+ }++ fn remember_inner(+ &self,+ provider: &str,+ config: Option<&[AgentConfigOption]>,+ commands: Option<&[AgentCommand]>,+ model: Option<&str>,+ discovered: bool,+ ) {+ // Keep the update and its disk write ordered; a session report wins over discovery.+ let mut cache = self.known.lock();+ let known = cache.entry(provider.to_owned()).or_default();+ let mut changed = false;+ if let Some(c) = config.filter(|_| !discovered || known.config.is_empty()) {+ if let Some(model) = model {+ let levels: Vec<_> =+ c.iter().filter(|o| o.category.as_deref() == Some("thought_level")).cloned().collect();+ if known.thought_levels.get(model) != Some(&levels) {+ known.thought_levels.insert(model.to_owned(), levels);changed = true;}}- let root = self.root_key();- if let Some(c) =- commands.filter(|c| !c.is_empty() && known.commands.get(&root).map(Vec::as_slice) != Some(c))- {- known.commands.insert(root, c.to_vec());+ if !c.is_empty() && known.config != c {+ known.config = c.to_vec();changed = true;}- if !changed {- return;- }- serde_json::to_vec_pretty(&*cache)- };- if let Ok(bytes) = snapshot+ }+ let root = self.root_key();+ if let Some(c) = commands.filter(|c| {+ !c.is_empty()+ && (!discovered || known.commands.get(&root).is_none_or(Vec::is_empty))+ && known.commands.get(&root).map(Vec::as_slice) != Some(c)+ }) {+ known.commands.insert(root, c.to_vec());+ changed = true;+ }+ if !changed {+ return;+ }+ if let Ok(bytes) = serde_json::to_vec_pretty(&*cache)&& let Err(e) = write_file(&self.paths.models_file, &bytes){tracing::warn!("saving agent settings: {e}");@@ -458,10 +477,10 @@ impl AgentManager {// merged without duplicating what `availableCommands` or the disk offer.let mut offered = offered;if task.is_none()- && offered.is_empty()+ && (offered.is_empty() || !self.shared.has_config(&provider))&& let Some(spec) = self.shared.spec(&provider).filter(|s| s.driver == provider::Driver::Claude){- self.shared.fetch_commands(spec).await;+ self.shared.fetch_settings(spec).await;offered = self.shared.known_commands(&provider);}for &(name, description) in builtin_commands(&provider) {diff --git a/crates/ide-agent/src/native/claude/mod.rs b/crates/ide-agent/src/native/claude/mod.rsindex e4e557162..39677e622 100644--- a/crates/ide-agent/src/native/claude/mod.rs+++ b/crates/ide-agent/src/native/claude/mod.rs@@ -69,8 +69,9 @@ pub(crate) fn connect(Ok(super::serve(shim, client))}-/// Discover commands without a prompt, ACP session, or pending session file.-pub(crate) async fn commands(spec: ProviderSpec, cwd: PathBuf) -> Result<Vec<Value>, String> {+/// Discover the slash commands and the model, mode and effort options without a prompt,+/// ACP session, or pending session file.+pub(crate) async fn discover(spec: ProviderSpec, cwd: PathBuf) -> Result<(Vec<Value>, Value), String> {tokio::time::timeout(Duration::from_secs(5), async move {let spec = tokio::task::spawn_blocking(move || (spec.resolve_for_launch(&cwd), cwd));let (spec, cwd) = spec.await.map_err(|e| e.to_string())?;@@ -79,28 +80,52 @@ pub(crate) async fn commands(spec: ProviderSpec, cwd: PathBuf) -> Result<Vec<Vallet launch = Launch { program: spec.command, args, cwd, env: spec.env };let mut io = cli::Process.launch(&launch, Arc::new(|_| {})).map_err(|e| e.to_string())?;let _stop = io.kill.clone().drop_guard();- let request = json!({ "type": "control_request", "request_id": "commands",- "request": { "subtype": "initialize", "perTaskStopAffordance": true } });- io.stdin.write_all(format!("{request}\n").as_bytes()).await.map_err(|e| e.to_string())?;- io.stdin.flush().await.map_err(|e| e.to_string())?;let mut lines = BufReader::new(io.stdout).lines();- while let Some(line) = lines.next_line().await.map_err(|e| e.to_string())? {- let Ok(msg) = serde_json::from_str::<Value>(&line) else { continue };- if msg["type"] == "control_response" && msg["response"]["request_id"] == "commands" {- let response = &msg["response"];- return if response["subtype"] == "success" {- Ok(Settings::from_cli(&response["response"], &Value::Null).commands)- } else {- Err("Claude Code did not initialize".into())- };- }- }- Err("Claude Code exited".into())+ let init = control(+ &mut io.stdin,+ &mut lines,+ "commands",+ json!({ "subtype": "initialize", "perTaskStopAffordance": true }),+ )+ .await?+ .ok_or("Claude Code did not initialize")?;+ // The effort and model the user configured; without them the options show the defaults.+ let applied = tokio::time::timeout(+ Duration::from_secs(2),+ control(&mut io.stdin, &mut lines, "settings", json!({ "subtype": "get_settings" })),+ )+ .await+ .ok()+ .and_then(Result::ok)+ .flatten()+ .unwrap_or_default();+ let settings = Settings::from_cli(&init, &applied);+ Ok((settings.commands.clone(), settings.options()))}).await.map_err(|_| "Claude Code command discovery timed out".to_owned())?}+/// Sends one control request and waits for its response; `None` when the CLI answered with an error.+async fn control(+ stdin: &mut (impl AsyncWriteExt + Unpin),+ lines: &mut tokio::io::Lines<impl AsyncBufReadExt + Unpin>,+ id: &str,+ request: Value,+) -> Result<Option<Value>, String> {+ let line = json!({ "type": "control_request", "request_id": id, "request": request });+ stdin.write_all(format!("{line}\n").as_bytes()).await.map_err(|e| e.to_string())?;+ stdin.flush().await.map_err(|e| e.to_string())?;+ while let Some(line) = lines.next_line().await.map_err(|e| e.to_string())? {+ let Ok(msg) = serde_json::from_str::<Value>(&line) else { continue };+ if msg["type"] == "control_response" && msg["response"]["request_id"] == id {+ let response = &msg["response"];+ return Ok((response["subtype"] == "success").then(|| response["response"].clone()));+ }+ }+ Err("Claude Code exited".into())+}+struct Config {pub program: String,/// Extra arguments (a custom agent's), before the session's own.diff --git a/crates/ide-agent/src/tests.rs b/crates/ide-agent/src/tests.rsindex 025bc98bb..e38114b23 100644--- a/crates/ide-agent/src/tests.rs+++ b/crates/ide-agent/src/tests.rs@@ -371,7 +371,7 @@ fn manager_at(dir: &Path, models_file: &Path, agent: Arc<FakeAgent>) -> AgentManasync fn claude_commands_before_session_are_fetched_once_and_saved() {use std::os::unix::fs::PermissionsExt;- for outcome in ["success", "error", "exit", "timeout", "missing"] {+ for outcome in ["success", "session_report", "empty", "settings_timeout", "error", "exit", "timeout", "missing"] {let tmp = tempfile::tempdir().unwrap();let root = tmp.path();let script = root.join("fake-claude");@@ -380,6 +380,7 @@ async fn claude_commands_before_session_are_fetched_once_and_saved() {r#"#!/usr/bin/env python3import json, os, pathlib, sys, timeroot = pathlib.Path.cwd()+(root / 'pid').write_text(str(os.getpid()))with (root / 'launches').open('a') as f:f.write(json.dumps(sys.argv[1:]) + '\n')request = json.loads(sys.stdin.readline())@@ -391,16 +392,34 @@ if outcome == 'exit':if outcome == 'timeout':time.sleep(60)response = {'subtype': outcome, 'request_id': request['request_id']}-if outcome == 'success':+if outcome in ('success', 'session_report', 'empty', 'settings_timeout'):+ response['subtype'] = 'success'response['response'] = {'commands': [{'name': 'compact', 'description': 'Free up context', 'argumentHint': '[instructions]'},- {'name': 'clear'}, {'name': 'model'}, {'name': 'context'}]}+ {'name': 'clear'}, {'name': 'model'}, {'name': 'context'}],+ 'models': [+ {'value': 'default', 'displayName': 'Default (recommended)', 'description': 'Use the default model',+ 'supportsEffort': True, 'supportedEffortLevels': ['low', 'high']},+ {'value': 'custom-opus', 'displayName': 'custom-opus', 'description': 'Custom Opus model'}]}+ if outcome == 'empty':+ response['response'] = {}else:response['error'] = 'Authentication required'+if outcome == 'session_report':+ (root / 'initialized').touch()+ while not (root / 'continue').exists():+ time.sleep(0.01)print(json.dumps({'type': 'control_response', 'response': response}), flush=True)for line in sys.stdin:with (root / 'requests').open('a') as f:f.write(line)+ request = json.loads(line)+ if request['request']['subtype'] == 'get_settings':+ if outcome == 'settings_timeout':+ time.sleep(60)+ reply = {'subtype': 'success', 'request_id': request['request_id'],+ 'response': {'applied': {'effort': 'high'}, 'effective': {}}}+ print(json.dumps({'type': 'control_response', 'response': reply}), flush=True)"#,).unwrap();@@ -417,19 +436,59 @@ for line in sys.stdin:}spec.env = vec![("OUTCOME".into(), outcome.into())];}- let (first, concurrent) = tokio::join!(mgr.commands("claude", None), mgr.commands("claude", None));+ let concurrent = async {+ if outcome == "session_report" {+ tokio::time::timeout(Duration::from_secs(2), async {+ while !root.join("initialized").exists() {+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ })+ .await+ .unwrap();+ let reported = config::options_of(&json!({ "configOptions": [+ { "id": "model", "category": "model", "type": "select", "currentValue": "default",+ "options": [{ "value": "default" }, { "value": "custom-opus" }] },+ { "id": "effort", "category": "thought_level", "type": "select", "currentValue": "low",+ "options": [{ "value": "default" }, { "value": "low" }, { "value": "high" }] }+ ] }));+ mgr.shared.remember("claude", Some(&reported), None, Some("default"));+ std::fs::write(root.join("continue"), "").unwrap();+ }+ mgr.commands("claude", None).await+ };+ let (first, concurrent) = tokio::join!(mgr.commands("claude", None), concurrent);let first = first.unwrap();assert_eq!(first, concurrent.unwrap());assert_eq!(first, mgr.commands("claude", None).await.unwrap());let names: Vec<_> = first.iter().map(|c| c.name.as_str()).collect();- if outcome == "success" {+ if matches!(outcome, "success" | "session_report" | "settings_timeout") {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()));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] {+ let claude = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();+ let model = claude.config.iter().find(|o| o.category.as_deref() == Some("model")).unwrap();+ assert_eq!(model.current.as_deref(), Some("default"));+ let values: Vec<_> = model.values.iter().map(|v| v.value.as_str()).collect();+ assert_eq!(values, ["default", "custom-opus"]);+ let effort =+ claude.thought_levels["default"].iter().find(|o| o.category.as_deref() == Some("thought_level"));+ assert_eq!(+ effort.unwrap().current.as_deref(),+ Some(match outcome {+ "settings_timeout" => "default",+ "session_report" => "low",+ _ => "high",+ })+ );+ }} else {assert_eq!(names, ["triage"], "{outcome}");- assert!(!root.join("models.json").exists());+ assert_eq!(root.join("models.json").exists(), outcome == "empty");+ let claude = mgr.providers().into_iter().find(|p| p.id == "claude").unwrap();+ assert!(!claude.config.iter().any(|o| o.category.as_deref() == Some("model")), "{outcome}");}assert!(mgr.tasks.read().is_empty());assert!(!root.join("store").exists());@@ -439,10 +498,25 @@ for line in sys.stdin:let args: Vec<String> = serde_json::from_str(launches.trim()).unwrap();assert!(args.windows(2).any(|a| a == ["--input-format", "stream-json"]));let requests = std::fs::read_to_string(root.join("requests")).unwrap();- assert_eq!(requests.lines().count(), 1, "only initialize, no prompt or other control request");- let request: Value = serde_json::from_str(requests.trim()).unwrap();- assert_eq!(request["type"], "control_request");- assert_eq!(request["request"]["subtype"], "initialize");+ let subtypes: Vec<String> = requests+ .lines()+ .map(|l| serde_json::from_str::<Value>(l).unwrap()["request"]["subtype"].as_str().unwrap().to_owned())+ .collect();+ // The handshake and the settings read: no prompt or other control request.+ let expected: &[&str] = if matches!(outcome, "success" | "session_report" | "empty" | "settings_timeout") {+ &["initialize", "get_settings"]+ } else {+ &["initialize"]+ };+ assert_eq!(subtypes, expected, "{outcome}");+ let pid = std::fs::read_to_string(root.join("pid")).unwrap();+ tokio::time::timeout(Duration::from_secs(2), async {+ while std::process::Command::new("kill").args(["-0", pid.trim()]).output().unwrap().status.success() {+ tokio::time::sleep(Duration::from_millis(10)).await;+ }+ })+ .await+ .expect("discovery process must exit");}}}@@ -2358,3 +2432,31 @@ fn mcp_servers_follow_server_state_and_agent_capabilities() {"args":["--mcp-stdio","--project","/project"],"env":[]})]);}++#[tokio::test(flavor = "multi_thread")]+async fn session_settings_win_over_discovery_in_memory_and_on_disk() {+ for discovery_first in [false, true] {+ let tmp = tempfile::tempdir().unwrap();+ let mgr = manager(tmp.path(), Arc::new(FakeAgent::default()));+ let options = |model: &str, effort: &str| {+ config::options_of(&json!({ "configOptions": [+ { "id": "model", "category": "model", "type": "select", "currentValue": model,+ "options": [{ "value": "saved" }, { "value": "discovered" }] },+ { "id": "effort", "category": "thought_level", "type": "select", "currentValue": effort,+ "options": [{ "value": "low" }, { "value": "high" }] }+ ] }))+ };+ let saved = options("saved", "low");+ let discovered = options("discovered", "high");+ if discovery_first {+ mgr.shared.remember_discovered("claude", &discovered, &[]);+ }+ mgr.shared.remember("claude", Some(&saved), None, Some("saved"));+ mgr.shared.remember_discovered("claude", &discovered, &[]);+ let restored = manager(tmp.path(), Arc::new(FakeAgent::default()));+ for mgr in [&mgr, &restored] {+ assert_eq!(model_of(&mgr.shared.known_config("claude")).as_deref(), Some("saved"));+ assert_eq!(mgr.shared.known.lock()["claude"].thought_levels["saved"], saved[1..]);+ }+ }+}