feat: normalized config schema with PersonaRecord.provider and SPROUT_AGENT_MODEL

sprout-agent personas all failed because the desktop never injected
SPROUT_AGENT_PROVIDER or model env vars at spawn time, and the goose
config fallback only understood the old flat format. Extract goose
config compat into an isolated submodule, add support for the newer
active_provider + nested providers format, and wire a normalized
config schema so Sprout injects the right env vars for any runtime.

Key changes:
- PersonaRecord.provider captures the LLM provider independently
- SPROUT_AGENT_MODEL works as a universal model fallback
- provider_env_var and model_env_var always injected at spawn time
- Pack import now stores resolved env vars (was always empty)
- runtime_env_vars() emits runtime-appropriate vars (SPROUT_AGENT_*
  vs GOOSE_*)

Author: wpfleger96

crates/sprout-acp/src/acp.rs

@@ -202,7 +202,7 @@ impl AcpClient {
             // Callers MUST still call shutdown().await for guaranteed cleanup.
             .kill_on_drop(true);
 
-        // Per-persona env vars (e.g., GOOSE_PROVIDER, GOOSE_MODEL).
+        // Per-persona env vars (e.g., GOOSE_PROVIDER, SPROUT_AGENT_PROVIDER).
         // Only injected if not already set in parent env (operator precedence).
         for (key, value) in extra_env {
             if std::env::var(key).is_err() {

crates/sprout-acp/src/config.rs

@@ -466,7 +466,7 @@ pub struct Config {
     pub respond_to: RespondTo,
     /// Validated allowlist of pubkey hex strings (used when respond_to == Allowlist).
     pub respond_to_allowlist: HashSet<String>,
-    /// Per-persona env vars to inject at agent spawn time (e.g., GOOSE_PROVIDER, GOOSE_MODEL).
+    /// Per-persona env vars to inject at agent spawn time (e.g., GOOSE_PROVIDER, GOOSE_MODEL, SPROUT_AGENT_MODEL).
     /// Populated from persona pack resolution. Empty when no pack is configured.
     pub persona_env_vars: Vec<(String, String)>,
     /// Whether to publish encrypted observer frames through the relay.
@@ -764,7 +764,7 @@ impl Config {
                     (
                         Some(persona.system_prompt),
                         persona.model,
-                        persona.goose_env_vars,
+                        persona.runtime_env_vars,
                     )
                 }
                 (Some(_), None) => {

crates/sprout-agent/src/config/goose_compat.rs

@@ -0,0 +1,345 @@
+//! Goose config compatibility layer.
+//!
+//! Reads `~/.config/goose/config.yaml` to extract Databricks credentials
+//! as a fallback when env vars aren't set. Bridge code that shrinks as
+//! Sprout's spawn-time env injection improves.
+
+use std::{collections::HashMap, path::PathBuf};
+
+#[derive(Default)]
+pub(super) struct GooseDatabricksConfig {
+    pub(super) host: Option<String>,
+    pub(super) model: Option<String>,
+}
+
+impl GooseDatabricksConfig {
+    pub(super) fn load_default() -> Self {
+        goose_config_path()
+            .and_then(|p| Self::load_from_path(&p))
+            .unwrap_or_default()
+    }
+
+    pub(super) fn load_from_path(path: &std::path::Path) -> Option<Self> {
+        let raw = std::fs::read_to_string(path).ok()?;
+        let map: HashMap<String, serde_yaml::Value> = serde_yaml::from_str(&raw).ok()?;
+        Some(Self::from_map(&map))
+    }
+
+    pub(super) fn from_map(map: &HashMap<String, serde_yaml::Value>) -> Self {
+        let host = yaml_string(map, "DATABRICKS_HOST");
+        let explicit_model = yaml_string(map, "DATABRICKS_MODEL");
+        let goose_provider = yaml_string(map, "GOOSE_PROVIDER");
+        let goose_model = yaml_string(map, "GOOSE_MODEL");
+        let goose_mode = yaml_string(map, "GOOSE_MODE");
+
+        // Flat-key model resolution (existing)
+        let flat_model = explicit_model.or_else(|| {
+            if goose_provider
+                .as_deref()
+                .is_some_and(|p| p.eq_ignore_ascii_case("databricks"))
+            {
+                goose_model.or(goose_mode)
+            } else {
+                None
+            }
+        });
+
+        // Nested provider format fallback (active_provider + providers block)
+        let active_provider = yaml_string(map, "active_provider");
+        let (nested_host, nested_model) = active_provider
+            .as_deref()
+            .filter(|ap| ap.to_ascii_lowercase().starts_with("databricks"))
+            .and_then(|ap| nested_provider_config(map, ap))
+            .unwrap_or((None, None));
+
+        Self {
+            host: host.or(nested_host),
+            model: flat_model.or(nested_model),
+        }
+    }
+}
+
+fn nested_provider_config(
+    map: &HashMap<String, serde_yaml::Value>,
+    active_provider: &str,
+) -> Option<(Option<String>, Option<String>)> {
+    let providers = map.get("providers").and_then(|v| v.as_mapping())?;
+    let provider_config = providers
+        .get(serde_yaml::Value::String(active_provider.to_owned()))?
+        .as_mapping()?;
+
+    let model = provider_config
+        .get(serde_yaml::Value::String("model".to_owned()))
+        .and_then(|v| v.as_str())
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty())
+        .map(str::to_string);
+
+    let host = provider_config
+        .get(serde_yaml::Value::String("host".to_owned()))
+        .and_then(|v| v.as_str())
+        .map(|s| s.trim())
+        .filter(|s| !s.is_empty())
+        .map(str::to_string);
+
+    Some((host, model))
+}
+
+fn yaml_string(map: &HashMap<String, serde_yaml::Value>, key: &str) -> Option<String> {
+    map.get(key)?
+        .as_str()
+        .map(str::trim)
+        .filter(|s| !s.is_empty())
+        .map(str::to_string)
+}
+
+fn goose_config_path() -> Option<PathBuf> {
+    if let Ok(root) = std::env::var("GOOSE_PATH_ROOT") {
+        return Some(PathBuf::from(root).join("config").join("config.yaml"));
+    }
+    let home = std::env::var("HOME").ok()?;
+    Some(
+        PathBuf::from(home)
+            .join(".config")
+            .join("goose")
+            .join("config.yaml"),
+    )
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // ── Existing flat-key tests ──────────────────────────────────────────────
+
+    #[test]
+    fn goose_databricks_config_reads_host_and_model() {
+        let map = HashMap::from([
+            (
+                "DATABRICKS_HOST".to_string(),
+                serde_yaml::Value::String("https://dbc.example".into()),
+            ),
+            (
+                "GOOSE_PROVIDER".to_string(),
+                serde_yaml::Value::String("databricks".into()),
+            ),
+            (
+                "GOOSE_MODEL".to_string(),
+                serde_yaml::Value::String("goose-claude-4-6-sonnet".into()),
+            ),
+        ]);
+        let cfg = GooseDatabricksConfig::from_map(&map);
+        assert_eq!(cfg.host.as_deref(), Some("https://dbc.example"));
+        assert_eq!(cfg.model.as_deref(), Some("goose-claude-4-6-sonnet"));
+    }
+
+    #[test]
+    fn goose_databricks_config_prefers_explicit_databricks_model() {
+        let map = HashMap::from([
+            (
+                "DATABRICKS_HOST".to_string(),
+                serde_yaml::Value::String("https://dbc.example".into()),
+            ),
+            (
+                "DATABRICKS_MODEL".to_string(),
+                serde_yaml::Value::String("explicit-db-model".into()),
+            ),
+            (
+                "GOOSE_PROVIDER".to_string(),
+                serde_yaml::Value::String("databricks".into()),
+            ),
+            (
+                "GOOSE_MODEL".to_string(),
+                serde_yaml::Value::String("goose-model".into()),
+            ),
+        ]);
+        let cfg = GooseDatabricksConfig::from_map(&map);
+        assert_eq!(cfg.model.as_deref(), Some("explicit-db-model"));
+    }
+
+    #[test]
+    fn goose_databricks_config_ignores_goose_model_for_other_provider() {
+        let map = HashMap::from([
+            (
+                "DATABRICKS_HOST".to_string(),
+                serde_yaml::Value::String("https://dbc.example".into()),
+            ),
+            (
+                "GOOSE_PROVIDER".to_string(),
+                serde_yaml::Value::String("anthropic".into()),
+            ),
+            (
+                "GOOSE_MODEL".to_string(),
+                serde_yaml::Value::String("claude".into()),
+            ),
+        ]);
+        let cfg = GooseDatabricksConfig::from_map(&map);
+        assert_eq!(cfg.host.as_deref(), Some("https://dbc.example"));
+        assert!(cfg.model.is_none());
+    }
+
+    // ── Nested active_provider + providers block (newer goose format) ────────
+
+    #[test]
+    fn from_map_reads_nested_active_provider_databricks_v2() {
+        // Simulates:
+        //   active_provider: databricks_v2
+        //   providers:
+        //     databricks_v2:
+        //       model: goose-claude-4-6-opus
+        //       host: https://dbc.example
+        let providers_map = {
+            let mut inner = serde_yaml::Mapping::new();
+            let mut provider_entry = serde_yaml::Mapping::new();
+            provider_entry.insert(
+                serde_yaml::Value::String("model".into()),
+                serde_yaml::Value::String("goose-claude-4-6-opus".into()),
+            );
+            provider_entry.insert(
+                serde_yaml::Value::String("host".into()),
+                serde_yaml::Value::String("https://dbc.example".into()),
+            );
+            inner.insert(
+                serde_yaml::Value::String("databricks_v2".into()),
+                serde_yaml::Value::Mapping(provider_entry),
+            );
+            serde_yaml::Value::Mapping(inner)
+        };
+
+        let map = HashMap::from([
+            (
+                "active_provider".to_string(),
+                serde_yaml::Value::String("databricks_v2".into()),
+            ),
+            ("providers".to_string(), providers_map),
+        ]);
+
+        let cfg = GooseDatabricksConfig::from_map(&map);
+        assert_eq!(cfg.host.as_deref(), Some("https://dbc.example"));
+        assert_eq!(cfg.model.as_deref(), Some("goose-claude-4-6-opus"));
+    }
+
+    #[test]
+    fn from_map_flat_keys_win_over_nested() {
+        // Flat DATABRICKS_MODEL takes precedence over the nested providers block.
+        let providers_map = {
+            let mut inner = serde_yaml::Mapping::new();
+            let mut provider_entry = serde_yaml::Mapping::new();
+            provider_entry.insert(
+                serde_yaml::Value::String("model".into()),
+                serde_yaml::Value::String("nested-model".into()),
+            );
+            provider_entry.insert(
+                serde_yaml::Value::String("host".into()),
+                serde_yaml::Value::String("https://nested-host.example".into()),
+            );
+            inner.insert(
+                serde_yaml::Value::String("databricks_v2".into()),
+                serde_yaml::Value::Mapping(provider_entry),
+            );
+            serde_yaml::Value::Mapping(inner)
+        };
+
+        let map = HashMap::from([
+            (
+                "active_provider".to_string(),
+                serde_yaml::Value::String("databricks_v2".into()),
+            ),
+            ("providers".to_string(), providers_map),
+            (
+                "DATABRICKS_HOST".to_string(),
+                serde_yaml::Value::String("https://flat-host.example".into()),
+            ),
+            (
+                "DATABRICKS_MODEL".to_string(),
+                serde_yaml::Value::String("flat-model".into()),
+            ),
+        ]);
+
+        let cfg = GooseDatabricksConfig::from_map(&map);
+        // Flat keys win
+        assert_eq!(cfg.host.as_deref(), Some("https://flat-host.example"));
+        assert_eq!(cfg.model.as_deref(), Some("flat-model"));
+    }
+
+    #[test]
+    fn from_map_non_databricks_active_provider_is_ignored() {
+        // active_provider = anthropic should not trigger nested lookup
+        let providers_map = {
+            let mut inner = serde_yaml::Mapping::new();
+            let mut provider_entry = serde_yaml::Mapping::new();
+            provider_entry.insert(
+                serde_yaml::Value::String("model".into()),
+                serde_yaml::Value::String("claude-opus-4".into()),
+            );
+            inner.insert(
+                serde_yaml::Value::String("anthropic".into()),
+                serde_yaml::Value::Mapping(provider_entry),
+            );
+            serde_yaml::Value::Mapping(inner)
+        };
+
+        let map = HashMap::from([
+            (
+                "active_provider".to_string(),
+                serde_yaml::Value::String("anthropic".into()),
+            ),
+            ("providers".to_string(), providers_map),
+        ]);
+
+        let cfg = GooseDatabricksConfig::from_map(&map);
+        assert!(cfg.host.is_none());
+        assert!(cfg.model.is_none());
+    }
+
+    #[test]
+    fn load_from_path_returns_none_for_nonexistent_file() {
+        let result = GooseDatabricksConfig::load_from_path(std::path::Path::new(
+            "/tmp/sprout-test-nonexistent-goose-config-99999999.yaml",
+        ));
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn load_from_path_parses_valid_yaml() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("config.yaml");
+        std::fs::write(
+            &path,
+            "DATABRICKS_HOST: https://dbc.example\nGOOSE_PROVIDER: databricks\nGOOSE_MODEL: goose-claude-4-6-sonnet\n",
+        )
+        .unwrap();
+        let cfg = GooseDatabricksConfig::load_from_path(&path).unwrap();
+        assert_eq!(cfg.host.as_deref(), Some("https://dbc.example"));
+        assert_eq!(cfg.model.as_deref(), Some("goose-claude-4-6-sonnet"));
+    }
+
+    #[test]
+    fn load_from_path_returns_none_for_invalid_yaml() {
+        let dir = tempfile::tempdir().unwrap();
+        let path = dir.path().join("config.yaml");
+        std::fs::write(&path, "{{{{not valid yaml at all::::").unwrap();
+        let result = GooseDatabricksConfig::load_from_path(&path);
+        assert!(result.is_none());
+    }
+
+    #[test]
+    fn goose_config_path_falls_back_to_home_when_root_unset() {
+        // When GOOSE_PATH_ROOT is not set, goose_config_path() constructs a
+        // path under $HOME. We can verify the suffix without mutating env vars.
+        // If HOME is set (virtually all environments), the path ends with the
+        // expected goose config suffix.
+        if let Ok(home) = std::env::var("HOME") {
+            // Only run the check when GOOSE_PATH_ROOT is not already set, so
+            // this test doesn't interfere with the override logic.
+            if std::env::var("GOOSE_PATH_ROOT").is_err() {
+                let result = goose_config_path();
+                let expected = std::path::PathBuf::from(&home)
+                    .join(".config")
+                    .join("goose")
+                    .join("config.yaml");
+                assert_eq!(result, Some(expected));
+            }
+        }
+    }
+}