@assistant-ui/react-ag-ui 0.0.48 → 0.0.49

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

@@ -8,6 +8,12 @@ import {
   type ToolCallMessagePart,
   type ToolModelContentPart,
 } from "@assistant-ui/core";
+import {
+  applyA2uiOperations,
+  convertSurfaceToUISpec,
+  type A2uiState,
+  type A2uiSurfaceState,
+} from "@assistant-ui/react-generative-ui/a2ui";
 import { readMcpAppResourceUri } from "../mcp-tool-result";
 import type { AgUiEvent, AgUiInterrupt } from "../types";
 import type { Logger } from "../logger";
@@ -37,6 +43,8 @@ type ToolCallState = {
 
 export const MCP_APPS_ACTIVITY_TYPE = "mcp-apps";
 
+export const A2UI_SURFACE_ACTIVITY_TYPE = "a2ui-surface";
+
 export const isPlainObject = (
   value: unknown,
 ): value is Record<string, unknown> =>
@@ -72,6 +80,8 @@ export class RunAggregator {
   private activeReasoningKey: string | undefined;
   private reasoningPartCounter = 0;
   private readonly toolCalls = new Map<string, ToolCallState>();
+  private readonly a2uiBuckets = new Map<string, A2uiState>();
+  private readonly a2uiToolCallIds = new Set<string>();
   private lastResolvedToolCallId: string | undefined;
   private readonly partOrder: (
     | { kind: "text"; key: string }
@@ -104,6 +114,8 @@ export class RunAggregator {
         this.activeReasoningKey = undefined;
         this.reasoningPartCounter = 0;
         this.toolCalls.clear();
+        this.a2uiBuckets.clear();
+        this.a2uiToolCallIds.clear();
         this.lastResolvedToolCallId = undefined;
         this.partOrder.length = 0;
         this.textPartCounter = 0;
@@ -250,6 +262,10 @@ export class RunAggregator {
         break;
       }
       case "ACTIVITY_SNAPSHOT": {
+        if (event.activityType === A2UI_SURFACE_ACTIVITY_TYPE) {
+          this.handleA2uiActivitySnapshot(event);
+          break;
+        }
         if (event.activityType !== MCP_APPS_ACTIVITY_TYPE) break;
         const toolCallId = event.content.toolCallId;
         const entry =
@@ -305,6 +321,72 @@ export class RunAggregator {
     }
   }
 
+  private handleA2uiActivitySnapshot(
+    event: Extract<AgUiEvent, { type: "ACTIVITY_SNAPSHOT" }>,
+  ): void {
+    const operations = event.content["a2ui_operations"];
+    if (!Array.isArray(operations)) return;
+
+    const messageId = event.messageId ?? "a2ui:anonymous";
+    if (event.replace === false && this.a2uiBuckets.has(messageId)) return;
+
+    const { state, warnings } = applyA2uiOperations(new Map(), operations);
+    for (const warning of warnings) {
+      this.logger.debug("[agui] a2ui operation warning", warning);
+    }
+    this.a2uiBuckets.delete(messageId);
+    this.a2uiBuckets.set(messageId, state);
+    this.synthesizeA2uiToolCalls();
+    this.emit();
+  }
+
+  private synthesizeA2uiToolCalls(): void {
+    const surfaces = new Map<string, A2uiSurfaceState>();
+
+    for (const bucket of this.a2uiBuckets.values()) {
+      for (const [surfaceId, surface] of bucket) {
+        surfaces.set(surfaceId, surface);
+      }
+    }
+
+    const activeToolCallIds = new Set<string>();
+    for (const [surfaceId, surface] of surfaces) {
+      const toolCallId = `a2ui:${surfaceId}`;
+      const { spec, warnings } = convertSurfaceToUISpec(surface);
+      for (const warning of warnings) {
+        this.logger.debug("[agui] a2ui surface conversion warning", warning);
+      }
+      if (!spec) continue;
+
+      activeToolCallIds.add(toolCallId);
+
+      const entry: ToolCallState = {
+        toolCallId,
+        toolCallName: "present",
+        argsText: JSON.stringify(spec),
+        parsedArgs: spec,
+        result: {},
+        isError: undefined,
+        snapshotResultApplied: false,
+      };
+      if (!this.toolCalls.has(toolCallId)) {
+        this.partOrder.push({ kind: "tool-call", toolCallId });
+      }
+      this.toolCalls.set(toolCallId, entry);
+      this.a2uiToolCallIds.add(toolCallId);
+    }
+
+    for (const toolCallId of this.a2uiToolCallIds) {
+      if (activeToolCallIds.has(toolCallId)) continue;
+      this.toolCalls.delete(toolCallId);
+      const partIndex = this.partOrder.findIndex(
+        (part) => part.kind === "tool-call" && part.toolCallId === toolCallId,
+      );
+      if (partIndex !== -1) this.partOrder.splice(partIndex, 1);
+      this.a2uiToolCallIds.delete(toolCallId);
+    }
+  }
+
   private reportServerMessageId(messageId: string | undefined): void {
     if (this.serverMessageIdReported || !messageId) return;
     this.serverMessageIdReported = true;

package/src/runtime/event-parser.ts

@@ -241,11 +241,18 @@ export const parseAgUiEvent = (
     case "ACTIVITY_SNAPSHOT": {
       const activityType = getString("activityType");
       if (!activityType || !isPlainObject(payload.content)) return null;
-      return {
-        type: "ACTIVITY_SNAPSHOT" as const,
-        activityType,
-        content: payload.content,
-      };
+      return withOptional(
+        {
+          type: "ACTIVITY_SNAPSHOT" as const,
+          activityType,
+          content: payload.content,
+        },
+        {
+          messageId: getString("messageId"),
+          replace:
+            typeof payload.replace === "boolean" ? payload.replace : undefined,
+        },
+      );
     }
     case "RAW":
       return withOptional(

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

@@ -26,12 +26,14 @@ export const parseMcpToolCallResult = (
   };
 };
 
-// _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).
+// The MCP Apps pointer on CallToolResult._meta: canonical nested `ui.resourceUri`
+// per the Apps spec (2026-01-26), with the deprecated flat `"ui/resourceUri"` kept
+// for legacy producers. Only ui:// URIs identify a widget.
 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;
+  const ui = meta["ui"];
+  const nested = isRecord(ui) ? ui["resourceUri"] : undefined;
+  if (typeof nested === "string" && isMcpAppUri(nested)) return nested;
+  const flat = meta["ui/resourceUri"];
+  return typeof flat === "string" && isMcpAppUri(flat) ? flat : undefined;
 };

package/src/runtime/types.ts

@@ -100,6 +100,7 @@ export type AgUiResumeEntry = {
 
 export type AgUiRuntimeExtras = {
   interrupts: readonly AgUiInterrupt[];
+  sendA2uiAction: (action: Record<string, unknown>) => void;
   submitInterruptResponses: (
     responses: readonly AgUiResumeEntry[],
   ) => Promise<void>;
@@ -169,6 +170,8 @@ export type AgUiEvent =
       type: "ACTIVITY_SNAPSHOT";
       activityType: string;
       content: Record<string, unknown>;
+      messageId?: string;
+      replace?: boolean;
     }
   | { type: "RAW"; event: any; source?: string }
   | { type: "CUSTOM"; name: string; value: any }

package/src/useAgUiRuntime.ts

@@ -147,6 +147,7 @@ export function useAgUiRuntime(
         extras: agUiExtras.provide({
           interrupts:
             core.getPendingInterrupts()?.interrupts ?? EMPTY_INTERRUPTS,
+          sendA2uiAction: (action) => core.sendA2uiAction(action),
           submitInterruptResponses: (responses) =>
             core.submitInterruptResponses(responses),
           steerAway: (message, responses) => core.steerAway(message, responses),