@assistant-ui/react-ag-ui 0.0.64 → 0.0.66

package/src/runtime/adapter/conversions.content.test.ts

@@ -40,6 +40,47 @@ const appendMessage = (): AppendMessage => ({
   metadata: { custom: {} },
 });
 
+describe("toAgUiMessages data URLs", () => {
+  it.each(["application/pdf", ""])(
+    "unwraps a media-less data URL while retaining the adapter's %j MIME fallback",
+    (mimeType) => {
+      expect(
+        contentOf(
+          userMessage([
+            { type: "file", data: "data:;base64,SGVsbG8=", mimeType },
+          ]),
+        ),
+      ).toEqual([
+        {
+          type: "document",
+          source: {
+            type: "data",
+            value: "SGVsbG8=",
+            mimeType: mimeType || "application/octet-stream",
+          },
+        },
+      ]);
+    },
+  );
+
+  it("sniffs a media-less image data URL", () => {
+    expect(
+      contentOf(
+        userMessage([{ type: "image", image: "data:;base64,iVBORw0KGgo=" }]),
+      ),
+    ).toEqual([
+      {
+        type: "image",
+        source: {
+          type: "data",
+          value: "iVBORw0KGgo=",
+          mimeType: "image/png",
+        },
+      },
+    ]);
+  });
+});
+
 describe("toAgUiMessages content metadata", () => {
   it("emits AgUiMessage values assignable to AG-UI Message", () => {
     expectTypeOf<AgUiMessage>().toExtend<AgUiWireMessage>();

package/src/runtime/adapter/conversions.nested-tool-calls.test.ts

@@ -0,0 +1,107 @@
+import { describe, expect, it } from "vitest";
+import type { ThreadMessageLike } from "@assistant-ui/core";
+import { toAgUiMessages } from "./conversions";
+
+type Message = ThreadMessageLike;
+type ToolCall = Extract<
+  Exclude<Message["content"], string>[number],
+  { type: "tool-call" }
+>;
+
+const toolCall = (
+  toolCallId: string,
+  messages?: readonly Message[],
+): ToolCall =>
+  ({
+    type: "tool-call",
+    toolCallId,
+    toolName: "test",
+    args: {},
+    ...(messages ? { messages } : {}),
+  }) as ToolCall;
+
+const assistant = (id: string, content: readonly ToolCall[]): Message =>
+  ({ id, role: "assistant", content }) as Message;
+
+const deepToolCall = (depth: number) => {
+  let part = toolCall(String(depth - 1));
+  for (let index = depth - 2; index >= 0; index--) {
+    part = toolCall(String(index), [assistant(`nested-${index}`, [part])]);
+  }
+  return part;
+};
+
+describe("toAgUiMessages nested tool calls", () => {
+  it("preserves document order", () => {
+    const [converted] = toAgUiMessages([
+      assistant("root", [
+        toolCall("root-call", [
+          assistant("nested", [
+            toolCall("first", [assistant("deep", [toolCall("first-child")])]),
+            toolCall("second"),
+          ]),
+        ]),
+      ]),
+    ]);
+
+    expect(converted).toMatchObject({ role: "assistant" });
+    if (converted?.role !== "assistant") throw new Error("expected assistant");
+    expect(converted.toolCalls?.map(({ id }) => id)).toEqual([
+      "root-call",
+      "first",
+      "first-child",
+      "second",
+    ]);
+  });
+
+  it("prunes nested tool calls below filtered a2ui parts", () => {
+    const [converted] = toAgUiMessages([
+      assistant("root", [
+        toolCall("root-call", [
+          assistant("nested", [
+            toolCall("a2ui:surface", [
+              assistant("hidden", [toolCall("hidden")]),
+            ]),
+            toolCall("visible"),
+          ]),
+        ]),
+      ]),
+    ]);
+
+    expect(converted).toMatchObject({ role: "assistant" });
+    if (converted?.role !== "assistant") throw new Error("expected assistant");
+    expect(converted.toolCalls?.map(({ id }) => id)).toEqual([
+      "root-call",
+      "visible",
+    ]);
+  });
+
+  it("converts deeply nested tool calls without overflowing the stack", () => {
+    const depth = 10_000;
+
+    const [converted] = toAgUiMessages([
+      assistant("root", [deepToolCall(depth)]),
+    ]);
+
+    expect(converted).toMatchObject({ role: "assistant" });
+    if (converted?.role !== "assistant") throw new Error("expected assistant");
+    expect(converted.toolCalls).toHaveLength(depth);
+    expect(converted.toolCalls?.at(-1)?.id).toBe(String(depth - 1));
+  });
+
+  it("terminates cyclic nested tool-call messages without throwing", () => {
+    const messages: Message[] = [];
+    messages.push(assistant("nested", [toolCall("nested-call", messages)]));
+
+    const [converted] = toAgUiMessages([
+      assistant("root", [toolCall("root-call", messages)]),
+    ]);
+
+    expect(converted).toMatchObject({ role: "assistant" });
+    if (converted?.role !== "assistant") throw new Error("expected assistant");
+    expect(converted.toolCalls?.map(({ id }) => id)).toEqual([
+      "root-call",
+      "nested-call",
+    ]);
+  });
+});

package/src/runtime/adapter/conversions.ts

@@ -6,14 +6,13 @@ import type {
   ThreadMessageLike as CoreThreadMessageLike,
   PartProviderMetadata,
   ReasoningMessagePart,
-  ThreadMessage,
-  ToolCallMessagePartMcpMetadata,
-  ToolModelContentPart,
 } from "@assistant-ui/core";
 import {
   getAutoStatus,
   parseDataUrl,
   resolveFilePartSource,
+  resolveImageMediaType,
+  walkToolCallTree,
 } from "@assistant-ui/core/internal";
 import { type Tool, toToolsJSONSchema } from "assistant-stream";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
@@ -23,14 +22,13 @@ import {
   MCP_APPS_ACTIVITY_TYPE,
   type AgUiCustomMetadata,
   type AgUiOpaqueReasoning,
-} from "./run-aggregator";
+} from "../types";
 import {
   applyA2uiOperations,
-  convertSurfaceToUISpec,
-  surfaceToOperations,
+  surfaceToPresentToolCall,
   type A2uiState,
   type A2uiSurfaceState,
-} from "@assistant-ui/react-generative-ui/a2ui";
+} from "@assistant-ui/generative-ui/a2ui";
 import type { AgUiInterrupt } from "../types";
 import { projectAgUiToolApprovals } from "./tool-approval";
 import {
@@ -99,29 +97,18 @@ export type AgUiMessage =
       error?: string;
     };
 
-type ToolCallPart = {
-  type: "tool-call";
-  toolCallId?: string;
-  toolName: string;
-  argsText?: string;
-  args?: ReadonlyJSONObject;
+type CoreToolCallPart = Extract<
+  Exclude<CoreThreadMessageLike["content"], string>[number],
+  { type: "tool-call" }
+>;
+
+type ToolCallPart = Omit<CoreToolCallPart, "result" | "isError"> & {
   result?: unknown;
-  artifact?: unknown;
-  isError?: boolean;
-  modelContent?: readonly ToolModelContentPart[];
+  isError?: boolean | undefined;
+  /** @deprecated Experimental since 2026-03-08. Not scheduled for removal; the API may change in any release. */
   unstable_toolMessageId?: string;
-  mcp?: ToolCallMessagePartMcpMetadata;
-  messages?: readonly ThreadMessage[];
-  approval?: CoreToolCallPartApproval;
 };
 
-type CoreToolCallPartApproval = NonNullable<
-  Extract<
-    Exclude<CoreThreadMessageLike["content"], string>[number],
-    { type: "tool-call" }
-  >["approval"]
->;
-
 const isObject = (value: unknown): value is Record<string, unknown> =>
   typeof value === "object" && value !== null;
 
@@ -215,6 +202,9 @@ function normalizeToolCall(part: ToolCallPart): {
   };
 }
 
+const isExportableNestedToolCall = (part: { readonly toolCallId?: unknown }) =>
+  typeof part.toolCallId === "string" && !part.toolCallId.startsWith("a2ui:");
+
 function extractText(content: unknown): string {
   if (typeof content === "string") return content;
   if (!Array.isArray(content)) return "";
@@ -287,9 +277,16 @@ function toInputContent(
     const image = getString(part, "image");
     if (image === undefined) return null;
     const metadata = buildInputMetadata(part, getString(part, "filename"));
+    const source = buildInputSource(image, fallbackMimeType);
     return {
       type: "image",
-      source: buildInputSource(image, fallbackMimeType),
+      source:
+        source.type === "data"
+          ? {
+              ...source,
+              mimeType: resolveImageMediaType(image, fallbackMimeType),
+            }
+          : source,
       ...(metadata && { metadata }),
     };
   }
@@ -513,7 +510,6 @@ function toToolCallPart(value: unknown): ToolCallPart | null {
       : isObject(value.args) && !Array.isArray(value.args)
         ? (value.args as ReadonlyJSONObject)
         : undefined;
-
   const part: ToolCallPart = {
     type: "tool-call",
     ...(toolCallId !== undefined ? { toolCallId } : {}),
@@ -704,27 +700,17 @@ function toUserOrSystemSnapshotMessage(
   };
 }
 
-// Rebuilds the a2ui:<surfaceId> "present" tool-call parts for one owning
-// assistant message from a bucket of rebuilt surface state, mirroring the
-// live RunAggregator.synthesizeA2uiToolCalls shape. Non-a2ui parts (text,
-// other tool calls) are preserved; existing a2ui parts are replaced wholesale
-// so create/update/delete within the bucket all converge on the rebuilt set.
 function attachA2uiSurfaces(
   message: CoreThreadMessageLike,
   state: A2uiState,
 ): CoreThreadMessageLike {
   const a2uiParts: ToolCallPart[] = [];
   for (const [surfaceId, surface] of state) {
-    const { spec } = convertSurfaceToUISpec(surface);
-    if (!spec) continue;
+    const { toolCall } = surfaceToPresentToolCall(surfaceId, surface);
+    if (!toolCall) continue;
     a2uiParts.push({
       type: "tool-call",
-      toolCallId: `a2ui:${surfaceId}`,
-      toolName: "present",
-      args: spec as unknown as ReadonlyJSONObject,
-      argsText: JSON.stringify(spec),
-      result: {},
-      artifact: { a2ui: surfaceToOperations(surface) },
+      ...toolCall,
     });
   }
 
@@ -1316,7 +1302,16 @@ function convertAssistantMessage(
     part: ToolCallPart;
   }[] = [];
   for (const { part } of toolCalls) {
-    collectNestedToolCalls(part, nestedToolCalls);
+    for (const { part: nestedToolCall } of walkToolCallTree(
+      part.messages ?? [],
+      { shouldDescend: isExportableNestedToolCall },
+    )) {
+      if (!isExportableNestedToolCall(nestedToolCall)) continue;
+      nestedToolCalls.push({
+        ...normalizeToolCall(nestedToolCall),
+        part: nestedToolCall,
+      });
+    }
   }
 
   converted.push({
@@ -1348,28 +1343,6 @@ function convertAssistantMessage(
   }
 }
 
-function collectNestedToolCalls(
-  part: ToolCallPart,
-  out: { id: string; call: AgUiToolCall; part: ToolCallPart }[],
-): void {
-  for (const nested of part.messages ?? []) {
-    if (!isObject(nested) || nested.role !== "assistant") continue;
-    const nestedContent = Array.isArray(nested.content) ? nested.content : [];
-    for (const nestedPart of nestedContent) {
-      if (!isObject(nestedPart) || nestedPart.type !== "tool-call") continue;
-      const nestedToolCall = nestedPart as ToolCallPart;
-      if (
-        typeof nestedToolCall.toolCallId !== "string" ||
-        nestedToolCall.toolCallId.startsWith("a2ui:")
-      ) {
-        continue;
-      }
-      out.push({ ...normalizeToolCall(nestedToolCall), part: nestedToolCall });
-      collectNestedToolCalls(nestedToolCall, out);
-    }
-  }
-}
-
 function emitToolResult(
   toolCallId: string,
   part: ToolCallPart,

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

@@ -0,0 +1,143 @@
+import { describe, expect, it } from "vitest";
+import type { ChatModelRunResult } from "@assistant-ui/core";
+import { RunAggregator } from "./run-aggregator";
+import type { AgUiCustomMetadata } from "../types";
+import { toAgUiMessages } from "./conversions";
+
+describe.each([true, false])(
+  "reasoning ownership (showThinking=%s)",
+  (showThinking) => {
+    it.each([
+      { parentText: "", nextReasoning: false },
+      { parentText: "", nextReasoning: true },
+      { parentText: "Looking it up.", nextReasoning: false },
+      { parentText: "Looking it up.", nextReasoning: true },
+    ])(
+      "keeps pre-tool reasoning on its parent ($parentText, nextReasoning=$nextReasoning)",
+      ({ parentText, nextReasoning }) => {
+        let latest: ChatModelRunResult = {};
+        let previous: ChatModelRunResult | undefined;
+        const aggregator = new RunAggregator({
+          showThinking,
+          logger: { debug: () => {}, error: () => {} },
+          emit: (update) => {
+            latest = update;
+          },
+          onTextMessageStart: () => {
+            previous = latest;
+          },
+        });
+        const reason = (messageId: string, delta: string) => {
+          aggregator.handle({ type: "REASONING_MESSAGE_START", messageId });
+          aggregator.handle({
+            type: "REASONING_MESSAGE_CONTENT",
+            messageId,
+            delta,
+          });
+          aggregator.handle({ type: "REASONING_MESSAGE_END", messageId });
+          aggregator.handle({
+            type: "REASONING_ENCRYPTED_VALUE",
+            subtype: "message",
+            entityId: messageId,
+            encryptedValue: `sig-${messageId}`,
+          });
+        };
+        const reasoningOf = (result: ChatModelRunResult | undefined) =>
+          result?.content?.flatMap((part) =>
+            part.type === "reasoning" ? [part.text] : [],
+          );
+        const opaqueOf = (result: ChatModelRunResult | undefined) =>
+          (result?.metadata?.custom?.agui as AgUiCustomMetadata | undefined)
+            ?.opaqueReasoning ?? [];
+
+        aggregator.handle({ type: "RUN_STARTED", runId: "run-1" });
+        aggregator.handle({
+          type: "TEXT_MESSAGE_START",
+          messageId: "assistant-1",
+        });
+        if (parentText)
+          aggregator.handle({
+            type: "TEXT_MESSAGE_CONTENT",
+            messageId: "assistant-1",
+            delta: parentText,
+          });
+        reason("r-1", "plan the call");
+        aggregator.handle({
+          type: "TOOL_CALL_START",
+          toolCallId: "call-1",
+          toolCallName: "lookup",
+          parentMessageId: "assistant-1",
+        });
+        aggregator.handle({ type: "TOOL_CALL_END", toolCallId: "call-1" });
+        aggregator.handle({
+          type: "TOOL_CALL_RESULT",
+          toolCallId: "call-1",
+          messageId: "tool-1",
+          content: "ok",
+        });
+        if (nextReasoning) reason("r-2", "write the answer");
+        aggregator.handle({
+          type: "TEXT_MESSAGE_START",
+          messageId: "assistant-2",
+        });
+        aggregator.handle({
+          type: "TEXT_MESSAGE_CONTENT",
+          messageId: "assistant-2",
+          delta: "Done.",
+        });
+        aggregator.handle({ type: "RUN_FINISHED", runId: "run-1" });
+
+        expect(
+          previous?.content?.filter((part) => part.type === "tool-call"),
+        ).toHaveLength(1);
+        expect(
+          latest.content?.filter((part) => part.type === "tool-call"),
+        ).toHaveLength(0);
+        if (showThinking) {
+          expect(reasoningOf(previous)).toEqual(["plan the call"]);
+          expect(reasoningOf(latest)).toEqual(
+            nextReasoning ? ["write the answer"] : [],
+          );
+        } else {
+          expect(opaqueOf(previous)).toEqual([
+            { id: "r-1", encryptedValue: "sig-r-1" },
+          ]);
+          expect(opaqueOf(latest)).toEqual(
+            nextReasoning ? [{ id: "r-2", encryptedValue: "sig-r-2" }] : [],
+          );
+        }
+        const exported = toAgUiMessages([
+          {
+            id: "assistant-1",
+            role: "assistant",
+            content: previous?.content ?? [],
+            metadata: previous?.metadata,
+          },
+          {
+            id: "assistant-2",
+            role: "assistant",
+            content: latest.content ?? [],
+            metadata: latest.metadata,
+          },
+        ]);
+        expect(exported.map((message) => message.id)).toEqual([
+          "r-1",
+          "assistant-1",
+          "tool-1",
+          ...(nextReasoning ? ["r-2"] : []),
+          "assistant-2",
+        ]);
+        expect(
+          exported.flatMap((message) =>
+            message.role === "reasoning"
+              ? [[message.id, message.encryptedValue]]
+              : [],
+          ),
+        ).toEqual([
+          ["r-1", "sig-r-1"],
+          ...(nextReasoning ? [["r-2", "sig-r-2"]] : []),
+        ]);
+      },
+    );
+  },
+);