[goose2] MCP Apps: translate ACP host capabilities into MCP initialization (#8623)

Signed-off-by: Andrew Harvard <aharvard@squareup.com>

Author: aharvard

crates/goose-cli/src/cli.rs

@@ -1,6 +1,7 @@
 use anyhow::Result;
 use clap::{Args, CommandFactory, Parser, Subcommand};
 use clap_complete::{generate, Shell as ClapShell};
+use goose::agents::GoosePlatform;
 use goose::builtin_extension::register_builtin_extensions;
 use goose::config::{Config, GooseMode};
 #[cfg(feature = "telemetry")]
@@ -1083,6 +1084,7 @@ async fn handle_serve_command(host: String, port: u16, builtins: Vec<String>) ->
         builtins,
         data_dir: Paths::data_dir(),
         config_dir: Paths::config_dir(),
+        goose_platform: GoosePlatform::GooseCli,
     }));
     let router = create_router(server);
 

crates/goose/src/acp/server.rs

@@ -3,7 +3,7 @@ use crate::acp::fs::AcpTools;
 use crate::acp::tools::AcpAwareToolMeta;
 use crate::acp::{PermissionDecision, ACP_CURRENT_MODEL};
 use crate::agents::extension::{Envs, PLATFORM_EXTENSIONS};
-use crate::agents::mcp_client::McpClientTrait;
+use crate::agents::mcp_client::{GooseMcpHostInfo, McpClientTrait};
 use crate::agents::platform_extensions::developer::DeveloperClient;
 use crate::agents::{Agent, AgentConfig, ExtensionConfig, GoosePlatform, SessionConfig};
 use crate::config::base::CONFIG_YAML_NAME;
@@ -59,6 +59,7 @@ use sacp::{
     Agent as SacpAgent, ByteStreams, Client, ConnectionTo, Dispatch, HandleDispatchFrom, Handled,
     Responder,
 };
+use serde::Deserialize;
 use std::collections::HashMap;
 use std::sync::Arc;
 use strum::{EnumMessage, VariantNames};
@@ -182,13 +183,15 @@ pub struct GooseAcpAgent {
     builtins: Vec<String>,
     client_fs_capabilities: OnceCell<FileSystemCapabilities>,
     client_terminal: OnceCell<bool>,
+    client_mcp_host_info: OnceCell<GooseMcpHostInfo>,
     config_dir: std::path::PathBuf,
     session_manager: Arc<SessionManager>,
     thread_manager: Arc<crate::session::ThreadManager>,
     permission_manager: Arc<PermissionManager>,
     goose_mode: GooseMode,
     disable_session_naming: bool,
     provider_inventory: ProviderInventoryService,
+    goose_platform: GoosePlatform,
 }
 
 /// Shorten a session/thread id for perf log correlation.
@@ -253,6 +256,52 @@ fn extract_timeout_from_meta(meta: &Option<Meta>) -> Option<u64> {
         .and_then(|v| v.as_u64())
 }
 
+#[derive(Debug, Default, Deserialize)]
+struct GooseClientMetaEnvelope {
+    #[serde(default)]
+    goose: Option<GooseClientMeta>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct GooseClientMeta {
+    #[serde(rename = "mcpHostCapabilities", default)]
+    mcp_host_capabilities: Option<GooseMcpHostCapabilities>,
+}
+
+#[derive(Debug, Default, Deserialize)]
+struct GooseMcpHostCapabilities {
+    #[serde(default)]
+    extensions: Option<rmcp::model::ExtensionCapabilities>,
+}
+
+fn extract_goose_client_meta(meta: &Meta) -> Option<GooseClientMetaEnvelope> {
+    serde_json::from_value(serde_json::Value::Object(meta.clone())).ok()
+}
+
+fn extract_client_mcp_host_info(args: &InitializeRequest) -> GooseMcpHostInfo {
+    let host_capabilities = args
+        .client_capabilities
+        .meta
+        .as_ref()
+        .and_then(extract_goose_client_meta)
+        .and_then(|meta| meta.goose)
+        .and_then(|goose| goose.mcp_host_capabilities);
+    let explicit_extensions = host_capabilities
+        .as_ref()
+        .and_then(|capabilities| capabilities.extensions.as_ref())
+        .is_some();
+    let extensions = host_capabilities
+        .and_then(|capabilities| capabilities.extensions)
+        .unwrap_or_default();
+
+    GooseMcpHostInfo {
+        explicit_extensions,
+        extensions,
+        client_name: args.client_info.as_ref().map(|info| info.name.clone()),
+        client_version: args.client_info.as_ref().map(|info| info.version.clone()),
+    }
+}
+
 fn mcp_server_to_extension_config(mcp_server: McpServer) -> Result<ExtensionConfig, String> {
     match mcp_server {
         McpServer::Stdio(stdio) => {
@@ -795,6 +844,7 @@ impl GooseAcpAgent {
         config_dir: std::path::PathBuf,
         goose_mode: GooseMode,
         disable_session_naming: bool,
+        goose_platform: GoosePlatform,
     ) -> Result<Self> {
         let session_manager = Arc::new(SessionManager::new(data_dir));
         let thread_manager = Arc::new(crate::session::ThreadManager::new(
@@ -809,13 +859,15 @@ impl GooseAcpAgent {
             builtins,
             client_fs_capabilities: OnceCell::new(),
             client_terminal: OnceCell::new(),
+            client_mcp_host_info: OnceCell::new(),
             config_dir,
             session_manager,
             thread_manager,
             permission_manager,
             goose_mode,
             disable_session_naming,
             provider_inventory,
+            goose_platform,
         })
     }
 
@@ -986,12 +1038,14 @@ impl GooseAcpAgent {
             .cloned()
             .unwrap_or_default();
         let client_terminal = self.client_terminal.get().copied().unwrap_or(false);
+        let client_mcp_host_info = self.client_mcp_host_info.get().cloned();
         let provider_factory = Arc::clone(&self.provider_factory);
         let disable_session_naming = self.disable_session_naming;
+        let goose_platform = self.goose_platform.clone();
 
         tokio::spawn(async move {
             let t_setup = std::time::Instant::now();
-
+            debug!(target: "perf", sid = %sid, "perf: agent_setup start (background)");
             // Shared config — read once, used by both phases.
             let config = match Config::new(config_dir.join(CONFIG_YAML_NAME), "goose") {
                 Ok(c) => c,
@@ -1005,14 +1059,17 @@ impl GooseAcpAgent {
 
             // ── Phase 1: create agent + init provider (fast, ~55ms) ──────
             let phase1: Result<Arc<Agent>, String> = async {
-                let agent = Arc::new(Agent::with_config(AgentConfig::new(
-                    session_manager,
-                    permission_manager,
-                    None,
-                    goose_mode,
-                    disable_session_naming,
-                    GoosePlatform::GooseCli,
-                )));
+                let agent = Arc::new(Agent::with_config(
+                    AgentConfig::new(
+                        session_manager,
+                        permission_manager,
+                        None,
+                        goose_mode,
+                        disable_session_naming,
+                        goose_platform,
+                    )
+                    .with_mcp_host_info(client_mcp_host_info),
+                ));
 
                 // Init provider — reuse the pre-resolved name + model when
                 // available (already computed in on_new_session), otherwise
@@ -1627,6 +1684,9 @@ impl GooseAcpAgent {
             .client_fs_capabilities
             .set(args.client_capabilities.fs.clone());
         let _ = self.client_terminal.set(args.client_capabilities.terminal);
+        let _ = self
+            .client_mcp_host_info
+            .set(extract_client_mcp_host_info(&args));
 
         let capabilities = AgentCapabilities::new()
             .load_session(true)
@@ -3962,6 +4022,7 @@ pub async fn run(builtins: Vec<String>) -> Result<()> {
             builtins,
             data_dir: Paths::data_dir(),
             config_dir: Paths::config_dir(),
+            goose_platform: GoosePlatform::GooseCli,
         },
     );
     let agent = server.create_agent().await?;

crates/goose/src/acp/server_factory.rs

@@ -1,4 +1,5 @@
 use crate::acp::server::{AcpProviderFactory, GooseAcpAgent};
+use crate::agents::GoosePlatform;
 use anyhow::Result;
 use std::sync::Arc;
 use tracing::info;
@@ -7,6 +8,7 @@ pub struct AcpServerFactoryConfig {
     pub builtins: Vec<String>,
     pub data_dir: std::path::PathBuf,
     pub config_dir: std::path::PathBuf,
+    pub goose_platform: GoosePlatform,
 }
 
 pub struct AcpServer {
@@ -44,6 +46,7 @@ impl AcpServer {
             self.config.config_dir.clone(),
             goose_mode,
             disable_session_naming,
+            self.config.goose_platform.clone(),
         )
         .await?;
         info!("Created new ACP agent");

crates/goose/src/agents/agent.rs

@@ -12,6 +12,7 @@ use uuid::Uuid;
 
 use super::container::Container;
 use super::final_output_tool::FinalOutputTool;
+use super::mcp_client::GooseMcpHostInfo;
 use super::platform_tools;
 use super::tool_confirmation_router::ToolConfirmationRouter;
 use super::tool_execution::{ToolCallResult, CHAT_MODE_TOOL_SKIPPED_RESPONSE, DECLINED_RESPONSE};
@@ -114,6 +115,7 @@ pub struct AgentConfig {
     pub goose_mode: GooseMode,
     pub disable_session_naming: bool,
     pub goose_platform: GoosePlatform,
+    pub mcp_host_info: Option<GooseMcpHostInfo>,
 }
 
 impl AgentConfig {
@@ -132,8 +134,14 @@ impl AgentConfig {
             goose_mode,
             disable_session_naming,
             goose_platform,
+            mcp_host_info: None,
         }
     }
+
+    pub fn with_mcp_host_info(mut self, mcp_host_info: Option<GooseMcpHostInfo>) -> Self {
+        self.mcp_host_info = mcp_host_info;
+        self
+    }
 }
 
 /// The main goose Agent
@@ -223,10 +231,23 @@ impl Agent {
 
         let goose_platform = config.goose_platform.clone();
         let initial_mode = config.goose_mode;
-        let capabilities = match config.goose_platform {
-            GoosePlatform::GooseDesktop => ExtensionManagerCapabilities { mcpui: true },
-            GoosePlatform::GooseCli => ExtensionManagerCapabilities { mcpui: false },
+        let explicit_mcp_host_info = config.mcp_host_info.clone();
+        let mcpui = explicit_mcp_host_info
+            .as_ref()
+            .filter(|host_info| host_info.explicit_extensions)
+            .map(GooseMcpHostInfo::mcpui_enabled)
+            .unwrap_or_else(|| match config.goose_platform {
+                GoosePlatform::GooseDesktop => true,
+                GoosePlatform::GooseCli => false,
+            });
+        let capabilities = ExtensionManagerCapabilities {
+            mcpui,
+            host_info: explicit_mcp_host_info.clone(),
         };
+        let client_name = explicit_mcp_host_info
+            .as_ref()
+            .and_then(|host_info| host_info.client_name.clone())
+            .unwrap_or_else(|| goose_platform.to_string());
         let session_manager = Arc::clone(&config.session_manager);
         let permission_manager = Arc::clone(&config.permission_manager);
         Self {
@@ -236,7 +257,7 @@ impl Agent {
             extension_manager: Arc::new(ExtensionManager::new(
                 provider.clone(),
                 session_manager,
-                goose_platform.to_string(),
+                client_name,
                 capabilities,
             )),
             final_output_tool: Arc::new(Mutex::new(None)),