hydrate and replay mcp app payloads in goose2

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

Author: aharvard

crates/goose-acp/src/server.rs

@@ -1141,12 +1141,11 @@ impl GooseAcpAgent {
             }
         }
 
+        let update = ToolCallUpdate::new(ToolCallId::new(tool_response.id.clone()), fields)
+            .meta(extract_tool_call_update_meta(tool_response));
         cx.send_notification(SessionNotification::new(
             session_id.clone(),
-            SessionUpdate::ToolCallUpdate(ToolCallUpdate::new(
-                ToolCallId::new(tool_response.id.clone()),
-                fields,
-            )),
+            SessionUpdate::ToolCallUpdate(update),
         ))?;
 
         Ok(())
@@ -1238,6 +1237,16 @@ fn outcome_to_confirmation(outcome: &RequestPermissionOutcome) -> PermissionConf
     }
 }
 
+fn extract_tool_call_update_meta(
+    tool_response: &goose::conversation::message::ToolResponse,
+) -> Option<Meta> {
+    let tool_result = tool_response.tool_result.as_ref().ok()?;
+    let goose_meta = tool_result.meta.as_ref()?.0.get("goose")?.clone();
+    let mut meta_map = serde_json::Map::new();
+    meta_map.insert("goose".to_string(), goose_meta);
+    Some(meta_map)
+}
+
 fn build_tool_call_content(tool_result: &ToolResult<CallToolResult>) -> Vec<ToolCallContent> {
     match tool_result {
         Ok(result) => result
@@ -1654,12 +1663,12 @@ impl GooseAcpAgent {
                             }
                         }
 
+                        let update =
+                            ToolCallUpdate::new(ToolCallId::new(tool_response.id.clone()), fields)
+                                .meta(extract_tool_call_update_meta(tool_response));
                         cx.send_notification(SessionNotification::new(
                             args.session_id.clone(),
-                            SessionUpdate::ToolCallUpdate(ToolCallUpdate::new(
-                                ToolCallId::new(tool_response.id.clone()),
-                                fields,
-                            )),
+                            SessionUpdate::ToolCallUpdate(update),
                         ))?;
                     }
                     MessageContent::Thinking(thinking) => {

crates/goose/src/agents/extension_manager.rs

@@ -45,8 +45,8 @@ use crate::oauth::oauth_flow;
 use crate::prompt_template;
 use crate::subprocess::configure_subprocess;
 use rmcp::model::{
-    CallToolRequestParams, Content, ErrorCode, ErrorData, GetPromptResult, Prompt, Resource,
-    ResourceContents, ServerInfo, Tool,
+    CallToolRequestParams, CallToolResult, Content, ErrorCode, ErrorData, GetPromptResult, Meta,
+    Prompt, Resource, ResourceContents, ServerInfo, Tool,
 };
 use rmcp::transport::auth::AuthClient;
 use schemars::_private::NoSerialize;
@@ -121,6 +121,20 @@ pub struct ExtensionManagerCapabilities {
     pub host_info: Option<GooseMcpHostInfo>,
 }
 
+#[derive(Debug, Clone, serde::Serialize)]
+#[serde(rename_all = "camelCase")]
+pub struct GooseMcpAppToolAttachment {
+    pub tool_name: String,
+    pub extension_name: String,
+    pub resource_uri: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub tool_meta: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub resource_result: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub read_error: Option<String>,
+}
+
 /// Manages goose extensions / MCP clients and their interactions
 pub struct ExtensionManager {
     extensions: Mutex<HashMap<String, Extension>>,
@@ -214,6 +228,42 @@ pub fn get_tool_owner(tool: &Tool) -> Option<String> {
         .map(|s| s.to_string())
 }
 
+fn get_tool_meta_value(tool: &Tool) -> Option<Value> {
+    tool.meta.as_ref().map(|meta| Value::Object(meta.0.clone()))
+}
+
+fn get_tool_resource_uri(tool: &Tool) -> Option<String> {
+    tool.meta
+        .as_ref()
+        .and_then(|meta| meta.0.get("ui"))
+        .and_then(Value::as_object)
+        .and_then(|ui| ui.get("resourceUri"))
+        .and_then(Value::as_str)
+        .map(ToString::to_string)
+}
+
+fn merge_mcp_app_attachment_meta(
+    result: &mut CallToolResult,
+    attachment: &GooseMcpAppToolAttachment,
+) {
+    let mut meta_map = result
+        .meta
+        .as_ref()
+        .map(|meta| meta.0.clone())
+        .unwrap_or_default();
+    let mut goose_value = meta_map
+        .remove("goose")
+        .and_then(|value| value.as_object().cloned())
+        .unwrap_or_default();
+
+    goose_value.insert(
+        "mcpApp".to_string(),
+        serde_json::to_value(attachment).unwrap_or(Value::Null),
+    );
+    meta_map.insert("goose".to_string(), Value::Object(goose_value));
+    result.meta = Some(Meta(meta_map));
+}
+
 fn is_unprefixed_extension(config: &ExtensionConfig) -> bool {
     match config {
         ExtensionConfig::Platform { name, .. } | ExtensionConfig::Builtin { name, .. } => {
@@ -241,9 +291,12 @@ pub fn is_hidden_extension(name: &str) -> bool {
 
 /// Result of resolving a tool call to its owning extension
 struct ResolvedTool {
+    tool_name: String,
     extension_name: String,
     actual_tool_name: String,
     client: McpClientBox,
+    tool_meta: Option<Value>,
+    resource_uri: Option<String>,
 }
 
 async fn child_process_client(
@@ -969,6 +1022,55 @@ impl ExtensionManager {
         Ok(tools)
     }
 
+    fn host_supports_mcp_apps(&self) -> bool {
+        if let Some(host_info) = &self.capabilities.host_info {
+            if host_info.explicit_extensions {
+                return host_info.mcpui_enabled();
+            }
+        }
+
+        self.capabilities.mcpui
+    }
+
+    async fn hydrate_mcp_app_attachment(
+        client: &McpClientBox,
+        session_id: &str,
+        resolved_tool: &ResolvedTool,
+        cancellation_token: CancellationToken,
+        result: &mut CallToolResult,
+    ) {
+        if result.is_error == Some(true) {
+            return;
+        }
+
+        let Some(resource_uri) = resolved_tool.resource_uri.clone() else {
+            return;
+        };
+
+        let mut attachment = GooseMcpAppToolAttachment {
+            tool_name: resolved_tool.tool_name.clone(),
+            extension_name: resolved_tool.extension_name.clone(),
+            resource_uri: resource_uri.clone(),
+            tool_meta: resolved_tool.tool_meta.clone(),
+            resource_result: None,
+            read_error: None,
+        };
+
+        match client
+            .read_resource(session_id, &resource_uri, cancellation_token)
+            .await
+        {
+            Ok(resource_result) => {
+                attachment.resource_result = serde_json::to_value(&resource_result).ok();
+            }
+            Err(error) => {
+                attachment.read_error = Some(error.to_string());
+            }
+        }
+
+        merge_mcp_app_attachment_meta(result, &attachment);
+    }
+
     async fn invalidate_tools_cache_and_bump_version(&self) {
         self.tools_cache_version.fetch_add(1, Ordering::SeqCst);
         *self.tools_cache.lock().await = None;
@@ -1338,17 +1440,6 @@ impl ExtensionManager {
         session_id: &str,
         tool_name: &str,
     ) -> Result<ResolvedTool, ErrorData> {
-        if let Some((prefix, actual)) = tool_name.split_once("__") {
-            let owner = name_to_key(prefix);
-            if let Some(client) = self.get_server_client(&owner).await {
-                return Ok(ResolvedTool {
-                    extension_name: owner,
-                    actual_tool_name: actual.to_string(),
-                    client,
-                });
-            }
-        }
-
         let tools = self.get_all_tools_cached(session_id).await.map_err(|e| {
             ErrorData::new(
                 ErrorCode::INTERNAL_ERROR,
@@ -1358,13 +1449,19 @@ impl ExtensionManager {
         })?;
 
         if let Some(tool) = tools.iter().find(|t| *t.name == *tool_name) {
-            let owner = get_tool_owner(tool).ok_or_else(|| {
-                ErrorData::new(
-                    ErrorCode::RESOURCE_NOT_FOUND,
-                    format!("Tool '{}' has no owner", tool_name),
-                    None,
-                )
-            })?;
+            let owner = get_tool_owner(tool)
+                .or_else(|| {
+                    tool_name
+                        .split_once("__")
+                        .map(|(prefix, _)| name_to_key(prefix))
+                })
+                .ok_or_else(|| {
+                    ErrorData::new(
+                        ErrorCode::RESOURCE_NOT_FOUND,
+                        format!("Tool '{}' has no owner", tool_name),
+                        None,
+                    )
+                })?;
 
             let actual_tool_name = tool_name
                 .strip_prefix(&format!("{owner}__"))
@@ -1380,12 +1477,29 @@ impl ExtensionManager {
             })?;
 
             return Ok(ResolvedTool {
+                tool_name: tool.name.to_string(),
                 extension_name: owner,
                 actual_tool_name,
                 client,
+                tool_meta: get_tool_meta_value(tool),
+                resource_uri: get_tool_resource_uri(tool),
             });
         }
 
+        if let Some((prefix, actual)) = tool_name.split_once("__") {
+            let owner = name_to_key(prefix);
+            if let Some(client) = self.get_server_client(&owner).await {
+                return Ok(ResolvedTool {
+                    tool_name: tool_name.to_string(),
+                    extension_name: owner,
+                    actual_tool_name: actual.to_string(),
+                    client,
+                    tool_meta: None,
+                    resource_uri: None,
+                });
+            }
+        }
+
         Err(ErrorData::new(
             ErrorCode::RESOURCE_NOT_FOUND,
             format!("Tool '{}' not found", tool_name),
@@ -1421,8 +1535,13 @@ impl ExtensionManager {
 
         let arguments = tool_call.arguments.clone();
         let client = resolved.client.clone();
+        let hydration_client = client.clone();
         let notifications_receiver = client.subscribe().await;
-        let actual_tool_name = resolved.actual_tool_name;
+        let actual_tool_name = resolved.actual_tool_name.clone();
+        let resolved_tool = resolved;
+        let should_hydrate_mcp_app = self.host_supports_mcp_apps();
+        let read_cancellation_token = cancellation_token.clone();
+        let session_id = ctx.session_id.clone();
         let owned_ctx = ToolCallContext::new(
             ctx.session_id.clone(),
             ctx.working_dir.clone(),
@@ -1436,15 +1555,28 @@ impl ExtensionManager {
                 owned_ctx.session_id,
                 owned_ctx.working_dir,
             );
-            client
+            let mut result = client
                 .call_tool(&owned_ctx, &actual_tool_name, arguments, cancellation_token)
                 .await
                 .map_err(|e| match e {
                     ServiceError::McpError(error_data) => error_data,
                     _ => {
                         ErrorData::new(ErrorCode::INTERNAL_ERROR, e.to_string(), e.maybe_to_value())
                     }
-                })
+                })?;
+
+            if should_hydrate_mcp_app {
+                Self::hydrate_mcp_app_attachment(
+                    &hydration_client,
+                    &session_id,
+                    &resolved_tool,
+                    read_cancellation_token,
+                    &mut result,
+                )
+                .await;
+            }
+
+            Ok(result)
         };
 
         Ok(ToolCallResult {

ui/goose2/src/features/chat/hooks/replayBuffer.ts

@@ -35,6 +35,10 @@ export function getBufferedMessage(
   return replayBuffers.get(sessionId)?.find((m) => m.id === messageId);
 }
 
+export function getReplayBuffer(sessionId: string): Message[] | undefined {
+  return replayBuffers.get(sessionId);
+}
+
 export function getAndDeleteReplayBuffer(
   sessionId: string,
 ): Message[] | undefined {

ui/goose2/src/features/chat/ui/McpAppView.tsx

@@ -0,0 +1,22 @@
+import { CodeBlock } from "@/shared/ui/ai-elements/code-block";
+import { useTranslation } from "react-i18next";
+import type { McpAppPayload } from "@/shared/types/messages";
+
+interface McpAppViewProps {
+  payload: McpAppPayload;
+}
+
+export function McpAppView({ payload }: McpAppViewProps) {
+  const { t } = useTranslation("chat");
+
+  // Currently we just render the MCP App payload as JSON.
+  // Up next, we'll replace this with actual HTML rendering and host bridging.
+  return (
+    <div className="my-3" data-testid="mcp-app-view">
+      <div className="mb-2 text-muted-foreground text-xs uppercase tracking-wide">
+        {t("message.mcpAppUnderConstruction")}
+      </div>
+      <CodeBlock code={JSON.stringify(payload, null, 2)} language="json" />
+    </div>
+  );
+}

ui/goose2/src/features/chat/ui/MessageBubble.tsx

@@ -32,13 +32,15 @@ import {
 } from "@/shared/ui/ai-elements/reasoning";
 import { ToolChainCards, type ToolChainItem } from "./ToolChainCards";
 import { ClickableImage } from "./ClickableImage";
+import { McpAppView } from "./McpAppView";
 import { useArtifactLinkHandler } from "@/features/chat/hooks/useArtifactLinkHandler";
 import type {
   Message,
   MessageAttachment,
   MessageContent,
   TextContent,
   ImageContent,
+  McpAppContent,
   ToolResponseContent,
   ThinkingContent,
   ReasoningContent as ReasoningContentType,
@@ -224,6 +226,10 @@ function renderContentBlock(
     case "toolResponse":
       // Handled by groupContentSections toolChain rendering
       return null;
+    case "mcpApp": {
+      const mcpApp = content as McpAppContent;
+      return <McpAppView key={`mcp-app-${index}`} payload={mcpApp.payload} />;
+    }
     case "thinking": {
       const th = content as ThinkingContent;
       return (