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

package/src/runtime/adapter/conversions.ts

@@ -1,8 +1,15 @@
 "use client";
 
 import type { InputContent } from "@ag-ui/client";
-import type { ThreadMessageLike as CoreThreadMessageLike } from "@assistant-ui/core";
-import { getAutoStatus } from "@assistant-ui/core/internal";
+import type {
+  ThreadMessageLike as CoreThreadMessageLike,
+  ToolModelContentPart,
+} from "@assistant-ui/core";
+import {
+  getAutoStatus,
+  httpUrlPattern,
+  parseDataUrl,
+} from "@assistant-ui/core/internal";
 import { type Tool, toToolsJSONSchema } from "assistant-stream";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
 import {
@@ -10,6 +17,7 @@ import {
   type AgUiCustomMetadata,
 } from "./run-aggregator";
 import type { AgUiInterrupt } from "../types";
+import { parseMcpToolCallResult } from "../mcp-tool-result";
 
 export type { InputContent };
 
@@ -59,6 +67,7 @@ type ToolCallPart = {
   args?: ReadonlyJSONObject;
   result?: unknown;
   isError?: boolean;
+  modelContent?: readonly ToolModelContentPart[];
   unstable_toolMessageId?: string;
 };
 
@@ -125,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 };
@@ -536,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 ||
@@ -577,6 +582,7 @@ export function fromAgUiMessages(
           const updatedPart: ToolCallPart = {
             ...(part as ToolCallPart),
             result,
+            ...(mcpModelContent ? { modelContent: mcpModelContent } : {}),
             ...(isError !== undefined ? { isError } : {}),
             ...(toolMessageId !== undefined
               ? { unstable_toolMessageId: toolMessageId }
@@ -611,6 +617,7 @@ export function fromAgUiMessages(
             args: {},
             argsText: "{}",
             result,
+            ...(mcpModelContent ? { modelContent: mcpModelContent } : {}),
             ...(isError !== undefined ? { isError } : {}),
             ...(toolMessageId !== undefined
               ? { unstable_toolMessageId: toolMessageId }
@@ -716,9 +723,11 @@ function convertAssistantMessage(
     if (part.result === undefined) continue;
 
     const resultContent =
-      typeof part.result === "string"
-        ? part.result
-        : JSON.stringify(part.result);
+      part.modelContent !== undefined
+        ? extractText(part.modelContent)
+        : typeof part.result === "string"
+          ? part.result
+          : JSON.stringify(part.result);
 
     const toolMessage: AgUiMessage = {
       id: part.unstable_toolMessageId ?? `${toolCallId}:tool`,

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

@@ -6,6 +6,7 @@ import {
   type MessageTiming,
   type ThreadAssistantMessagePart,
   type ToolCallMessagePart,
+  type ToolModelContentPart,
 } from "@assistant-ui/core";
 import type { AgUiEvent, AgUiInterrupt } from "../types";
 import type { Logger } from "../logger";
@@ -28,9 +29,17 @@ type ToolCallState = {
   parentMessageId?: string;
   toolMessageId?: string;
   mcpAppResourceUri?: string;
+  mcpAppServerId?: string;
+  modelContent?: ToolModelContentPart[];
+  snapshotResultApplied: boolean;
 };
 
-const MCP_APPS_ACTIVITY_TYPE = "mcp-apps";
+export const MCP_APPS_ACTIVITY_TYPE = "mcp-apps";
+
+export const isPlainObject = (
+  value: unknown,
+): value is Record<string, unknown> =>
+  !!value && typeof value === "object" && !Array.isArray(value);
 
 export type RunAggregatorOptions = {
   showThinking: boolean;
@@ -228,16 +237,26 @@ 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;
       }
       case "ACTIVITY_SNAPSHOT": {
         if (event.activityType !== MCP_APPS_ACTIVITY_TYPE) break;
-        const id = this.lastResolvedToolCallId;
-        const entry = id ? this.toolCalls.get(id) : undefined;
+        const toolCallId = event.content.toolCallId;
+        const entry =
+          typeof toolCallId === "string"
+            ? this.toolCalls.get(toolCallId)
+            : this.lastResolvedToolCallId
+              ? this.toolCalls.get(this.lastResolvedToolCallId)
+              : undefined;
         const resourceUri = event.content.resourceUri;
         if (
           entry &&
@@ -245,6 +264,35 @@ export class RunAggregator {
           isMcpAppUri(resourceUri)
         ) {
           entry.mcpAppResourceUri = resourceUri;
+          const id = event.content.serverId;
+          const hash = event.content.serverHash;
+          if (typeof id === "string" && id.length > 0) {
+            entry.mcpAppServerId = id;
+          } else if (typeof hash === "string" && hash.length > 0) {
+            entry.mcpAppServerId = hash;
+          }
+          const result = event.content.result;
+          if (isPlainObject(result)) {
+            if (
+              entry.result !== undefined &&
+              entry.modelContent === undefined
+            ) {
+              entry.modelContent = [
+                {
+                  type: "text",
+                  text:
+                    typeof entry.result === "string"
+                      ? entry.result
+                      : JSON.stringify(entry.result),
+                },
+              ];
+            }
+            entry.result = result;
+            entry.snapshotResultApplied = true;
+            if (typeof result.isError === "boolean") {
+              entry.isError = result.isError;
+            }
+          }
           this.emit();
         }
         break;
@@ -343,6 +391,7 @@ export class RunAggregator {
       parsedArgs: undefined,
       result: undefined,
       isError: undefined,
+      snapshotResultApplied: false,
     };
     if (parentMessageId) {
       state.parentMessageId = parentMessageId;
@@ -400,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);
@@ -411,6 +461,7 @@ export class RunAggregator {
         parsedArgs: undefined,
         result: undefined,
         isError: undefined,
+        snapshotResultApplied: false,
       };
       this.toolCalls.set(id, entry);
     }
@@ -421,8 +472,22 @@ export class RunAggregator {
     ) {
       this.partOrder.push({ kind: "tool-call", toolCallId: id });
     }
-    entry.result = tryParseJSON(content);
-    entry.isError = isError;
+    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 }];
+      }
+      if (entry.isError === undefined) {
+        entry.isError = isError;
+      }
+    } else {
+      entry.result = tryParseJSON(content);
+      entry.isError = isError;
+    }
     if (toolMessageId) {
       entry.toolMessageId = toolMessageId;
     }
@@ -460,9 +525,21 @@ export class RunAggregator {
         args: (entry.parsedArgs ?? {}) as any,
         argsText: entry.argsText,
         ...(entry.result !== undefined ? { result: entry.result } : {}),
+        ...(entry.modelContent !== undefined
+          ? { modelContent: entry.modelContent }
+          : {}),
         ...(entry.isError !== undefined ? { isError: entry.isError } : {}),
         ...(entry.mcpAppResourceUri
-          ? { mcp: { app: { resourceUri: entry.mcpAppResourceUri } } }
+          ? {
+              mcp: {
+                app: {
+                  resourceUri: entry.mcpAppResourceUri,
+                  ...(entry.mcpAppServerId
+                    ? { serverId: entry.mcpAppServerId }
+                    : {}),
+                },
+              },
+            }
           : {}),
         ...(entry.parentMessageId ? { parentId: entry.parentMessageId } : {}),
         ...(entry.toolMessageId

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.
@@ -59,6 +60,17 @@ export type UseAgUiRuntimeOptions = ExternalStoreSharedOptions & {
   agent: AbstractAgent;
   logger?: Partial<Logger>;
   showThinking?: boolean;
+  /**
+   * When the user sends, edits, or reloads a message while client-side tool
+   * calls are still pending, automatically cancel the unresolved tool calls
+   * with an error result so the agent's tool-call accounting stays
+   * consistent. Pending AG-UI interrupts are exempt: they still reject the
+   * run and must be answered with `useAgUiSubmitInterruptResponses` or
+   * discarded with `useAgUiSteerAway`. When disabled, `useAgUiSteerAway`
+   * remains the explicit way to cancel pending tool calls.
+   * Defaults to `true`.
+   */
+  autoCancelPendingToolCalls?: boolean | undefined;
   onError?: (e: Error) => void;
   onCancel?: () => void;
   adapters?: UseAgUiRuntimeAdapters;
@@ -95,6 +107,12 @@ export type AgUiRuntimeExtras = {
     message: CreateAppendMessage,
     responses?: readonly AgUiResumeEntry[],
   ) => Promise<void>;
+  state: ReadonlyJSONValue | undefined;
+  setState: (
+    next:
+      | ReadonlyJSONValue
+      | ((prev: ReadonlyJSONValue | undefined) => ReadonlyJSONValue),
+  ) => void;
 };
 
 export type AgUiRunFinishedOutcome =
@@ -145,6 +163,7 @@ export type AgUiEvent =
       toolCallId: string;
       content: string;
       role?: "tool";
+      mcpResult?: McpToolCallResult;
     }
   | {
       type: "ACTIVITY_SNAPSHOT";

package/src/useAgUiRuntime.ts

@@ -58,6 +58,7 @@ export function useAgUiRuntime(
       agent: options.agent,
       logger,
       showThinking: options.showThinking ?? true,
+      autoCancelPendingToolCalls: options.autoCancelPendingToolCalls,
       ...(options.onError && { onError: options.onError }),
       ...(options.onCancel && { onCancel: options.onCancel }),
       ...(historyAdapter && { history: historyAdapter }),
@@ -70,6 +71,7 @@ export function useAgUiRuntime(
     agent: options.agent,
     logger,
     showThinking: options.showThinking ?? true,
+    autoCancelPendingToolCalls: options.autoCancelPendingToolCalls,
     ...(options.onError && { onError: options.onError }),
     ...(options.onCancel && { onCancel: options.onCancel }),
     ...(historyAdapter && { history: historyAdapter }),
@@ -95,6 +97,7 @@ export function useAgUiRuntime(
         ? async () => {
             await onSwitchToNewThread();
             core.applyExternalMessages([]);
+            core.resetState();
           }
         : undefined,
       onSwitchToThread: onSwitchToThread
@@ -106,6 +109,8 @@ export function useAgUiRuntime(
             core.applyExternalMessages(result.messages);
             if (result.state !== undefined) {
               core.loadExternalState(result.state);
+            } else {
+              core.resetState();
             }
             if (result.unstable_resume) {
               void core.resumeInFlightRun(result.messages);
@@ -136,7 +141,7 @@ export function useAgUiRuntime(
       return {
         ...shared,
         isLoading: core.isLoading,
-        messages: core.getMessages(),
+        messageRepository: core.getMessageRepository(),
         state: core.getState(),
         isRunning: core.isRunning() || hasExecutingTools,
         extras: agUiExtras.provide({
@@ -145,6 +150,8 @@ export function useAgUiRuntime(
           submitInterruptResponses: (responses) =>
             core.submitInterruptResponses(responses),
           steerAway: (message, responses) => core.steerAway(message, responses),
+          state: core.getState(),
+          setState: (next) => core.setState(next),
         }),
         unstable_enableToolInvocations: true,
         setToolStatuses,