@assistant-ui/ai-sdk 0.0.9 → 0.0.11

package/src/converters/convertMessage.test.ts

@@ -666,6 +666,119 @@ describe("AISDKMessageConverter", () => {
     ]);
   });
 
+  it("reads questions and recorded answers from the approval descriptor for a custom response channel", () => {
+    const questions = [
+      {
+        id: "scope",
+        prompt: "Which files?",
+        header: "Scope",
+        options: [
+          { id: "src", label: "src", description: "Sources" },
+          { id: 1, label: "invalid" },
+        ],
+        multiple: true,
+      },
+      { id: "note", prompt: "Anything else?", allowFreeform: "yes" },
+      { prompt: "No id" },
+    ];
+    const parts = [
+      {
+        type: "tool-ask",
+        toolCallId: "tc-1",
+        state: "approval-requested",
+        input: {},
+        approval: {
+          id: "approval-1",
+          descriptor: { display: "questions", questions },
+        },
+      },
+      {
+        type: "tool-ask",
+        toolCallId: "tc-2",
+        state: "approval-responded",
+        input: {},
+        approval: {
+          id: "approval-2",
+          approved: true,
+          descriptor: {
+            display: "questions",
+            questions: [{ id: "note", prompt: "Anything else?" }],
+            answers: {
+              note: { text: "no", optionIds: [1, "x"] },
+              bad: "x",
+              empty: { optionIds: [1] },
+            },
+          },
+        },
+      },
+    ];
+
+    const convert = (supportsRichToolApprovalResponses: boolean) => {
+      const metadata: AISDKMessageConverterMetadata = {
+        supportsRichToolApprovalResponses,
+      };
+      return AISDKMessageConverter.toThreadMessages(
+        [{ id: "a1", role: "assistant", parts } as any],
+        false,
+        metadata,
+      )[0]?.content.map((part) => (part as { approval?: any }).approval);
+    };
+
+    const [requested, responded] = convert(true)!;
+    expect(requested.display).toBe("questions");
+    expect(requested.questions).toEqual([
+      {
+        id: "scope",
+        prompt: "Which files?",
+        header: "Scope",
+        options: [{ id: "src", label: "src", description: "Sources" }],
+        multiple: true,
+      },
+      { id: "note", prompt: "Anything else?" },
+    ]);
+    expect(responded.approved).toBe(true);
+    expect(responded.answers).toEqual({
+      note: { text: "no", optionIds: ["x"] },
+    });
+    expect(
+      convertWith(JSON.parse('{"__proto__":{"text":"kept"}}')).answers
+        .__proto__,
+    ).toEqual({ text: "kept" });
+
+    function convertWith(answers: unknown) {
+      const metadata: AISDKMessageConverterMetadata = {
+        supportsRichToolApprovalResponses: true,
+      };
+      return AISDKMessageConverter.toThreadMessages(
+        [
+          {
+            id: "a2",
+            role: "assistant",
+            parts: [
+              {
+                type: "tool-ask",
+                toolCallId: "tc-3",
+                state: "approval-responded",
+                input: {},
+                approval: {
+                  id: "approval-3",
+                  approved: true,
+                  descriptor: { display: "questions", answers },
+                },
+              },
+            ],
+          } as any,
+        ],
+        false,
+        metadata,
+      )[0]?.content.map((part) => (part as { approval?: any }).approval)[0];
+    }
+
+    const [builtIn] = convert(false)!;
+    expect(builtIn).not.toHaveProperty("display");
+    expect(builtIn).not.toHaveProperty("questions");
+  });
+
   it("ignores a non-boolean dismissible field from the approval descriptor", () => {
     const metadata: AISDKMessageConverterMetadata = {
       supportsRichToolApprovalResponses: true,
@@ -1416,6 +1529,123 @@ describe("AISDKMessageConverter", () => {
     });
   });
 
+  it("forwards toolMetadata.app without a tool-supplied serverId", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-search",
+            toolCallId: "tc-1",
+            state: "output-available",
+            input: { query: "hi" },
+            output: { results: [] },
+            toolMetadata: {
+              app: {
+                resourceUri: "ui://example/search",
+                mimeType: "text/html;profile=mcp-app",
+                visibility: ["app", "model", "bogus"],
+                serverId: "search-server",
+              },
+            },
+          },
+        ],
+      } as any,
+    ]);
+
+    const call = converted[0]?.content.find(
+      (part): part is any => part.type === "tool-call",
+    );
+    expect(call?.mcp?.app).toEqual({
+      resourceUri: "ui://example/search",
+      mimeType: "text/html;profile=mcp-app",
+      visibility: ["app", "model"],
+    });
+  });
+
+  it.each([undefined, "", "other-server"])(
+    "keeps provider serverId when the tool supplies %s",
+    (serverId) => {
+      const converted = AISDKMessageConverter.toThreadMessages([
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-search",
+              toolCallId: "tc-1",
+              state: "output-available",
+              input: { query: "hi" },
+              output: { results: [] },
+              toolMetadata: {
+                app: {
+                  resourceUri: "ui://example/search",
+                  mimeType: "text/html;profile=mcp-app",
+                  serverId,
+                },
+              },
+              callProviderMetadata: {
+                mcp: {
+                  app: {
+                    resourceUri: "ui://example/search",
+                    serverId: "search-server",
+                  },
+                },
+              },
+            },
+          ],
+        } as any,
+      ]);
+
+      const call = converted[0]?.content.find(
+        (part): part is any => part.type === "tool-call",
+      );
+      expect(call?.mcp?.app).toEqual({
+        resourceUri: "ui://example/search",
+        mimeType: "text/html;profile=mcp-app",
+        serverId: "search-server",
+      });
+    },
+  );
+
+  it("falls back to provider app metadata when toolMetadata.app has an invalid URI", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-search",
+            toolCallId: "tc-1",
+            state: "output-available",
+            input: { query: "hi" },
+            output: { results: [] },
+            toolMetadata: {
+              app: { resourceUri: "https://example.com/search" },
+            },
+            callProviderMetadata: {
+              mcp: {
+                app: {
+                  resourceUri: "ui://example/search",
+                  mimeType: "text/html;profile=mcp-app",
+                },
+              },
+            },
+          },
+        ],
+      } as any,
+    ]);
+
+    const call = converted[0]?.content.find(
+      (part): part is any => part.type === "tool-call",
+    );
+    expect(call?.mcp?.app).toEqual({
+      resourceUri: "ui://example/search",
+      mimeType: "text/html;profile=mcp-app",
+    });
+  });
+
   it("omits an empty callProviderMetadata.mcp.app.serverId", () => {
     const converted = AISDKMessageConverter.toThreadMessages([
       {
@@ -1483,6 +1713,42 @@ describe("AISDKMessageConverter", () => {
     expect(converted[0]?.content[2]).not.toHaveProperty("providerMetadata");
   });
 
+  it("keeps a step scoped reasoning block id off the part", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [
+          { type: "reasoning", id: "reasoning-0", text: "first step" },
+          { type: "text", text: "answer" },
+          { type: "reasoning", id: "reasoning-0", text: "second step" },
+        ],
+      } as any,
+    ]);
+
+    expect(converted[0]?.content[0]).toMatchObject({ type: "reasoning" });
+    expect(converted[0]?.content[0]).not.toHaveProperty("id");
+    expect(converted[0]?.content[1]).not.toHaveProperty("id");
+    expect(converted[0]?.content[2]).not.toHaveProperty("id");
+  });
+
+  it("forwards data part ids", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [{ type: "data-chart", id: "data-1", data: { x: 1 } }],
+      } as any,
+    ]);
+
+    expect(converted[0]?.content[0]).toMatchObject({
+      type: "data",
+      id: "data-1",
+      name: "chart",
+      data: { x: 1 },
+    });
+  });
+
   it("maps TextUIPart.state onto the per-part status", () => {
     const converted = AISDKMessageConverter.toThreadMessages([
       {

package/src/converters/convertMessage.ts

@@ -13,6 +13,8 @@ import {
   isMcpAppUri,
   type ReasoningMessagePart,
   type ToolApprovalOption,
+  type ToolApprovalQuestion,
+  type ToolApprovalQuestionOption,
   type ToolCallMessagePart,
   type TextMessagePart,
   type DataMessagePart,
@@ -26,6 +28,7 @@ import {
   type RespondToToolApprovalOptions,
   type Unstable_ToolInteractionLog,
 } from "@assistant-ui/core";
+import { normalizeToolApprovalAnswers } from "./toolApprovalAnswers";
 import { stableStringifyToolArgs } from "@assistant-ui/core/internal";
 import {
   parsePartialJsonObject,
@@ -95,17 +98,45 @@ function extractMcpAppMetadata(
   cache: Map<string, McpAppMetadata> | undefined,
 ): McpAppMetadata | undefined {
   if (!part || typeof part !== "object") return undefined;
+  const toolMetadata = (part as { toolMetadata?: unknown }).toolMetadata;
+  const toolApp =
+    toolMetadata && typeof toolMetadata === "object"
+      ? (toolMetadata as { app?: unknown }).app
+      : undefined;
   const meta = (part as { callProviderMetadata?: unknown })
     .callProviderMetadata;
   const mcp =
     meta && typeof meta === "object"
       ? (meta as { mcp?: unknown }).mcp
       : undefined;
-  const app =
+  const providerApp =
     mcp && typeof mcp === "object" ? (mcp as { app?: unknown }).app : undefined;
+
+  const apps: Record<string, unknown>[] = [];
+  for (const candidate of [toolApp, providerApp]) {
+    if (!candidate || typeof candidate !== "object") continue;
+    const candidateApp = candidate as Record<string, unknown>;
+    const resourceUri = candidateApp["resourceUri"];
+    if (typeof resourceUri !== "string" || !isMcpAppUri(resourceUri)) continue;
+    apps.push({
+      resourceUri,
+      ...(typeof candidateApp["mimeType"] === "string" && {
+        mimeType: candidateApp["mimeType"],
+      }),
+      ...(Array.isArray(candidateApp["visibility"]) && {
+        visibility: candidateApp["visibility"],
+      }),
+      ...(candidate === providerApp &&
+        typeof candidateApp["serverId"] === "string" &&
+        candidateApp["serverId"].length > 0 && {
+          serverId: candidateApp["serverId"],
+        }),
+    });
+  }
+
   let a: Record<string, unknown>;
-  if (app && typeof app === "object") {
-    a = app as Record<string, unknown>;
+  if (apps.length > 0) {
+    a = { ...(apps[1] ?? {}), ...apps[0]! };
   } else {
     // MCP-UI tools surface the pointer on result._meta: canonical nested
     // `ui.resourceUri`, or the deprecated flat `"ui/resourceUri"` key.
@@ -221,6 +252,51 @@ const normalizeToolApprovalOptions = (
   });
 };
 
+const normalizeToolApprovalQuestions = (
+  questions: unknown,
+): readonly ToolApprovalQuestion[] | undefined => {
+  if (!Array.isArray(questions)) return undefined;
+
+  return questions.flatMap<ToolApprovalQuestion>((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+    const question = value as Record<string, unknown>;
+    if (typeof question.id !== "string" || typeof question.prompt !== "string")
+      return [];
+    const options = Array.isArray(question.options)
+      ? question.options.flatMap<ToolApprovalQuestionOption>((option) => {
+          if (!option || typeof option !== "object" || Array.isArray(option))
+            return [];
+          const { id, label, description } = option as Record<string, unknown>;
+          if (typeof id !== "string" || typeof label !== "string") return [];
+          return [
+            {
+              id,
+              label,
+              ...(typeof description === "string" && { description }),
+            },
+          ];
+        })
+      : undefined;
+
+    return [
+      {
+        id: question.id,
+        prompt: question.prompt,
+        ...(typeof question.header === "string" && {
+          header: question.header,
+        }),
+        ...(options && { options }),
+        ...(typeof question.multiple === "boolean" && {
+          multiple: question.multiple,
+        }),
+        ...(typeof question.allowFreeform === "boolean" && {
+          allowFreeform: question.allowFreeform,
+        }),
+      },
+    ];
+  });
+};
+
 const APPROVAL_DESCRIPTOR_FIELDS = [
   "prompt",
   "display",
@@ -229,6 +305,8 @@ const APPROVAL_DESCRIPTOR_FIELDS = [
   "options",
   "optionId",
   "text",
+  "questions",
+  "answers",
   "resolution",
 ] as const;
 
@@ -302,6 +380,8 @@ function getToolApprovalAndInterrupt(
       options,
       optionId,
       text,
+      questions,
+      answers,
       ...additionalApprovalFields
     } = response
       ? {
@@ -310,11 +390,18 @@ function getToolApprovalAndInterrupt(
           ...(response.reason != null && { reason: response.reason }),
           ...(response.optionId != null && { optionId: response.optionId }),
           ...(response.text != null && { text: response.text }),
+          ...(response.answers != null && { answers: response.answers }),
         }
       : approval;
     const normalizedOptions = supportsRichToolApprovalResponses
       ? normalizeToolApprovalOptions(options)
       : undefined;
+    const normalizedQuestions = supportsRichToolApprovalResponses
+      ? normalizeToolApprovalQuestions(questions)
+      : undefined;
+    const normalizedAnswers = supportsRichToolApprovalResponses
+      ? normalizeToolApprovalAnswers(answers)
+      : undefined;
     const requestReason = additionalApprovalFields.requestReason;
     if (typeof id === "string")
       return {
@@ -332,12 +419,15 @@ function getToolApprovalAndInterrupt(
           ...(supportsRichToolApprovalResponses && {
             ...((display === "decision" ||
               display === "select" ||
-              display === "text") && { display }),
+              display === "text" ||
+              display === "questions") && { display }),
             ...(typeof allowFreeform === "boolean" && { allowFreeform }),
             ...(typeof dismissible === "boolean" && { dismissible }),
             ...(normalizedOptions && { options: normalizedOptions }),
             ...(typeof optionId === "string" && { optionId }),
             ...(typeof text === "string" && { text }),
+            ...(normalizedQuestions && { questions: normalizedQuestions }),
+            ...(normalizedAnswers && { answers: normalizedAnswers }),
           }),
           ...((resolution === "cancelled" || resolution === "expired") && {
             resolution,
@@ -585,6 +675,9 @@ function convertParts(
       if (part.type.startsWith("data-")) {
         return {
           type: "data",
+          ...("id" in part && typeof part.id === "string"
+            ? { id: part.id }
+            : undefined),
           name: part.type.substring(5),
           data: (part as any).data,
         } satisfies DataMessagePart;

package/src/converters/toCreateMessage.test.ts

@@ -185,6 +185,19 @@ describe("toCreateMessage", () => {
     ]);
   });
 
+  it("forwards a data part id", () => {
+    const message = {
+      ...baseMessage,
+      content: [
+        { type: "data", name: "workflow", id: "p1", data: { field: 1 } },
+      ],
+    } as unknown as AppendMessage;
+
+    expect(toCreateMessage(message).parts).toEqual([
+      { type: "data-workflow", id: "p1", data: { field: 1 } },
+    ]);
+  });
+
   it("converts a data part inside an attachment without throwing", () => {
     const message = {
       ...baseMessage,

package/src/converters/toCreateMessage.ts

@@ -86,6 +86,7 @@ export const toCreateMessage = <UI_MESSAGE extends UIMessage = UIMessage>(
         return {
           type: `data-${part.name}`,
           data: part.data,
+          ...(part.id !== undefined && { id: part.id }),
         };
       default:
         throw new Error(`Unsupported part type: ${part.type}`);

package/src/converters/toolApprovalAnswers.ts

@@ -0,0 +1,27 @@
+import type { ToolApprovalAnswer } from "@assistant-ui/core";
+
+export const normalizeToolApprovalAnswers = (
+  answers: unknown,
+): Readonly<Record<string, ToolApprovalAnswer>> | undefined => {
+  if (!answers || typeof answers !== "object" || Array.isArray(answers))
+    return undefined;
+
+  return Object.fromEntries(
+    Object.entries(answers).flatMap(([id, value]) => {
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        return [];
+      const { optionIds, text } = value as Record<string, unknown>;
+      const answer: ToolApprovalAnswer = {
+        ...(Array.isArray(optionIds) && {
+          optionIds: optionIds.filter(
+            (optionId): optionId is string => typeof optionId === "string",
+          ),
+        }),
+        ...(typeof text === "string" && { text }),
+      };
+      return answer.optionIds?.length || answer.text !== undefined
+        ? [[id, answer]]
+        : [];
+    }),
+  );
+};

package/src/runtime/useExternalHistory.test.ts

@@ -1383,6 +1383,100 @@ describe("useExternalHistory persistence", () => {
     );
   });
 
+  it("stores and restores questionnaire answers with the approval response", async () => {
+    const answers = {
+      scope: { optionIds: ["src", "tests"] },
+      note: { text: "keep it short" },
+    };
+    const saved = new Map<string, RespondToToolApprovalOptions>();
+    const writer = createPersistenceHarness(false, {
+      toolApprovalResponses: saved,
+    });
+    const innerMessage: InnerMessage = {
+      id: "inner-a",
+      role: "assistant",
+      parts: [
+        {
+          type: "tool-ask",
+          toolCallId: "call-1",
+          state: "approval-requested",
+          approval: { id: "approval-1" },
+        },
+      ],
+    };
+    const message = Object.assign(
+      createAssistantMessage({ type: "complete", reason: "stop" }, [
+        innerMessage,
+      ]),
+      {
+        content: [
+          {
+            type: "tool-call" as const,
+            toolCallId: "call-1",
+            toolName: "ask",
+            args: {},
+            argsText: "{}",
+            result: undefined,
+            isError: false,
+            approval: { id: "approval-1" },
+          },
+        ],
+      },
+    );
+    await waitFor(() => expect(writer.load).toHaveBeenCalledTimes(1));
+    saved.set("approval-1", {
+      approvalId: "approval-1",
+      approved: true,
+      answers,
+    });
+    await writer.runCycle([message]);
+    await waitFor(() =>
+      expect(writer.append).toHaveBeenCalledWith({
+        parentId: null,
+        message: {
+          ...innerMessage,
+          metadata: {
+            __aui_toolApprovalResponses: {
+              "approval-1": { approved: true, answers },
+            },
+          },
+        },
+      }),
+    );
+    writer.unmount();
+
+    const restored = new Map<string, RespondToToolApprovalOptions>();
+    const reader = createPersistenceHarness(true, {
+      loadMessages: {
+        messages: [
+          {
+            parentId: null,
+            message: {
+              ...innerMessage,
+              metadata: {
+                __aui_toolApprovalResponses: {
+                  "approval-1": {
+                    approved: true,
+                    answers: { ...answers, junk: { optionIds: [1] } },
+                  },
+                },
+              },
+            },
+          },
+        ],
+      },
+      toolApprovalResponses: restored,
+    });
+    await waitFor(() => expect(reader.load).toHaveBeenCalledTimes(1));
+    await waitFor(() =>
+      expect(restored.get("approval-1")).toEqual({
+        approvalId: "approval-1",
+        approved: true,
+        answers,
+      }),
+    );
+  });
+
   it("restores stored tool artifacts without returning metadata to the chat", async () => {
     const toolArtifacts = new Map<string, unknown>();
     const onSetMessages = vi.fn();

package/src/runtime/useExternalHistory.ts

@@ -25,6 +25,7 @@ import {
   useCallback,
   useMemo,
 } from "react";
+import { normalizeToolApprovalAnswers } from "../converters/toolApprovalAnswers";
 
 export const toExportedMessageRepository = <TMessage>(
   toThreadMessages: (messages: TMessage[]) => ThreadMessage[],
@@ -131,6 +132,7 @@ const collectToolApprovalResponses = (
           approved: response.approved,
           ...(response.optionId != null && { optionId: response.optionId }),
           ...(response.text != null && { text: response.text }),
+          ...(response.answers != null && { answers: response.answers }),
           ...(response.reason != null && { reason: response.reason }),
         },
       ] as const,
@@ -246,6 +248,7 @@ const restoreToolData = <TMessage>(
   if (toolApprovalResponses && isRecord(approvalResponses)) {
     for (const [approvalId, value] of Object.entries(approvalResponses)) {
       if (!isRecord(value) || typeof value.approved !== "boolean") continue;
+      const answers = normalizeToolApprovalAnswers(value.answers);
       toolApprovalResponses.set(approvalId, {
         approvalId,
         approved: value.approved,
@@ -253,6 +256,7 @@ const restoreToolData = <TMessage>(
           optionId: value.optionId,
         }),
         ...(typeof value.text === "string" && { text: value.text }),
+        ...(answers && Object.keys(answers).length > 0 && { answers }),
         ...(typeof value.reason === "string" && { reason: value.reason }),
       });
     }