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

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,
@@ -24,6 +28,8 @@ 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 +431,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 +444,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 +523,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 +1345,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);
     }
@@ -1361,10 +1378,49 @@ export class AgUiThreadRuntimeCore {
         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 }
+              : {}),
           ...(event.messageId
             ? { unstable_toolMessageId: event.messageId }
             : {}),
@@ -1381,6 +1437,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

@@ -5,7 +5,11 @@ import type {
   ThreadMessageLike as CoreThreadMessageLike,
   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 +17,7 @@ import {
   type AgUiCustomMetadata,
 } from "./run-aggregator";
 import type { AgUiInterrupt } from "../types";
+import { parseMcpToolCallResult } from "../mcp-tool-result";
 
 export type { InputContent };
 
@@ -129,16 +134,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 +535,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 ||
@@ -581,6 +582,7 @@ export function fromAgUiMessages(
           const updatedPart: ToolCallPart = {
             ...(part as ToolCallPart),
             result,
+            ...(mcpModelContent ? { modelContent: mcpModelContent } : {}),
             ...(isError !== undefined ? { isError } : {}),
             ...(toolMessageId !== undefined
               ? { unstable_toolMessageId: toolMessageId }
@@ -615,6 +617,7 @@ export function fromAgUiMessages(
             args: {},
             argsText: "{}",
             result,
+            ...(mcpModelContent ? { modelContent: mcpModelContent } : {}),
             ...(isError !== undefined ? { isError } : {}),
             ...(toolMessageId !== undefined
               ? { unstable_toolMessageId: toolMessageId }
@@ -719,10 +722,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

@@ -34,9 +34,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 +237,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 +449,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 +472,12 @@ 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;
+    } 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,26 @@
+import { isRecord } from "@assistant-ui/core/internal";
+
+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 } : {}),
+  };
+};

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";