refactor(desktop): remove orphaned model-discovery probe

The agent profile sidebar went read-only, removing the ModelPicker that
was the sole consumer of the model-discovery probe (`get_agent_models`,
which spawns `buzz-acp models --json`). Rip out the now-dead chain:

- delete ModelPicker.tsx (imported by nothing)
- drop the get_agent_models Tauri command + its probe/normalization
  helpers in agent_models.rs, its lib.rs registration, and the
  e2eBridge mock
- remove AgentModelsResponse/AgentModelInfo (Rust + TS) and the
  getAgentModels() wrapper
- remove the three helpers the probe was the only caller of:
  resolve_persona_env, redact_env_values_in (a thin redact_secrets_with
  wrapper), and resolve_effective_prompt_model_provider, plus their
  now-orphaned tests

Keep update_managed_agent (lives in the same file, still used widely)
and the static "Model: Auto" display row (pure config read).

Co-authored-by: Taylor Ho <taylorkmho@gmail.com>
Signed-off-by: Taylor Ho <taylorkmho@gmail.com>

Author: npub1223z34hd7vtwc6qj4s7flsxkj644nlre2nthu7lrrmkumhu3xddsrx9r6w

desktop/src-tauri/src/commands/agent_models.rs

@@ -1,205 +1,18 @@
-use std::collections::HashSet;
-
 use nostr::Keys;
 use tauri::{AppHandle, State};
 
 use crate::{
     app_state::AppState,
     managed_agents::{
-        build_databricks_defaults, build_managed_agent_summary, current_instance_id,
-        default_agent_workdir, find_managed_agent_mut, known_acp_runtime, load_managed_agents,
-        load_personas, managed_agent_avatar_url, missing_command_message, normalize_agent_args,
-        resolve_command, resolve_effective_prompt_model_provider, runtime_metadata_env_vars,
-        save_managed_agents, sync_managed_agent_processes, try_regenerate_nest, AgentModelInfo,
-        AgentModelsResponse, UpdateManagedAgentRequest, UpdateManagedAgentResponse,
+        build_managed_agent_summary, current_instance_id, find_managed_agent_mut,
+        load_managed_agents, load_personas, managed_agent_avatar_url, save_managed_agents,
+        sync_managed_agent_processes, try_regenerate_nest, UpdateManagedAgentRequest,
+        UpdateManagedAgentResponse,
     },
     relay::{relay_ws_url_with_override, sync_managed_agent_profile},
     util::now_iso,
 };
 
-/// Query available models from an agent via `buzz-acp models --json`.
-///
-/// Spawns a short-lived subprocess (no relay connection needed). The subprocess
-/// starts the agent, queries its model catalog, and exits. ~2-5s total.
-#[tauri::command]
-pub async fn get_agent_models(
-    pubkey: String,
-    app: AppHandle,
-    state: State<'_, AppState>,
-) -> Result<AgentModelsResponse, String> {
-    let (
-        resolved_acp,
-        agent_command,
-        agent_args,
-        persisted_model,
-        runtime_default_env,
-        runtime_metadata_env,
-        databricks_defaults,
-        merged_env,
-    ) = {
-        let _store_guard = state
-            .managed_agents_store_lock
-            .lock()
-            .map_err(|e| e.to_string())?;
-        let mut records = load_managed_agents(&app)?;
-        let mut runtimes = state
-            .managed_agent_processes
-            .lock()
-            .map_err(|e| e.to_string())?;
-        if sync_managed_agent_processes(&mut records, &mut runtimes, &current_instance_id(&app)) {
-            save_managed_agents(&app, &records)?;
-        }
-
-        let record = records
-            .iter()
-            .find(|r| r.pubkey == pubkey)
-            .ok_or_else(|| format!("agent {pubkey} not found"))?;
-
-        let resolved = resolve_command(&record.acp_command)
-            .ok_or_else(|| missing_command_message(&record.acp_command, "ACP harness command"))?;
-
-        // Resolve the effective harness from the linked persona (mirrors spawn),
-        // so model discovery runs against the persona's current harness, not the
-        // frozen record snapshot. An explicit per-agent override wins.
-        let personas = load_personas(&app).unwrap_or_default();
-        let effective_command = crate::managed_agents::effective_agent_command(
-            record.persona_id.as_deref(),
-            &personas,
-            record.agent_command_override.as_deref(),
-        );
-
-        let args = normalize_agent_args(&effective_command, record.agent_args.clone());
-
-        let resolved_agent = resolve_command(&effective_command)
-            .map(|p| p.display().to_string())
-            .unwrap_or_else(|| effective_command.clone());
-
-        // Same env layering as runtime spawn: persona env < agent env.
-        // Model discovery needs the user's credentials. Fail closed on
-        // persona-resolution errors so a corrupt personas.json doesn't
-        // produce a model list as if the persona had no credentials.
-        let persona_env =
-            crate::managed_agents::resolve_persona_env(&app, record.persona_id.as_deref())?;
-        let env = crate::managed_agents::merged_user_env(&persona_env, &record.env_vars);
-
-        // Resolve the effective model from the linked persona so the ModelPicker
-        // dropdown shows the current persona model as selected.
-        let (_prompt, effective_model, effective_provider) =
-            resolve_effective_prompt_model_provider(
-                record.persona_id.as_deref(),
-                &personas,
-                record.system_prompt.clone(),
-                record.model.clone(),
-            );
-        let runtime = known_acp_runtime(&record.agent_command);
-        let runtime_default_env: Vec<(String, String)> = runtime
-            .map(|meta| {
-                meta.default_env
-                    .iter()
-                    .map(|(key, value)| ((*key).to_string(), (*value).to_string()))
-                    .collect()
-            })
-            .unwrap_or_default();
-        let runtime_metadata_env: Vec<(String, String)> = runtime
-            .map(|meta| {
-                runtime_metadata_env_vars(
-                    meta.model_env_var,
-                    meta.provider_env_var,
-                    meta.provider_locked,
-                    effective_model.as_deref(),
-                    effective_provider.as_deref(),
-                )
-                .into_iter()
-                .map(|(key, value)| (key.to_string(), value.to_string()))
-                .collect()
-            })
-            .unwrap_or_default();
-        let databricks_defaults: Vec<(String, String)> = build_databricks_defaults()
-            .into_iter()
-            .map(|(key, value)| (key.to_string(), value.to_string()))
-            .collect();
-
-        (
-            resolved,
-            resolved_agent,
-            args,
-            effective_model,
-            runtime_default_env,
-            runtime_metadata_env,
-            databricks_defaults,
-            env,
-        )
-    }; // store lock released — subprocess runs without holding the lock
-
-    // Clone the env map for redaction below — `merged_env` is moved
-    // into the spawn_blocking closure and we still need the values to
-    // scrub any user-supplied secrets that the child surfaces in stderr.
-    let env_for_redaction = merged_env.clone();
-
-    // Use spawn_blocking because the desktop Tauri crate doesn't enable
-    // tokio's `process` feature. std::process::Command is synchronous
-    // but fine for a short-lived subprocess (~2-5s).
-    let output = tokio::task::spawn_blocking(move || {
-        let mut cmd = std::process::Command::new(&resolved_acp);
-        if let Some(home) = default_agent_workdir() {
-            cmd.current_dir(home);
-        }
-        if let Some(ref path) = crate::managed_agents::login_shell_path() {
-            cmd.env("PATH", path);
-        }
-        cmd.arg("models")
-            .arg("--json")
-            .env("BUZZ_ACP_AGENT_COMMAND", &agent_command)
-            .env("BUZZ_ACP_AGENT_ARGS", agent_args.join(","));
-        for (key, value) in &runtime_default_env {
-            if std::env::var(key).is_err() {
-                cmd.env(key, value);
-            }
-        }
-        for (key, value) in &runtime_metadata_env {
-            cmd.env(key, value);
-        }
-        for (key, value) in &databricks_defaults {
-            cmd.env(key, value);
-        }
-        // User env layering — written LAST so it overrides any Buzz-set env above.
-        for (k, v) in &merged_env {
-            cmd.env(k, v);
-        }
-        cmd.stdout(std::process::Stdio::piped())
-            .stderr(std::process::Stdio::piped())
-            .output()
-            .map_err(|e| format!("failed to spawn buzz-acp models: {e}"))
-    })
-    .await
-    .map_err(|e| format!("model discovery task failed: {e}"))?
-    .map_err(|e: String| e)?;
-
-    if !output.status.success() {
-        let stderr = String::from_utf8_lossy(&output.stderr);
-        // Scrub any user-supplied env values before surfacing stderr to
-        // the frontend — persona/agent env_vars may carry API keys that
-        // a failing child process echoed back.
-        let stderr_redacted =
-            crate::managed_agents::redact_env_values_in(stderr.as_ref(), &env_for_redaction);
-        if let Some(configuration_error) = model_configuration_error(&stderr_redacted) {
-            return Ok(unavailable_agent_models(
-                persisted_model,
-                configuration_error,
-            ));
-        }
-        return Err(format!(
-            "buzz-acp models failed (exit {}): {stderr_redacted}",
-            output.status.code().unwrap_or(-1)
-        ));
-    }
-
-    let raw: serde_json::Value = serde_json::from_slice(&output.stdout)
-        .map_err(|e| format!("failed to parse model JSON: {e}"))?;
-
-    Ok(normalize_agent_models(&raw, persisted_model))
-}
-
 /// Update mutable fields on an existing managed agent record.
 ///
 /// Does NOT auto-restart the agent. Runtime config changes (system prompt,
@@ -389,133 +202,3 @@ pub async fn update_managed_agent(
         profile_sync_error,
     })
 }
-
-// ── Model normalization ───────────────────────────────────────────────────────
-
-/// Normalize raw `buzz-acp models --json` output into a typed DTO for the frontend.
-///
-/// Merges models from both ACP paths (stable configOptions + unstable SessionModelState),
-/// deduplicates by ID (stable takes precedence), and returns a unified list.
-fn normalize_agent_models(
-    raw: &serde_json::Value,
-    persisted_model: Option<String>,
-) -> AgentModelsResponse {
-    let agent_name = raw["agent"]["name"]
-        .as_str()
-        .unwrap_or("unknown")
-        .to_string();
-    let agent_version = raw["agent"]["version"]
-        .as_str()
-        .unwrap_or("unknown")
-        .to_string();
-
-    let mut models: Vec<AgentModelInfo> = Vec::new();
-    let mut seen_ids: HashSet<String> = HashSet::new();
-
-    // 1. Stable configOptions (preferred). Only entries with category "model"
-    //    are model options — the CLI pre-filters, but we're defensive here.
-    if let Some(config_options) = raw["stable"]["configOptions"].as_array() {
-        for opt in config_options {
-            if opt.get("category").and_then(|c| c.as_str()) != Some("model") {
-                continue;
-            }
-            if let Some(options) = opt.get("options").and_then(|v| v.as_array()) {
-                for o in options {
-                    if let Some(value) = o.get("value").and_then(|v| v.as_str()) {
-                        if seen_ids.insert(value.to_string()) {
-                            models.push(AgentModelInfo {
-                                id: value.to_string(),
-                                name: o
-                                    .get("displayName")
-                                    .and_then(|v| v.as_str())
-                                    .map(str::to_string),
-                                description: None,
-                            });
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // 2. Unstable availableModels (fallback — skip duplicates from stable).
-    let mut agent_default_model: Option<String> = None;
-    if let Some(unstable) = raw.get("unstable") {
-        agent_default_model = unstable["currentModelId"].as_str().map(str::to_string);
-        if let Some(available) = unstable["availableModels"].as_array() {
-            for m in available {
-                if let Some(id) = m.get("modelId").and_then(|v| v.as_str()) {
-                    if seen_ids.insert(id.to_string()) {
-                        models.push(AgentModelInfo {
-                            id: id.to_string(),
-                            name: m.get("name").and_then(|v| v.as_str()).map(str::to_string),
-                            description: m
-                                .get("description")
-                                .and_then(|v| v.as_str())
-                                .map(str::to_string),
-                        });
-                    }
-                }
-            }
-        }
-    }
-
-    let supports_switching = !models.is_empty();
-
-    AgentModelsResponse {
-        agent_name,
-        agent_version,
-        models,
-        agent_default_model,
-        selected_model: persisted_model,
-        supports_switching,
-        configuration_error: None,
-    }
-}
-
-fn unavailable_agent_models(
-    persisted_model: Option<String>,
-    configuration_error: String,
-) -> AgentModelsResponse {
-    AgentModelsResponse {
-        agent_name: "unknown".to_string(),
-        agent_version: "unknown".to_string(),
-        models: Vec::new(),
-        agent_default_model: None,
-        selected_model: persisted_model,
-        supports_switching: false,
-        configuration_error: Some(configuration_error),
-    }
-}
-
-fn model_configuration_error(stderr: &str) -> Option<String> {
-    let normalized = stderr.to_ascii_lowercase();
-
-    if normalized.contains("buzz_agent_provider required") {
-        return Some(
-            "This agent does not have an LLM provider configured. Set a provider and model on the persona or agent, then retry."
-                .to_string(),
-        );
-    }
-
-    if normalized.contains("anthropic_model required")
-        || normalized.contains("openai_compat_model required")
-        || normalized.contains("databricks_model required")
-    {
-        return Some(
-            "This agent does not have an LLM model configured. Set a model on the persona or agent, then retry."
-                .to_string(),
-        );
-    }
-
-    if normalized.contains("anthropic_api_key required")
-        || normalized.contains("openai_compat_api_key required")
-    {
-        return Some(
-            "This agent is missing credentials for its configured LLM provider. Add the provider credentials, then retry."
-                .to_string(),
-        );
-    }
-
-    None
-}

desktop/src-tauri/src/lib.rs

@@ -825,7 +825,6 @@ pub fn run() {
             set_managed_agent_start_on_app_launch,
             delete_managed_agent,
             get_managed_agent_log,
-            get_agent_models,
             mesh_availability,
             mesh_start_node,
             mesh_ensure_client_node,

desktop/src-tauri/src/managed_agents/backend.rs

@@ -337,22 +337,6 @@ fn env_secrets_from_request(request: &serde_json::Value) -> Vec<String> {
         .unwrap_or_default()
 }
 
-/// Public-in-crate helper: redact every non-empty value from `env` (plus
-/// the standard nsec/sprt_tok prefix scrubbing) out of `s`. Used by
-/// callers that already have a flat env map handy — e.g. model discovery
-/// formatting child stderr into a frontend-visible error.
-pub(crate) fn redact_env_values_in(
-    s: &str,
-    env: &std::collections::BTreeMap<String, String>,
-) -> String {
-    let values: Vec<&str> = env
-        .values()
-        .filter(|v| !v.is_empty())
-        .map(String::as_str)
-        .collect();
-    redact_secrets_with(s, &values)
-}
-
 /// Deploy an agent via provider binary. Returns the provider-assigned agent_id.
 ///
 /// `request_id` is included for provider-side logging/correlation but is not
@@ -584,17 +568,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn redact_env_values_in_scrubs_map_values() {
-        let mut env = std::collections::BTreeMap::new();
-        env.insert("ANTHROPIC_API_KEY".to_string(), "sk-ant-real".to_string());
-        env.insert("EMPTY".to_string(), String::new());
-        let stderr = "auth=sk-ant-real failed; other context";
-        let r = redact_env_values_in(stderr, &env);
-        assert!(!r.contains("sk-ant-real"));
-        assert!(r.contains("[REDACTED]"));
-    }
-
     #[test]
     fn validate_provider_config_rejects_secret_key() {
         let cfg = serde_json::json!({"api_key": "val"});