@assistant-ui/ai-sdk 0.0.5 → 0.0.7

package/src/converters/convertMessage.test.ts

@@ -48,6 +48,20 @@ describe("AISDKMessageConverter", () => {
     expect(converted[0]?.metadata).not.toHaveProperty("usage");
   });
 
+  it("keeps modality metadata at the top level", () => {
+    const converted = AISDKMessageConverter.toThreadMessages([
+      {
+        id: "a1",
+        role: "assistant",
+        parts: [{ type: "text", text: "yo" }],
+        metadata: { modality: "voice" },
+      },
+    ] as any);
+
+    expect(converted[0]?.metadata.modality).toBe("voice");
+    expect(converted[0]?.metadata.custom).not.toHaveProperty("modality");
+  });
+
   it("does not flag messages when no optimistic id is provided", () => {
     const converted = AISDKMessageConverter.toThreadMessages([
       { id: "a1", role: "assistant", parts: [{ type: "text", text: "yo" }] },
@@ -473,6 +487,144 @@ describe("AISDKMessageConverter", () => {
     });
   });
 
+  it("preserves rich approval fields for a custom response channel", () => {
+    const metadata: AISDKMessageConverterMetadata = {
+      supportsRichToolApprovalResponses: true,
+    };
+    const converted = AISDKMessageConverter.toThreadMessages(
+      [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-deploy",
+              toolCallId: "tc-1",
+              state: "approval-responded",
+              input: {},
+              approval: {
+                id: "approval-1",
+                display: "select",
+                allowFreeform: true,
+                options: [
+                  {
+                    id: "once",
+                    kind: "allow-once",
+                    label: "Only once",
+                    grants: ["repository", 42],
+                    confirm: {
+                      title: "Confirm access",
+                      description: { invalid: true },
+                    },
+                  },
+                  "invalid",
+                  { id: 1, kind: "allow-always" },
+                  { id: "always", kind: 2 },
+                ],
+                optionId: "once",
+                text: "an answer",
+              },
+            },
+          ],
+        } as any,
+      ],
+      false,
+      metadata,
+    );
+
+    const toolCall = converted[0]?.content.find(
+      (part): part is any => part.type === "tool-call",
+    );
+    expect(toolCall?.approval).toEqual({
+      id: "approval-1",
+      display: "select",
+      allowFreeform: true,
+      options: [
+        {
+          id: "once",
+          kind: "allow-once",
+          label: "Only once",
+          grants: ["repository"],
+          confirm: { title: "Confirm access" },
+        },
+      ],
+      optionId: "once",
+      text: "an answer",
+    });
+  });
+
+  it("applies a host answer to an approval the message has not recorded", () => {
+    const metadata: AISDKMessageConverterMetadata = {
+      supportsRichToolApprovalResponses: true,
+      toolApprovalResponses: new Map([
+        [
+          "approval-1",
+          {
+            approvalId: "approval-1",
+            approved: true,
+            optionId: "staging",
+            text: "only staging",
+          },
+        ],
+        ["approval-2", { approvalId: "approval-2", approved: true }],
+        ["approval-3", { approvalId: "approval-3", approved: true }],
+      ]),
+    };
+    const converted = AISDKMessageConverter.toThreadMessages(
+      [
+        {
+          id: "a1",
+          role: "assistant",
+          parts: [
+            {
+              type: "tool-deploy",
+              toolCallId: "tc-1",
+              state: "approval-requested",
+              input: {},
+              approval: {
+                id: "approval-1",
+                display: "select",
+                options: [{ id: "staging", kind: "_target" }],
+              },
+            },
+            {
+              type: "tool-deploy",
+              toolCallId: "tc-2",
+              state: "approval-responded",
+              input: {},
+              approval: { id: "approval-2", approved: false, reason: "no" },
+            },
+            {
+              type: "tool-deploy",
+              toolCallId: "tc-3",
+              state: "approval-requested",
+              input: {},
+              approval: { id: "approval-3", resolution: "expired" },
+            },
+          ],
+        } as any,
+      ],
+      false,
+      metadata,
+    );
+
+    const approvals = converted[0]?.content.map(
+      (part) => (part as { approval?: unknown }).approval,
+    );
+    expect(approvals).toEqual([
+      {
+        id: "approval-1",
+        display: "select",
+        options: [{ id: "staging", kind: "_target" }],
+        approved: true,
+        optionId: "staging",
+        text: "only staging",
+      },
+      { id: "approval-2", approved: false, reason: "no" },
+      { id: "approval-3", resolution: "expired" },
+    ]);
+  });
+
   it("drops a resolution the core contract does not declare", () => {
     const converted = AISDKMessageConverter.toThreadMessages([
       {

package/src/converters/convertMessage.ts

@@ -12,6 +12,7 @@ import {
 import {
   isMcpAppUri,
   type ReasoningMessagePart,
+  type ToolApprovalOption,
   type ToolCallMessagePart,
   type TextMessagePart,
   type DataMessagePart,
@@ -22,6 +23,7 @@ import {
   type ThreadMessageLike,
   type McpAppMetadata,
   type MessagePartStreamStatus,
+  type RespondToToolApprovalOptions,
 } from "@assistant-ui/core";
 import { stableStringifyToolArgs } from "@assistant-ui/core/internal";
 import {
@@ -40,6 +42,7 @@ const THREAD_METADATA_KEYS = new Set([
   "timing",
   "submittedFeedback",
   "isOptimistic",
+  "modality",
   "custom",
 ]);
 
@@ -60,6 +63,8 @@ export type AISDKMessageConverterMetadata =
     toolArgsKeyOrderCache?: Map<string, Map<string, string[]>>;
     toolLastInputCache?: Map<string, ReadonlyJSONObject>;
     mcpAppMetadataCache?: Map<string, McpAppMetadata>;
+    supportsRichToolApprovalResponses?: boolean;
+    toolApprovalResponses?: ReadonlyMap<string, RespondToToolApprovalOptions>;
     /** Id of the currently-streaming message, flagged optimistic (#4037). */
     optimisticMessageId?: string | undefined;
   };
@@ -152,19 +157,79 @@ function extractMcpAppMetadata(
   return out;
 }
 
+const normalizeToolApprovalOptions = (
+  options: unknown,
+): readonly ToolApprovalOption[] | undefined => {
+  if (!Array.isArray(options)) return undefined;
+
+  return options.flatMap<ToolApprovalOption>((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+    const option = value as Record<string, unknown>;
+    if (typeof option.id !== "string" || typeof option.kind !== "string")
+      return [];
+
+    const confirm = option.confirm;
+    const confirmDetails =
+      confirm && typeof confirm === "object" && !Array.isArray(confirm)
+        ? (confirm as Record<string, unknown>)
+        : undefined;
+
+    return [
+      {
+        id: option.id,
+        kind: option.kind,
+        ...(typeof option.label === "string" && { label: option.label }),
+        ...(typeof option.description === "string" && {
+          description: option.description,
+        }),
+        ...(Array.isArray(option.grants) && {
+          grants: option.grants.filter(
+            (grant): grant is string => typeof grant === "string",
+          ),
+        }),
+        ...(typeof confirm === "boolean"
+          ? { confirm }
+          : confirmDetails
+            ? {
+                confirm: {
+                  ...(typeof confirmDetails.title === "string" && {
+                    title: confirmDetails.title,
+                  }),
+                  ...(typeof confirmDetails.description === "string" && {
+                    description: confirmDetails.description,
+                  }),
+                },
+              }
+            : {}),
+      },
+    ];
+  });
+};
+
 function getToolApprovalAndInterrupt(
   part: {
     approval?: Record<string, unknown> | undefined;
   },
   toolStatus: { type: string; payload?: unknown } | undefined,
+  supportsRichToolApprovalResponses: boolean,
+  toolApprovalResponses:
+    | ReadonlyMap<string, RespondToToolApprovalOptions>
+    | undefined,
 ): {
   approval?: NonNullable<ToolCallMessagePart["approval"]>;
   interrupt?: NonNullable<ToolCallMessagePart["interrupt"]>;
 } {
   if (part.approval) {
-    // The AI SDK sends only id, approved and reason back to the server, so a
-    // request shape promising any other answer would render controls whose
-    // response cannot travel.
+    const response =
+      typeof part.approval.id === "string" &&
+      part.approval.approved === undefined &&
+      part.approval.resolution !== "cancelled" &&
+      part.approval.resolution !== "expired"
+        ? toolApprovalResponses?.get(part.approval.id)
+        : undefined;
+    // The built-in AI SDK channel sends only id, approved and reason back to
+    // the server, so a request shape promising any other answer would render
+    // controls whose response cannot travel.
     const {
       id,
       prompt,
@@ -178,7 +243,18 @@ function getToolApprovalAndInterrupt(
       optionId,
       text,
       ...additionalApprovalFields
-    } = part.approval;
+    } = response
+      ? {
+          ...part.approval,
+          approved: response.approved,
+          ...(response.reason != null && { reason: response.reason }),
+          ...(response.optionId != null && { optionId: response.optionId }),
+          ...(response.text != null && { text: response.text }),
+        }
+      : part.approval;
+    const normalizedOptions = supportsRichToolApprovalResponses
+      ? normalizeToolApprovalOptions(options)
+      : undefined;
     const requestReason = additionalApprovalFields.requestReason;
     if (typeof id === "string")
       return {
@@ -193,6 +269,15 @@ function getToolApprovalAndInterrupt(
           ...(typeof approved === "boolean" && { approved }),
           ...(typeof reason === "string" && { reason }),
           ...(isAutomatic === true && { isAutomatic: true }),
+          ...(supportsRichToolApprovalResponses && {
+            ...((display === "decision" ||
+              display === "select" ||
+              display === "text") && { display }),
+            ...(typeof allowFreeform === "boolean" && { allowFreeform }),
+            ...(normalizedOptions && { options: normalizedOptions }),
+            ...(typeof optionId === "string" && { optionId }),
+            ...(typeof text === "string" && { text }),
+          }),
           ...((resolution === "cancelled" || resolution === "expired") && {
             resolution,
           }),
@@ -347,7 +432,12 @@ function convertParts(
                   part.callProviderMetadata as PartProviderMetadata,
               }
             : undefined),
-          ...getToolApprovalAndInterrupt(part, toolStatus),
+          ...getToolApprovalAndInterrupt(
+            part,
+            toolStatus,
+            metadata.supportsRichToolApprovalResponses === true,
+            metadata.toolApprovalResponses,
+          ),
         } satisfies ToolCallMessagePart;
       }
 

package/src/runtime/AISDKChat.test.ts

@@ -153,7 +153,9 @@ describe("AISDKChat as a standalone client config entry", () => {
     ]
       .map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`)
       .join("");
-    const fetchMock = vi.fn(
+    const fetchMock = vi.fn<
+      (input: RequestInfo | URL, init: RequestInit) => Promise<Response>
+    >(
       async () =>
         new Response(sse, {
           headers: { "content-type": "text/event-stream" },
@@ -178,10 +180,7 @@ describe("AISDKChat as a standalone client config entry", () => {
         expect(state.messages).toHaveLength(2);
       });
 
-      const [url, init] = fetchMock.mock.calls[0]! as [
-        RequestInfo,
-        RequestInit,
-      ];
+      const [url, init] = fetchMock.mock.calls[0]!;
       expect(String(url)).toContain("/api/chat");
       const body = JSON.parse(init.body as string);
       expect(body.id).toBe("test-thread-1");

package/src/runtime/AISDKThreads.cloud.test.ts

@@ -54,23 +54,28 @@ const mocks = vi.hoisted(() => {
       return { history };
     },
   };
-  return { adapter };
+  return {
+    adapter,
+    useCloudThreadListAdapter: vi.fn(() => adapter),
+  };
 });
 
 vi.mock("@assistant-ui/core/react", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/core/react")>()),
-  useCloudThreadListAdapter: () => mocks.adapter,
+  useCloudThreadListAdapter: mocks.useCloudThreadListAdapter,
 }));
 
 import { AISDKThreads } from "./AISDKThreads";
 import { createCancellableTransport } from "./__tests__/controlled-transport";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 describe("AISDKThreads cloud", () => {
   it("reloads history when switching a keyed cloud thread", async () => {
+    const cloud = {} as AssistantCloud;
     const handle = createAssistantClient(
       AuiConfig({
         threads: AISDKThreads({
-          cloud: {} as AssistantCloud,
+          cloud,
           threadId: "t1",
         }),
       }),
@@ -84,6 +89,10 @@ describe("AISDKThreads cloud", () => {
     await vi.waitFor(() => {
       expect(load).toHaveBeenCalled();
     });
+    expect(mocks.useCloudThreadListAdapter).toHaveBeenCalledWith({
+      cloud,
+      sdk: AI_SDK_SDK,
+    });
     const afterFirst = load.mock.calls.length;
     flushTapSync(() => aui.threads.switchToThread("t2"));
     await vi.waitFor(() => {

package/src/runtime/AISDKThreads.test.ts

@@ -251,17 +251,28 @@ describe("AISDKThreads", () => {
     }
   });
 
-  it("forwards ChatInit callbacks to each thread's chat", async () => {
+  it("forwards ChatInit callbacks to each thread's chat from the latest render", async () => {
     const { transport, emit, close } = createControlledTransport();
-    const onFinish = vi.fn();
-    const handle = createAssistantClient(
-      AuiConfig({
-        threads: AISDKThreads({ transport: () => transport, onFinish }),
-      }),
-    );
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ transport: () => transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
     handle.subscribe(() => {});
     const aui = handle.getClient();
 
+    onFinish = onFinishB;
+    flushTapSync(() => listeners.forEach((listener) => listener()));
+
     flushTapSync(() => aui.composer.setText("hi"));
     flushTapSync(() => aui.composer.send());
     await vi.waitFor(() => {
@@ -271,11 +282,123 @@ describe("AISDKThreads", () => {
     });
     emit(...textReply("done"));
     close();
-    await vi.waitFor(() => expect(onFinish).toHaveBeenCalledTimes(1));
+    await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+    expect(onFinishA).not.toHaveBeenCalled();
+
+    handle.destroy();
+  });
+
+  it("forwards the latest callbacks to a switched-away thread still streaming in the background", async () => {
+    const { transport, emit, close } = createControlledTransport();
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ transport: () => transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
+    handle.subscribe(() => {});
+    const aui = handle.getClient();
+
+    flushTapSync(() => aui.composer.setText("stream me"));
+    flushTapSync(() => aui.composer.send());
+    await vi.waitFor(() => {
+      expect(
+        handle.getClient().thread.getState().messages.length,
+      ).toBeGreaterThan(0);
+    });
+    emit(
+      { type: "start" },
+      { type: "text-start", id: "t1" },
+      { type: "text-delta", id: "t1", delta: "partial" },
+    );
+
+    flushTapSync(() => aui.threads.switchToNewThread());
+    onFinish = onFinishB;
+    flushTapSync(() => listeners.forEach((listener) => listener()));
+
+    emit({ type: "text-end", id: "t1" }, { type: "finish" });
+    close();
+    await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+    expect(onFinishA).not.toHaveBeenCalled();
 
     handle.destroy();
   });
 
+  it("forwards the latest callbacks to a cloud thread's chat", async () => {
+    const cloudThread = (id: string) => ({
+      id,
+      title: id,
+      is_archived: false,
+      last_message_at: null,
+      external_id: null,
+      metadata: null,
+    });
+    const cloud = {
+      threads: {
+        list: vi.fn(async () => ({ threads: [cloudThread("t1")] })),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+        get: vi.fn(async (id: string) => cloudThread(id)),
+        messages: {
+          list: vi.fn(async () => ({ messages: [] })),
+          create: vi.fn(async () => ({ message_id: "remote-message-1" })),
+          update: vi.fn(),
+        },
+      },
+      runs: { stream: vi.fn(), report: vi.fn() },
+      telemetry: { enabled: false },
+    } as unknown as AssistantCloud;
+    const { transport, emit, close } = createControlledTransport();
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ cloud, threadId: "t1", transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
+    handle.subscribe(() => {});
+    try {
+      await handle.getClient().threads.getLoadThreadsPromise();
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+      });
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isLoading).toBe(false);
+      });
+
+      onFinish = onFinishB;
+      flushTapSync(() => listeners.forEach((listener) => listener()));
+
+      flushTapSync(() => handle.getClient().composer.setText("hi"));
+      flushTapSync(() => handle.getClient().composer.send());
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isRunning).toBe(true);
+      });
+      emit(...textReply("done"));
+      close();
+      await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+      expect(onFinishA).not.toHaveBeenCalled();
+    } finally {
+      handle.destroy();
+    }
+  });
+
   it("posts each thread's own id as the chat id", async () => {
     const bodies: unknown[] = [];
     const fetchStub = vi.fn(async (_url: unknown, init?: RequestInit) => {
@@ -332,7 +455,9 @@ describe("AISDKThreads", () => {
     const list = vi.fn(async () => ({
       threads: [cloudThread("cloud-1"), cloudThread("cloud-2")],
     }));
-    const create = vi.fn(async () => ({ thread_id: "cloud-created" }));
+    const create = vi.fn<AssistantCloud["threads"]["create"]>(async () => ({
+      thread_id: "cloud-created",
+    }));
     const deleteThread = vi.fn(async () => {});
     const cloud = {
       threads: {
@@ -398,7 +523,9 @@ describe("AISDKThreads", () => {
       external_id: null,
       metadata: null,
     });
-    const create = vi.fn(async () => ({ message_id: "remote-message-1" }));
+    const create = vi.fn<AssistantCloud["threads"]["messages"]["create"]>(
+      async () => ({ message_id: "remote-message-1" }),
+    );
     const cloud = {
       threads: {
         list: vi.fn(async () => ({
@@ -479,9 +606,9 @@ describe("AISDKThreads", () => {
       external_id: null,
       metadata: null,
     });
-    const createMessage = vi.fn(async () => ({
-      message_id: "remote-message-1",
-    }));
+    const createMessage = vi.fn<
+      AssistantCloud["threads"]["messages"]["create"]
+    >(async () => ({ message_id: "remote-message-1" }));
     const cloud = {
       threads: {
         list: vi.fn(async () => ({ threads: [cloudThread("t1")] })),

package/src/runtime/AISDKThreads.ts

@@ -2,7 +2,7 @@
 
 import { resource, useResource, withKey } from "@assistant-ui/tap";
 import { useEffect, useMemo, useState } from "react";
-import { Chat, type UIMessage } from "@ai-sdk/react";
+import type { Chat, UIMessage } from "@ai-sdk/react";
 import type { ChatTransport } from "ai";
 import type { AssistantCloud } from "assistant-cloud";
 import {
@@ -20,12 +20,14 @@ import {
 import { useAui } from "@assistant-ui/store";
 import { AssistantChatTransport } from "../transport/AssistantChatTransport";
 import {
+  createChat,
   splitChatThreadOptions,
   useChatThread,
   type ChatThreadOptions,
 } from "./useChatThread";
 import { MessageRepository } from "@assistant-ui/core/internal";
 import { useResourceCleanup } from "./useResourceCleanup";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 export type AISDKThreadsOptions<UI_MESSAGE extends UIMessage = UIMessage> =
   Omit<ChatThreadOptions<UI_MESSAGE>, "id" | "transport" | "messages"> & {
@@ -62,16 +64,22 @@ type AISDKThreadChatOptions<UI_MESSAGE extends UIMessage = UIMessage> = Omit<
   "cloud" | "threadId" | "onThreadIdChange"
 >;
 
+type ChatOptionsRef<UI_MESSAGE extends UIMessage> = {
+  current: AISDKThreadChatOptions<UI_MESSAGE> | undefined;
+};
+
 type ChatEntry<UI_MESSAGE extends UIMessage> = {
   chat: Chat<UI_MESSAGE>;
   transport: ChatTransport<UI_MESSAGE>;
   repository: MessageRepository;
+  optionsRef: ChatOptionsRef<UI_MESSAGE>;
 };
 
 const createChatEntry = <UI_MESSAGE extends UIMessage>(
   threadId: string,
   options: AISDKThreadChatOptions<UI_MESSAGE> | undefined,
 ): ChatEntry<UI_MESSAGE> => {
+  const optionsRef: ChatOptionsRef<UI_MESSAGE> = { current: options };
   const { chatInit } = splitChatThreadOptions(
     options as ChatThreadOptions<UI_MESSAGE> | undefined,
   );
@@ -84,9 +92,10 @@ const createChatEntry = <UI_MESSAGE extends UIMessage>(
           ? options.transport.__internal_clone()
           : options.transport;
   return {
-    chat: new Chat<UI_MESSAGE>({ ...chatInit, id: threadId, transport }),
+    chat: createChat({ ...chatInit, id: threadId, transport }, optionsRef),
     transport,
     repository: new MessageRepository(),
+    optionsRef,
   };
 };
 
@@ -116,9 +125,13 @@ const useAISDKChatThread = <UI_MESSAGE extends UIMessage = UIMessage>({
   const [owned] = useState(() =>
     cloud ? createChatEntry(threadId, options) : undefined,
   );
-  const { chat, transport, repository } =
+  const { chat, transport, repository, optionsRef } =
     owned ?? getOrCreateChatEntry(threadId, options, chats);
 
+  useEffect(() => {
+    if (cloud) optionsRef.current = options;
+  });
+
   useEffect(() => {
     if (!cloud) return undefined;
     return () => {
@@ -173,13 +186,19 @@ const useAISDKThreads = <UI_MESSAGE extends UIMessage = UIMessage>(
   const [chats] = useState(() => new Map<string, ChatEntry<UI_MESSAGE>>());
   const bindCloud = cloud !== undefined;
 
+  useEffect(() => {
+    for (const { optionsRef } of chats.values()) {
+      optionsRef.current = threadOptions;
+    }
+  });
+
   useResourceCleanup(true, () => {
     for (const { chat } of chats.values()) {
       void chat.stop().catch(() => {});
     }
   });
 
-  const cloudAdapter = useCloudThreadListAdapter({ cloud });
+  const cloudAdapter = useCloudThreadListAdapter({ cloud, sdk: AI_SDK_SDK });
   const thread = (id: string) => {
     const element = AISDKChatThread({
       threadId: id,

package/src/runtime/sdkIdentity.ts

@@ -0,0 +1,9 @@
+import type { SdkIdentity } from "assistant-cloud";
+
+export const AI_SDK_SDK: SdkIdentity = {
+  name: "@assistant-ui/ai-sdk",
+  version:
+    typeof __AUI_PACKAGE_VERSION__ === "string"
+      ? __AUI_PACKAGE_VERSION__
+      : "0.0.0",
+};