@assistant-ui/react-ag-ui 0.0.45 → 0.0.47

package/dist/runtime/mcp-tool-result.js

@@ -0,0 +1,26 @@
+import { isRecord } from "@assistant-ui/core/internal";
+import { isMcpAppUri } from "@assistant-ui/core";
+//#region src/runtime/mcp-tool-result.ts
+const parseMcpToolCallResult = (source, modelContent) => {
+	const structuredContent = isRecord(source.structuredContent) ? source.structuredContent : void 0;
+	const meta = isRecord(source._meta) ? source._meta : void 0;
+	if (!structuredContent && !meta) return void 0;
+	return {
+		content: modelContent ? [{
+			type: "text",
+			text: modelContent
+		}] : [],
+		...structuredContent ? { structuredContent } : {},
+		...meta ? { _meta: meta } : {},
+		...typeof source.isError === "boolean" ? { isError: source.isError } : {}
+	};
+};
+const readMcpAppResourceUri = (meta) => {
+	if (!isRecord(meta)) return void 0;
+	const uri = meta["ui/resourceUri"];
+	return typeof uri === "string" && isMcpAppUri(uri) ? uri : void 0;
+};
+//#endregion
+export { parseMcpToolCallResult, readMcpAppResourceUri };
+
+//# sourceMappingURL=mcp-tool-result.js.map

package/dist/runtime/mcp-tool-result.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mcp-tool-result.js","names":[],"sources":["../../src/runtime/mcp-tool-result.ts"],"sourcesContent":["import { isRecord } from \"@assistant-ui/core/internal\";\nimport { isMcpAppUri } from \"@assistant-ui/core\";\n\nexport type McpToolCallResult = Record<string, unknown> & {\n  content: unknown[];\n  structuredContent?: Record<string, unknown>;\n  _meta?: Record<string, unknown>;\n  isError?: boolean;\n};\n\nexport const parseMcpToolCallResult = (\n  source: Record<string, unknown>,\n  modelContent: string,\n): McpToolCallResult | undefined => {\n  const structuredContent = isRecord(source.structuredContent)\n    ? source.structuredContent\n    : undefined;\n  const meta = isRecord(source._meta) ? source._meta : undefined;\n  if (!structuredContent && !meta) return undefined;\n\n  return {\n    content: modelContent ? [{ type: \"text\", text: modelContent }] : [],\n    ...(structuredContent ? { structuredContent } : {}),\n    ...(meta ? { _meta: meta } : {}),\n    ...(typeof source.isError === \"boolean\" ? { isError: source.isError } : {}),\n  };\n};\n\n// _meta[\"ui/resourceUri\"] is the MCP-UI pointer react-ai-sdk reads off\n// CallToolResult._meta; only ui:// URIs identify an MCP Apps widget. A\n// structured carrier is deliberately not read until upstream AG-UI settles\n// one (agno-agi/agno#9087).\nexport const readMcpAppResourceUri = (meta: unknown): string | undefined => {\n  if (!isRecord(meta)) return undefined;\n  const uri = meta[\"ui/resourceUri\"];\n  return typeof uri === \"string\" && isMcpAppUri(uri) ? uri : undefined;\n};\n"],"mappings":";;;AAUA,MAAa,0BACX,QACA,iBACkC;CAClC,MAAM,oBAAoB,SAAS,OAAO,iBAAiB,IACvD,OAAO,oBACP,KAAA;CACJ,MAAM,OAAO,SAAS,OAAO,KAAK,IAAI,OAAO,QAAQ,KAAA;CACrD,IAAI,CAAC,qBAAqB,CAAC,MAAM,OAAO,KAAA;CAExC,OAAO;EACL,SAAS,eAAe,CAAC;GAAE,MAAM;GAAQ,MAAM;EAAa,CAAC,IAAI,CAAC;EAClE,GAAI,oBAAoB,EAAE,kBAAkB,IAAI,CAAC;EACjD,GAAI,OAAO,EAAE,OAAO,KAAK,IAAI,CAAC;EAC9B,GAAI,OAAO,OAAO,YAAY,YAAY,EAAE,SAAS,OAAO,QAAQ,IAAI,CAAC;CAC3E;AACF;AAMA,MAAa,yBAAyB,SAAsC;CAC1E,IAAI,CAAC,SAAS,IAAI,GAAG,OAAO,KAAA;CAC5B,MAAM,MAAM,KAAK;CACjB,OAAO,OAAO,QAAQ,YAAY,YAAY,GAAG,IAAI,MAAM,KAAA;AAC7D"}

package/dist/runtime/types.d.ts

@@ -1,4 +1,5 @@
 import { Logger } from "./logger.js";
+import { McpToolCallResult } from "./mcp-tool-result.js";
 import { AttachmentAdapter, CreateAppendMessage, DictationAdapter, ExternalStoreSharedOptions, ExternalStoreThreadListAdapter, FeedbackAdapter, RealtimeVoiceAdapter, SpeechSynthesisAdapter, ThreadHistoryAdapter, ThreadMessage } from "@assistant-ui/core";
 import { AbstractAgent } from "@ag-ui/client";
 import { ReadonlyJSONValue } from "assistant-stream/utils";
@@ -160,6 +161,7 @@ type AgUiEvent = {
   toolCallId: string;
   content: string;
   role?: "tool";
+  mcpResult?: McpToolCallResult;
 } | {
   type: "ACTIVITY_SNAPSHOT";
   activityType: string;

package/dist/runtime/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/runtime/types.ts"],"mappings":";;;;;;;;;;;KAsBK;EACH,mBAAmB;EACnB,QAAQ;;;;;;EAMR;;KAGU,2BAA2B,KACrC;EAGA,qBAEM,qBACG,QAAQ,wBAAwB;;KAI/B;EACV,cAAc;EACd,SAAS;EACT,YAAY;EACZ,QAAQ;EACR,WAAW;EACX,UAAU;;;;EAIV,aAAa;;KAGH,wBAAwB;EAClC,OAAO;EACP,SAAS,QAAQ;EACjB;;;;;;;;;;;EAWA;EACA,WAAW,GAAG;EACd;EACA,WAAW;;KAGD;KAMA;EACV;EACA,QAAQ;EACR;EACA;EACA,iBAAiB;EACjB;EACA,WAAW;;KAGD;EACV;EACA;EACA;;KAGU;EACV,qBAAqB;EACrB,2BACE,oBAAoB,sBACjB;EACL,YACE,SAAS,qBACT,qBAAqB,sBAClB;EACL,OAAO;EACP,WACE,MACI,sBACE,MAAM,kCAAkC;;KAItC;EACN;;EACA;EAAmB,YAAY;;KAEzB;EACN;EAAqB;;EAErB;EACA;EACA,UAAU;;EAEV;EAAuB;;EACvB;EAAmB;EAAkB;;EACrC;EAA4B;;EAC5B;EAA8B;EAAoB;;EAClD;EAA0B;;EAC1B;EAA4B;;EAC5B;EAAwB;;EACxB;;EACA;EAAuC;;EACvC;;EACA;;EACA;EAAyB;;EACzB;EAAiC;;EACjC;EAAmC;EAAoB;;EACvD;EAA+B;;EAC/B;EAAuB;;EAEvB;EACA;EACA;EACA;;EAEA;EAAwB;EAAoB;;EAC5C;EAAuB;;EAEvB;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA,SAAS;;EAET;EAAa;EAAY;;EACzB;EAAgB;EAAc;;EAC9B;EAAwB;;EACxB;EAAqB;;EACrB;EAA2B"}
+{"version":3,"file":"types.d.ts","names":[],"sources":["../../src/runtime/types.ts"],"mappings":";;;;;;;;;;;;KAuBK;EACH,mBAAmB;EACnB,QAAQ;;;;;;EAMR;;KAGU,2BAA2B,KACrC;EAGA,qBAEM,qBACG,QAAQ,wBAAwB;;KAI/B;EACV,cAAc;EACd,SAAS;EACT,YAAY;EACZ,QAAQ;EACR,WAAW;EACX,UAAU;;;;EAIV,aAAa;;KAGH,wBAAwB;EAClC,OAAO;EACP,SAAS,QAAQ;EACjB;;;;;;;;;;;EAWA;EACA,WAAW,GAAG;EACd;EACA,WAAW;;KAGD;KAMA;EACV;EACA,QAAQ;EACR;EACA;EACA,iBAAiB;EACjB;EACA,WAAW;;KAGD;EACV;EACA;EACA;;KAGU;EACV,qBAAqB;EACrB,2BACE,oBAAoB,sBACjB;EACL,YACE,SAAS,qBACT,qBAAqB,sBAClB;EACL,OAAO;EACP,WACE,MACI,sBACE,MAAM,kCAAkC;;KAItC;EACN;;EACA;EAAmB,YAAY;;KAEzB;EACN;EAAqB;;EAErB;EACA;EACA,UAAU;;EAEV;EAAuB;;EACvB;EAAmB;EAAkB;;EACrC;EAA4B;;EAC5B;EAA8B;EAAoB;;EAClD;EAA0B;;EAC1B;EAA4B;;EAC5B;EAAwB;;EACxB;;EACA;EAAuC;;EACvC;;EACA;;EACA;EAAyB;;EACzB;EAAiC;;EACjC;EAAmC;EAAoB;;EACvD;EAA+B;;EAC/B;EAAuB;;EAEvB;EACA;EACA;EACA;;EAEA;EAAwB;EAAoB;;EAC5C;EAAuB;;EAEvB;EACA;EACA;EACA;EACA;;EAGA;EACA;EACA;EACA;EACA;EACA,YAAY;;EAGZ;EACA;EACA,SAAS;;EAET;EAAa;EAAY;;EACzB;EAAgB;EAAc;;EAC9B;EAAwB;;EACxB;EAAqB;;EACrB;EAA2B"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@assistant-ui/react-ag-ui",
-  "version": "0.0.45",
+  "version": "0.0.47",
   "description": "AG-UI protocol adapter for assistant-ui",
   "keywords": [
     "ag-ui",
@@ -30,9 +30,9 @@
   "sideEffects": false,
   "dependencies": {
     "@ag-ui/client": "^0.0.57",
-    "@assistant-ui/core": "^0.2.21",
-    "@assistant-ui/store": "^0.2.20",
-    "assistant-stream": "^0.3.26",
+    "@assistant-ui/core": "^0.2.23",
+    "@assistant-ui/store": "^0.2.22",
+    "assistant-stream": "^0.3.28",
     "fast-json-patch": "^3.1.1"
   },
   "peerDependencies": {
@@ -46,10 +46,10 @@
   },
   "devDependencies": {
     "@types/react": "^19.2.17",
-    "react": "^19.2.7",
+    "react": "^19.2.8",
     "vitest": "^4.1.10",
     "zod": "^4.4.3",
-    "@assistant-ui/x-buildutils": "0.0.18"
+    "@assistant-ui/x-buildutils": "0.0.20"
   },
   "publishConfig": {
     "access": "public",

package/src/runtime/AgUiThreadRuntimeCore.ts

@@ -1,6 +1,10 @@
 "use client";
 
-import { generateId, fromThreadMessageLike } from "@assistant-ui/core";
+import {
+  generateId,
+  fromThreadMessageLike,
+  isMcpAppUri,
+} from "@assistant-ui/core";
 import type {
   AddToolResultOptions,
   AppendMessage,
@@ -19,11 +23,14 @@ import { MessageRepository } from "@assistant-ui/core/internal";
 import type { AbstractAgent } from "@ag-ui/client";
 import jsonpatch, { type Operation } from "fast-json-patch";
 import type { Logger } from "./logger";
+import { readMcpAppResourceUri } from "./mcp-tool-result";
 import type { AgUiEvent, AgUiInterrupt, AgUiResumeEntry } from "./types";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
 import {
   AG_UI_METADATA_NAMESPACE,
   type AgUiCustomMetadata,
+  isPlainObject,
+  MCP_APPS_ACTIVITY_TYPE,
   RunAggregator,
   tryParseJSON,
 } from "./adapter/run-aggregator";
@@ -425,25 +432,11 @@ export class AgUiThreadRuntimeCore {
       );
     }
 
-    const responsesById = new Map<string, AgUiResumeEntry>();
-    for (const entry of responses) {
-      if (!entry || typeof entry.interruptId !== "string") {
-        throw new Error(
-          "[agui] submitInterruptResponses: every entry must have an interruptId",
-        );
-      }
-      if (entry.status !== "resolved" && entry.status !== "cancelled") {
-        throw new Error(
-          `[agui] submitInterruptResponses: invalid status "${entry.status}" for interrupt ${entry.interruptId}`,
-        );
-      }
-      if (responsesById.has(entry.interruptId)) {
-        throw new Error(
-          `[agui] submitInterruptResponses: duplicate response for interrupt ${entry.interruptId}`,
-        );
-      }
-      responsesById.set(entry.interruptId, entry);
-    }
+    const responsesById = this.collectInterruptResponses(
+      "submitInterruptResponses",
+      pending.interrupts,
+      responses,
+    );
 
     const openIds = pending.interrupts.map((i) => i.id);
     const missing = openIds.filter((id) => !responsesById.has(id));
@@ -452,13 +445,6 @@ export class AgUiThreadRuntimeCore {
         `[agui] submitInterruptResponses: missing responses for open interrupts: ${missing.join(", ")}`,
       );
     }
-    const known = new Set(openIds);
-    const unknownIds = [...responsesById.keys()].filter((id) => !known.has(id));
-    if (unknownIds.length > 0) {
-      throw new Error(
-        `[agui] submitInterruptResponses: unknown interrupt ids: ${unknownIds.join(", ")}`,
-      );
-    }
 
     const now = Date.now();
     for (const interrupt of pending.interrupts) {
@@ -538,35 +524,51 @@ export class AgUiThreadRuntimeCore {
     interrupts: readonly AgUiInterrupt[],
     responses: readonly AgUiResumeEntry[] | undefined,
   ): AgUiResumeEntry[] {
-    const openIds = interrupts.map((interrupt) => interrupt.id);
-    const known = new Set(openIds);
+    const responsesById = this.collectInterruptResponses(
+      "steerAway",
+      interrupts,
+      responses ?? [],
+    );
+    return interrupts.map(
+      (interrupt) =>
+        responsesById.get(interrupt.id) ?? {
+          interruptId: interrupt.id,
+          status: "cancelled",
+        },
+    );
+  }
+
+  private collectInterruptResponses(
+    method: "submitInterruptResponses" | "steerAway",
+    interrupts: readonly AgUiInterrupt[],
+    responses: readonly AgUiResumeEntry[],
+  ): Map<string, AgUiResumeEntry> {
+    const known = new Set(interrupts.map((interrupt) => interrupt.id));
     const responsesById = new Map<string, AgUiResumeEntry>();
-    for (const entry of responses ?? []) {
+    for (const entry of responses) {
       if (!entry || typeof entry.interruptId !== "string") {
         throw new Error(
-          "[agui] steerAway: every response must have an interruptId",
+          `[agui] ${method}: every entry must have an interruptId`,
         );
       }
       if (entry.status !== "resolved" && entry.status !== "cancelled") {
         throw new Error(
-          `[agui] steerAway: invalid status "${entry.status}" for interrupt ${entry.interruptId}`,
+          `[agui] ${method}: invalid status "${entry.status}" for interrupt ${entry.interruptId}`,
         );
       }
       if (!known.has(entry.interruptId)) {
         throw new Error(
-          `[agui] steerAway: unknown interrupt id ${entry.interruptId}`,
+          `[agui] ${method}: unknown interrupt id ${entry.interruptId}`,
         );
       }
       if (responsesById.has(entry.interruptId)) {
         throw new Error(
-          `[agui] steerAway: duplicate response for interrupt ${entry.interruptId}`,
+          `[agui] ${method}: duplicate response for interrupt ${entry.interruptId}`,
         );
       }
       responsesById.set(entry.interruptId, entry);
     }
-    return openIds.map(
-      (id) => responsesById.get(id) ?? { interruptId: id, status: "cancelled" },
-    );
+    return responsesById;
   }
 
   private toAppendMessage(message: CreateAppendMessage): AppendMessage {
@@ -1344,6 +1346,22 @@ export class AgUiThreadRuntimeCore {
         aggregator.handle(event);
         return;
       }
+      case "ACTIVITY_SNAPSHOT": {
+        const toolCallId = event.content["toolCallId"];
+        if (
+          event.activityType === MCP_APPS_ACTIVITY_TYPE &&
+          typeof toolCallId === "string" &&
+          !aggregator.hasToolCall(toolCallId)
+        ) {
+          const messageId = this.findMessageIdForToolCall(toolCallId);
+          if (messageId !== undefined) {
+            this.applyCrossRunActivitySnapshot(messageId, toolCallId, event);
+            return;
+          }
+        }
+        aggregator.handle(event);
+        return;
+      }
       default:
         aggregator.handle(event);
     }
@@ -1356,15 +1374,58 @@ export class AgUiThreadRuntimeCore {
     const updated = this.updateMessage(messageId, (message) => {
       if (message.role !== "assistant") return message;
       const assistant = message as ThreadAssistantMessage;
+      const mcpAppUri = readMcpAppResourceUri(event.mcpResult?._meta);
       let matchedToolCall = false;
       const content = assistant.content.map((part) => {
         if (part.type !== "tool-call" || part.toolCallId !== event.toolCallId)
           return part;
         matchedToolCall = true;
+        // An applied activity snapshot owns part.result; a later result only
+        // fills what is missing, mirroring the aggregator's finishToolCall.
+        // The aggregator's flag is set only when the snapshot carried a
+        // result, so app presence alone is not enough: the current result
+        // must be CallToolResult-shaped (a required content array).
+        const snapshotResultApplied =
+          part.mcp?.app !== undefined &&
+          isPlainObject(part.result) &&
+          Array.isArray((part.result as Record<string, unknown>)["content"]);
+        if (snapshotResultApplied) {
+          return {
+            ...part,
+            ...(part.modelContent === undefined && event.content
+              ? {
+                  modelContent: [
+                    { type: "text" as const, text: event.content },
+                  ],
+                }
+              : {}),
+            ...(part.isError === undefined
+              ? typeof event.mcpResult?.isError === "boolean"
+                ? { isError: event.mcpResult.isError }
+                : event.role === "tool"
+                  ? { isError: false }
+                  : {}
+              : {}),
+            ...(event.messageId
+              ? { unstable_toolMessageId: event.messageId }
+              : {}),
+          };
+        }
         return {
           ...part,
-          result: tryParseJSON(event.content ?? "") as ReadonlyJSONValue,
-          ...(event.role === "tool" ? { isError: false } : {}),
+          result: (event.mcpResult ??
+            tryParseJSON(event.content ?? "")) as ReadonlyJSONValue,
+          ...(event.mcpResult !== undefined
+            ? { modelContent: [{ type: "text" as const, text: event.content }] }
+            : {}),
+          ...(typeof event.mcpResult?.isError === "boolean"
+            ? { isError: event.mcpResult.isError }
+            : event.role === "tool"
+              ? { isError: false }
+              : {}),
+          ...(part.mcp === undefined && mcpAppUri !== undefined
+            ? { mcp: { app: { resourceUri: mcpAppUri } } }
+            : {}),
           ...(event.messageId
             ? { unstable_toolMessageId: event.messageId }
             : {}),
@@ -1381,6 +1442,68 @@ export class AgUiThreadRuntimeCore {
     this.maybeCompleteAfterToolResults(messageId);
   }
 
+  private applyCrossRunActivitySnapshot(
+    messageId: string,
+    toolCallId: string,
+    event: Extract<AgUiEvent, { type: "ACTIVITY_SNAPSHOT" }>,
+  ): void {
+    const resourceUri = event.content["resourceUri"];
+    if (typeof resourceUri !== "string" || !isMcpAppUri(resourceUri)) return;
+    const serverId = event.content["serverId"];
+    const serverHash = event.content["serverHash"];
+    const appServerId =
+      typeof serverId === "string" && serverId.length > 0
+        ? serverId
+        : typeof serverHash === "string" && serverHash.length > 0
+          ? serverHash
+          : undefined;
+    const result = event.content["result"];
+    const updated = this.updateMessage(messageId, (message) => {
+      if (message.role !== "assistant") return message;
+      const assistant = message as ThreadAssistantMessage;
+      let matchedToolCall = false;
+      const content = assistant.content.map((part) => {
+        if (part.type !== "tool-call" || part.toolCallId !== toolCallId)
+          return part;
+        matchedToolCall = true;
+        return {
+          ...part,
+          mcp: {
+            app: {
+              resourceUri,
+              ...(appServerId ? { serverId: appServerId } : {}),
+            },
+          },
+          ...(isPlainObject(result)
+            ? {
+                ...(part.result !== undefined && part.modelContent === undefined
+                  ? {
+                      modelContent: [
+                        {
+                          type: "text" as const,
+                          text:
+                            typeof part.result === "string"
+                              ? part.result
+                              : JSON.stringify(part.result),
+                        },
+                      ],
+                    }
+                  : {}),
+                result: result as ReadonlyJSONValue,
+                isError: result["isError"] === true,
+              }
+            : {}),
+        };
+      });
+      if (!matchedToolCall) return message;
+      return { ...assistant, content };
+    });
+
+    if (!updated) return;
+    this.notifyUpdate();
+    this.maybeCompleteAfterToolResults(messageId);
+  }
+
   private importMessagesSnapshot(rawMessages: readonly unknown[]) {
     try {
       const normalized = fromAgUiMessages(rawMessages, {

package/src/runtime/adapter/conversions.ts

@@ -3,9 +3,14 @@
 import type { InputContent } from "@ag-ui/client";
 import type {
   ThreadMessageLike as CoreThreadMessageLike,
+  ToolCallMessagePartMcpMetadata,
   ToolModelContentPart,
 } from "@assistant-ui/core";
-import { getAutoStatus } from "@assistant-ui/core/internal";
+import {
+  getAutoStatus,
+  httpUrlPattern,
+  parseDataUrl,
+} from "@assistant-ui/core/internal";
 import { type Tool, toToolsJSONSchema } from "assistant-stream";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
 import {
@@ -13,6 +18,10 @@ import {
   type AgUiCustomMetadata,
 } from "./run-aggregator";
 import type { AgUiInterrupt } from "../types";
+import {
+  parseMcpToolCallResult,
+  readMcpAppResourceUri,
+} from "../mcp-tool-result";
 
 export type { InputContent };
 
@@ -64,6 +73,7 @@ type ToolCallPart = {
   isError?: boolean;
   modelContent?: readonly ToolModelContentPart[];
   unstable_toolMessageId?: string;
+  mcp?: ToolCallMessagePartMcpMetadata;
 };
 
 const isObject = (value: unknown): value is Record<string, unknown> =>
@@ -129,16 +139,6 @@ function extractText(content: unknown): string {
     .join("\n");
 }
 
-function parseDataUrl(
-  value: string,
-): { mimeType: string; data: string } | null {
-  const match = value.match(/^data:([^;,]+)(?:;[^;,]+)*;base64,(.+)$/);
-  if (!match) return null;
-  return { mimeType: match[1]!, data: match[2]! };
-}
-
-const httpUrlPattern = /^https?:\/\//i;
-
 type InputContentSource =
   | { type: "data"; value: string; mimeType: string }
   | { type: "url"; value: string; mimeType?: string };
@@ -540,12 +540,18 @@ export function fromAgUiMessages(
     if (role === "tool") {
       const toolCallId = getToolCallId(rawMessage) ?? `tool-${generateId()}`;
       const toolMessageId = getString(rawMessage, "id");
+      const modelContent = extractText(rawMessage.content);
+      const mcpResult = parseMcpToolCallResult(rawMessage, modelContent);
+      const mcpModelContent = mcpResult
+        ? [{ type: "text" as const, text: modelContent }]
+        : undefined;
       const result =
-        rawMessage.result !== undefined
+        mcpResult ??
+        (rawMessage.result !== undefined
           ? rawMessage.result
           : typeof rawMessage.content === "string"
             ? parseJSONText(rawMessage.content)
-            : rawMessage.content;
+            : rawMessage.content);
       const isError =
         typeof rawMessage.error === "string" ||
         rawMessage.isError === true ||
@@ -554,6 +560,9 @@ export function fromAgUiMessages(
           : rawMessage.isError === false
             ? false
             : undefined;
+      const mcpAppUri = readMcpAppResourceUri(mcpResult?._meta);
+      const mcpApp =
+        mcpAppUri !== undefined ? { resourceUri: mcpAppUri } : undefined;
 
       let updated = false;
       for (
@@ -581,10 +590,12 @@ export function fromAgUiMessages(
           const updatedPart: ToolCallPart = {
             ...(part as ToolCallPart),
             result,
+            ...(mcpModelContent ? { modelContent: mcpModelContent } : {}),
             ...(isError !== undefined ? { isError } : {}),
             ...(toolMessageId !== undefined
               ? { unstable_toolMessageId: toolMessageId }
               : {}),
+            ...(mcpApp ? { mcp: { app: mcpApp } } : {}),
           };
           const updatedContent = message.content.map((contentPart, index) =>
             index === partIndex ? updatedPart : contentPart,
@@ -615,10 +626,12 @@ export function fromAgUiMessages(
             args: {},
             argsText: "{}",
             result,
+            ...(mcpModelContent ? { modelContent: mcpModelContent } : {}),
             ...(isError !== undefined ? { isError } : {}),
             ...(toolMessageId !== undefined
               ? { unstable_toolMessageId: toolMessageId }
               : {}),
+            ...(mcpApp ? { mcp: { app: mcpApp } } : {}),
           },
         ],
       });
@@ -719,10 +732,9 @@ function convertAssistantMessage(
   for (const { id: toolCallId, part } of toolCalls) {
     if (part.result === undefined) continue;
 
-    const modelText = extractText(part.modelContent);
     const resultContent =
-      modelText.length > 0
-        ? modelText
+      part.modelContent !== undefined
+        ? extractText(part.modelContent)
         : typeof part.result === "string"
           ? part.result
           : JSON.stringify(part.result);

package/src/runtime/adapter/run-aggregator.ts

@@ -8,6 +8,7 @@ import {
   type ToolCallMessagePart,
   type ToolModelContentPart,
 } from "@assistant-ui/core";
+import { readMcpAppResourceUri } from "../mcp-tool-result";
 import type { AgUiEvent, AgUiInterrupt } from "../types";
 import type { Logger } from "../logger";
 
@@ -34,9 +35,11 @@ type ToolCallState = {
   snapshotResultApplied: boolean;
 };
 
-const MCP_APPS_ACTIVITY_TYPE = "mcp-apps";
+export const MCP_APPS_ACTIVITY_TYPE = "mcp-apps";
 
-const isPlainObject = (value: unknown): value is Record<string, unknown> =>
+export const isPlainObject = (
+  value: unknown,
+): value is Record<string, unknown> =>
   !!value && typeof value === "object" && !Array.isArray(value);
 
 export type RunAggregatorOptions = {
@@ -235,8 +238,13 @@ export class RunAggregator {
         this.finishToolCall(
           event.toolCallId,
           event.content ?? "",
-          event.role === "tool" ? false : undefined,
+          typeof event.mcpResult?.isError === "boolean"
+            ? event.mcpResult.isError
+            : event.role === "tool"
+              ? false
+              : undefined,
           event.messageId,
+          event.mcpResult,
         );
         this.emit();
         break;
@@ -442,6 +450,7 @@ export class RunAggregator {
     content: string,
     isError?: boolean,
     toolMessageId?: string,
+    mcpResult?: Record<string, unknown>,
   ) {
     if (!id) return;
     let entry = this.toolCalls.get(id);
@@ -464,7 +473,16 @@ export class RunAggregator {
     ) {
       this.partOrder.push({ kind: "tool-call", toolCallId: id });
     }
-    if (entry.snapshotResultApplied) {
+    if (mcpResult !== undefined && !entry.snapshotResultApplied) {
+      entry.result = mcpResult;
+      entry.modelContent = [{ type: "text", text: content }];
+      entry.snapshotResultApplied = true;
+      entry.isError = isError;
+      if (entry.mcpAppResourceUri === undefined) {
+        const uri = readMcpAppResourceUri(mcpResult._meta);
+        if (uri !== undefined) entry.mcpAppResourceUri = uri;
+      }
+    } else if (entry.snapshotResultApplied) {
       if (entry.modelContent === undefined) {
         entry.modelContent = [{ type: "text", text: content }];
       }

package/src/runtime/event-parser.ts

@@ -1,5 +1,6 @@
 import type { AgUiEvent, AgUiInterrupt, AgUiRunFinishedOutcome } from "./types";
 import type { Logger } from "./logger";
+import { parseMcpToolCallResult } from "./mcp-tool-result";
 
 export type ParseAgUiEventOptions = {
   logger?: Logger;
@@ -209,15 +210,17 @@ export const parseAgUiEvent = (
     case "TOOL_CALL_RESULT": {
       const toolCallId = getString("toolCallId");
       if (!toolCallId) return null;
+      const content = getString("content") ?? "";
       return withOptional(
         {
           type: "TOOL_CALL_RESULT" as const,
           toolCallId,
-          content: getString("content") ?? "",
+          content,
         },
         {
           messageId: getString("messageId"),
           role: payload.role === "tool" ? "tool" : undefined,
+          mcpResult: parseMcpToolCallResult(payload, content),
         },
       );
     }

package/src/runtime/mcp-tool-result.ts

@@ -0,0 +1,37 @@
+import { isRecord } from "@assistant-ui/core/internal";
+import { isMcpAppUri } from "@assistant-ui/core";
+
+export type McpToolCallResult = Record<string, unknown> & {
+  content: unknown[];
+  structuredContent?: Record<string, unknown>;
+  _meta?: Record<string, unknown>;
+  isError?: boolean;
+};
+
+export const parseMcpToolCallResult = (
+  source: Record<string, unknown>,
+  modelContent: string,
+): McpToolCallResult | undefined => {
+  const structuredContent = isRecord(source.structuredContent)
+    ? source.structuredContent
+    : undefined;
+  const meta = isRecord(source._meta) ? source._meta : undefined;
+  if (!structuredContent && !meta) return undefined;
+
+  return {
+    content: modelContent ? [{ type: "text", text: modelContent }] : [],
+    ...(structuredContent ? { structuredContent } : {}),
+    ...(meta ? { _meta: meta } : {}),
+    ...(typeof source.isError === "boolean" ? { isError: source.isError } : {}),
+  };
+};
+
+// _meta["ui/resourceUri"] is the MCP-UI pointer react-ai-sdk reads off
+// CallToolResult._meta; only ui:// URIs identify an MCP Apps widget. A
+// structured carrier is deliberately not read until upstream AG-UI settles
+// one (agno-agi/agno#9087).
+export const readMcpAppResourceUri = (meta: unknown): string | undefined => {
+  if (!isRecord(meta)) return undefined;
+  const uri = meta["ui/resourceUri"];
+  return typeof uri === "string" && isMcpAppUri(uri) ? uri : undefined;
+};

package/src/runtime/types.ts

@@ -13,6 +13,7 @@ import type {
 import type { AbstractAgent } from "@ag-ui/client";
 import type { Logger } from "./logger";
 import type { ReadonlyJSONValue } from "assistant-stream/utils";
+import type { McpToolCallResult } from "./mcp-tool-result";
 
 /**
  * @experimental This API is still under active development and might change without notice.
@@ -162,6 +163,7 @@ export type AgUiEvent =
       toolCallId: string;
       content: string;
       role?: "tool";
+      mcpResult?: McpToolCallResult;
     }
   | {
       type: "ACTIVITY_SNAPSHOT";