@assistant-ui/core 0.3.17 → 0.3.19

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.test.ts

@@ -3,6 +3,14 @@ import type { AssistantCloud } from "assistant-cloud";
 import type { PendingAttachment } from "../../../types/attachment";
 import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
 
+const deferred = <T>() => {
+  let resolve!: (value: T) => void;
+  const promise = new Promise<T>((res) => {
+    resolve = res;
+  });
+  return { promise, resolve };
+};
+
 const makeCloud = () =>
   ({
     files: {
@@ -124,4 +132,73 @@ describe("CloudFileAttachmentAdapter", () => {
       "Attachment not uploaded",
     );
   });
+
+  it("does not finish an upload removed while requesting its URL", async () => {
+    const presigned = deferred<{
+      signedUrl: string;
+      publicUrl: string;
+    }>();
+    const cloud = makeCloud();
+    vi.mocked(cloud.files.generatePresignedUploadUrl).mockReturnValue(
+      presigned.promise,
+    );
+    const fetchMock = vi.fn().mockResolvedValue({ ok: true });
+    vi.stubGlobal("fetch", fetchMock);
+    const adapter = new CloudFileAttachmentAdapter(cloud);
+    const generator = adapter.add({ file: makeFile() });
+
+    const running = await generator.next();
+    const completion = generator.next();
+    await vi.waitFor(() => {
+      expect(cloud.files.generatePresignedUploadUrl).toHaveBeenCalledOnce();
+    });
+
+    await adapter.remove(running.value!);
+    presigned.resolve({
+      signedUrl: "https://storage.example/upload",
+      publicUrl: "https://cdn.example/file.png",
+    });
+
+    await expect(completion).resolves.toEqual({ done: true, value: undefined });
+    expect(fetchMock).not.toHaveBeenCalled();
+    await expect(adapter.send(running.value!)).rejects.toThrow(
+      "Attachment not uploaded",
+    );
+  });
+
+  it("does not finish an upload removed during the file request", async () => {
+    const fetchMock = vi.fn((_url: string, init: RequestInit) => {
+      return new Promise((_resolve, reject) => {
+        init.signal!.addEventListener(
+          "abort",
+          () =>
+            reject(new DOMException("The operation was aborted", "AbortError")),
+          { once: true },
+        );
+      });
+    });
+    vi.stubGlobal("fetch", fetchMock);
+    const errorSpy = vi.spyOn(console, "error").mockImplementation(() => {});
+    const adapter = new CloudFileAttachmentAdapter(makeCloud());
+    const generator = adapter.add({ file: makeFile() });
+
+    const running = await generator.next();
+    const completion = generator.next();
+    await vi.waitFor(() => {
+      expect(fetchMock).toHaveBeenCalledOnce();
+    });
+
+    await adapter.remove(running.value!);
+    expect(fetchMock).toHaveBeenCalledWith(
+      "https://storage.example/upload",
+      expect.objectContaining({ signal: expect.any(AbortSignal) }),
+    );
+    expect(vi.mocked(fetchMock).mock.calls[0]?.[1]?.signal?.aborted).toBe(true);
+
+    await expect(completion).resolves.toEqual({ done: true, value: undefined });
+    expect(errorSpy).not.toHaveBeenCalled();
+    await expect(adapter.send(running.value!)).rejects.toThrow(
+      "Attachment not uploaded",
+    );
+  });
 });

package/src/react/runtimes/cloud/CloudFileAttachmentAdapter.ts

@@ -28,6 +28,10 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
   }
 
   private uploadedUrls = new Map<string, string>();
+  private activeUploads = new Map<
+    string,
+    { cancelled: boolean; controller: AbortController }
+  >();
 
   public async *add({
     file,
@@ -44,13 +48,20 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
       file,
       status: { type: "running", reason: "uploading", progress: 0 },
     };
-    yield attachment;
+    const controller = new AbortController();
+    const upload = { cancelled: false, controller };
+    this.activeUploads.set(id, upload);
 
     try {
+      yield attachment;
+      if (upload.cancelled) return;
+
       const { signedUrl, publicUrl } =
         await this.getCloud().files.generatePresignedUploadUrl({
           filename: file.name,
         });
+      if (upload.cancelled) return;
+
       const res = await fetch(signedUrl, {
         method: "PUT",
         body: file,
@@ -58,7 +69,10 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
           "Content-Type": file.type,
         },
         mode: "cors",
+        signal: controller.signal,
       });
+      if (upload.cancelled) return;
+
       if (!res.ok) {
         throw new Error(
           `Failed to upload file: ${res.status} ${res.statusText}`,
@@ -71,6 +85,8 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
       };
       yield attachment;
     } catch (error) {
+      if (upload.cancelled) return;
+
       console.error("[assistant-ui] Failed to upload attachment:", error);
       attachment = {
         ...attachment,
@@ -81,10 +97,20 @@ export class CloudFileAttachmentAdapter implements AttachmentAdapter {
         },
       };
       yield attachment;
+    } finally {
+      if (this.activeUploads.get(id) === upload) {
+        this.activeUploads.delete(id);
+      }
     }
   }
 
   public async remove(attachment: Attachment): Promise<void> {
+    const upload = this.activeUploads.get(attachment.id);
+    if (upload) {
+      upload.cancelled = true;
+      upload.controller.abort();
+      this.activeUploads.delete(attachment.id);
+    }
     this.uploadedUrls.delete(attachment.id);
   }
 

package/src/react/runtimes/cloud/auiV0.ts

@@ -2,11 +2,17 @@ import type {
   MessageStatus,
   SourceProviderMetadata,
   ThreadMessage,
+  ToolCallMessagePartMcpMetadata,
+  ToolCallTiming,
   ToolApprovalDisplay,
   ToolApprovalOption,
+  ReasoningMessagePart,
 } from "../../../types/message";
 import type { CompleteAttachment } from "../../../types/attachment";
-import { fromThreadMessageLike } from "../../../runtime/utils/thread-message-like";
+import {
+  fromThreadMessageLike,
+  type ThreadMessageLike,
+} from "../../../runtime/utils/thread-message-like";
 import type { CloudMessage } from "assistant-cloud";
 import { isJSONValue } from "../../../utils/json/is-json";
 import type {
@@ -33,11 +39,16 @@ type AuiV0MessagePart =
   | {
       readonly type: "text";
       readonly text: string;
+      readonly parentId?: string;
     }
   | {
       readonly type: "reasoning";
       readonly text: string;
       readonly unstable_summary?: string;
+      readonly providerMetadata?: NonNullable<
+        ReasoningMessagePart["providerMetadata"]
+      >;
+      readonly parentId?: string;
     }
   | {
       readonly type: "source";
@@ -46,6 +57,7 @@ type AuiV0MessagePart =
       readonly url: string;
       readonly title?: string;
       readonly providerMetadata?: SourceProviderMetadata;
+      readonly parentId?: string;
     }
   | {
       readonly type: "source";
@@ -55,25 +67,10 @@ type AuiV0MessagePart =
       readonly mediaType: string;
       readonly filename?: string;
       readonly providerMetadata?: SourceProviderMetadata;
+      readonly parentId?: string;
     }
-  | {
-      readonly type: "tool-call";
-      readonly toolCallId: string;
-      readonly toolName: string;
-      readonly args: ReadonlyJSONObject;
-      readonly result?: ReadonlyJSONValue;
-      readonly isError?: true;
-      readonly approval?: AuiV0ToolApproval;
-    }
-  | {
-      readonly type: "tool-call";
-      readonly toolCallId: string;
-      readonly toolName: string;
-      readonly argsText: string;
-      readonly result?: ReadonlyJSONValue;
-      readonly isError?: true;
-      readonly approval?: AuiV0ToolApproval;
-    }
+  | (AuiV0ToolCallPart &
+      ({ readonly args: ReadonlyJSONObject } | { readonly argsText: string }))
   | {
       readonly type: "image";
       readonly image: string;
@@ -84,17 +81,49 @@ type AuiV0MessagePart =
       readonly mimeType: string;
       readonly filename?: string;
       readonly sourceType?: "url" | "id";
+      readonly parentId?: string;
     }
   | {
       readonly type: "data";
       readonly name: string;
       readonly data: ReadonlyJSONValue;
+    }
+  | {
+      readonly type: "audio";
+      readonly audio: {
+        readonly data: string;
+        readonly format: "mp3" | "wav";
+      };
+    }
+  | {
+      readonly type: "generative-ui";
+      readonly spec: ReadonlyJSONObject;
+      readonly id?: string;
+      readonly parentId?: string;
     };
 
+type AuiV0ToolCallPart = {
+  readonly type: "tool-call";
+  readonly toolCallId: string;
+  readonly toolName: string;
+  readonly result?: ReadonlyJSONValue;
+  readonly isError?: true;
+  readonly interrupt?: {
+    readonly type: "human";
+    readonly payload: ReadonlyJSONValue;
+  };
+  readonly timing?: ToolCallTiming;
+  readonly mcp?: ToolCallMessagePartMcpMetadata;
+  readonly approval?: AuiV0ToolApproval;
+  readonly parentId?: string;
+  readonly messages?: readonly AuiV0Message[];
+};
+
 type AuiV0AttachmentPart =
   | {
       readonly type: "text";
       readonly text: string;
+      readonly parentId?: string;
     }
   | {
       readonly type: "image";
@@ -107,6 +136,7 @@ type AuiV0AttachmentPart =
       readonly mimeType: string;
       readonly filename?: string;
       readonly sourceType?: "url" | "id";
+      readonly parentId?: string;
     }
   | {
       readonly type: "audio";
@@ -131,6 +161,8 @@ type AuiV0Attachment = {
 };
 
 type AuiV0Message = {
+  readonly id?: string;
+  readonly createdAt?: string;
   readonly role: "assistant" | "user" | "system";
   readonly status?: MessageStatus;
   readonly content: readonly AuiV0MessagePart[];
@@ -155,7 +187,13 @@ const encodeAttachmentPart = (
   const type = part.type;
   switch (type) {
     case "text":
-      return { type: "text", text: part.text };
+      return {
+        type: "text",
+        text: part.text,
+        ...(part.parentId !== undefined
+          ? { parentId: part.parentId }
+          : undefined),
+      };
 
     case "image":
       return {
@@ -173,6 +211,9 @@ const encodeAttachmentPart = (
         ...(part.sourceType != null
           ? { sourceType: part.sourceType }
           : undefined),
+        ...(part.parentId !== undefined
+          ? { parentId: part.parentId }
+          : undefined),
       };
 
     case "audio":
@@ -234,7 +275,13 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
       const type = part.type;
       switch (type) {
         case "text":
-          return { type: "text", text: part.text };
+          return {
+            type: "text",
+            text: part.text,
+            ...(part.parentId !== undefined
+              ? { parentId: part.parentId }
+              : undefined),
+          };
 
         case "reasoning":
           return {
@@ -243,6 +290,12 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
             ...(part.unstable_summary !== undefined
               ? { unstable_summary: part.unstable_summary }
               : undefined),
+            ...(part.providerMetadata !== undefined
+              ? { providerMetadata: part.providerMetadata }
+              : undefined),
+            ...(part.parentId !== undefined
+              ? { parentId: part.parentId }
+              : undefined),
           };
 
         case "source":
@@ -256,6 +309,9 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
               ...(part.providerMetadata != null
                 ? { providerMetadata: part.providerMetadata }
                 : undefined),
+              ...(part.parentId !== undefined
+                ? { parentId: part.parentId }
+                : undefined),
             };
           }
 
@@ -271,6 +327,9 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
             ...(part.providerMetadata != null
               ? { providerMetadata: part.providerMetadata }
               : undefined),
+            ...(part.parentId !== undefined
+              ? { parentId: part.parentId }
+              : undefined),
           };
 
         case "tool-call": {
@@ -290,7 +349,25 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
               ? { result: part.result as ReadonlyJSONValue }
               : undefined),
             ...(part.isError ? { isError: true } : undefined),
+            ...(part.interrupt !== undefined
+              ? {
+                  interrupt: {
+                    type: part.interrupt.type,
+                    payload: part.interrupt.payload as ReadonlyJSONValue,
+                  },
+                }
+              : undefined),
+            ...(part.timing !== undefined
+              ? { timing: part.timing }
+              : undefined),
+            ...(part.mcp !== undefined ? { mcp: part.mcp } : undefined),
             ...(part.approval ? { approval: part.approval } : undefined),
+            ...(part.parentId !== undefined
+              ? { parentId: part.parentId }
+              : undefined),
+            ...(part.messages !== undefined
+              ? { messages: part.messages.map(encodeNestedMessage) }
+              : undefined),
           };
         }
 
@@ -304,6 +381,9 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
             mimeType: part.mimeType,
             ...(part.filename ? { filename: part.filename } : undefined),
             ...(part.sourceType ? { sourceType: part.sourceType } : undefined),
+            ...(part.parentId !== undefined
+              ? { parentId: part.parentId }
+              : undefined),
           };
 
         case "data": {
@@ -317,8 +397,24 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
           };
         }
 
+        case "audio":
+          return {
+            type: "audio",
+            audio: { data: part.audio.data, format: part.audio.format },
+          };
+
+        case "generative-ui":
+          return {
+            type: "generative-ui",
+            spec: part.spec as unknown as ReadonlyJSONObject,
+            ...(part.id !== undefined ? { id: part.id } : undefined),
+            ...(part.parentId !== undefined
+              ? { parentId: part.parentId }
+              : undefined),
+          };
+
         default: {
-          const unhandledType: "audio" | "generative-ui" = type;
+          const unhandledType: never = type;
           throw new Error(
             `Message part type not supported by aui/v0: ${unhandledType}`,
           );
@@ -335,14 +431,13 @@ export function auiV0Decode(
   cloudMessage: CloudMessage & { format: "aui/v0" },
 ): ExportedMessageRepositoryItem {
   const payload = cloudMessage.content as unknown as AuiV0Message;
-  const message = fromThreadMessageLike(
+  const message = decodeAuiV0Message(
     {
+      ...payload,
       id: cloudMessage.id,
       createdAt: cloudMessage.created_at,
-      ...payload,
     },
     cloudMessage.id,
-    { type: "complete", reason: "unknown" },
   );
 
   return {
@@ -350,3 +445,43 @@ export function auiV0Decode(
     message,
   };
 }
+
+const encodeNestedMessage = (message: ThreadMessage): AuiV0Message => ({
+  ...auiV0Encode(message),
+  id: message.id,
+  createdAt: message.createdAt.toISOString(),
+});
+
+const decodeAuiV0Message = (
+  payload: Omit<AuiV0Message, "createdAt"> & {
+    readonly createdAt?: Date | undefined;
+  },
+  fallbackId: string,
+): ThreadMessage =>
+  fromThreadMessageLike(
+    {
+      ...payload,
+      content: payload.content.map((part, index) => {
+        if (part.type !== "tool-call" || part.messages === undefined)
+          return part;
+        return {
+          ...part,
+          messages: part.messages.map((message, nestedIndex) =>
+            decodeAuiV0Message(
+              {
+                ...message,
+                createdAt:
+                  message.createdAt !== undefined
+                    ? new Date(message.createdAt)
+                    : payload.createdAt,
+              },
+              message.id ??
+                `${fallbackId}-${part.toolCallId}-${index}-${nestedIndex}`,
+            ),
+          ),
+        };
+      }),
+    } as ThreadMessageLike,
+    fallbackId,
+    { type: "complete", reason: "unknown" },
+  );

package/src/react/runtimes/cloud/createCloudThreadListAdapter.test.ts

@@ -4,6 +4,22 @@ import { describe, expect, it, vi } from "vitest";
 import { renderHook } from "@testing-library/react";
 import type { AssistantCloud } from "assistant-cloud";
 import { createCloudThreadListAdapter } from "./createCloudThreadListAdapter";
+import { CORE_SDK } from "./sdkIdentity";
+
+vi.mock("@assistant-ui/store", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@assistant-ui/store")>()),
+  useAui: () => ({
+    threads: {
+      getState: () => ({ mainThreadId: "local-1", threadItems: [] }),
+    },
+    thread: { getState: () => ({ isEmpty: true, suggestions: [] }) },
+    threadListItem: {
+      getState: () => ({ id: "local-1", remoteId: "remote-1" }),
+    },
+    on: () => () => {},
+    subscribe: () => () => {},
+  }),
+}));
 
 const makeCloud = () =>
   ({
@@ -15,6 +31,7 @@ const makeCloud = () =>
       get: vi.fn(),
     },
     runs: { stream: vi.fn(async () => new ReadableStream()) },
+    registerSdk: vi.fn(),
   }) as unknown as AssistantCloud;
 
 describe("createCloudThreadListAdapter", () => {
@@ -68,6 +85,25 @@ describe("createCloudThreadListAdapter", () => {
     expect(adapter.unstable_Provider).toBeUndefined();
   });
 
+  it("registers core and the calling integration identities", () => {
+    const cloud = makeCloud();
+    const sdk = { name: "@assistant-ui/ai-sdk", version: "0.0.5" };
+
+    createCloudThreadListAdapter({ cloud, sdk });
+
+    expect(cloud.registerSdk).toHaveBeenNthCalledWith(1, CORE_SDK);
+    expect(cloud.registerSdk).toHaveBeenNthCalledWith(2, sdk);
+  });
+
+  it("registers only core without a calling integration identity", () => {
+    const cloud = makeCloud();
+
+    createCloudThreadListAdapter({ cloud });
+
+    expect(cloud.registerSdk).toHaveBeenCalledOnce();
+    expect(cloud.registerSdk).toHaveBeenCalledWith(CORE_SDK);
+  });
+
   it("constructs stable history and attachment adapters when the hook runs", () => {
     const cloud = makeCloud();
     const adapter = createCloudThreadListAdapter({ cloud });

package/src/react/runtimes/cloud/createCloudThreadListAdapter.ts

@@ -1,7 +1,7 @@
 declare const process: { env: Record<string, string | undefined> };
 
 import { type RefObject, useMemo, useState } from "react";
-import { AssistantCloud } from "assistant-cloud";
+import { AssistantCloud, type SdkIdentity } from "assistant-cloud";
 import type {
   RemoteThreadListAdapter,
   RuntimeAdapters,
@@ -10,6 +10,7 @@ import { InMemoryThreadListAdapter } from "../../../runtimes/remote-thread-list/
 import { useAssistantCloudThreadHistoryAdapter } from "./AssistantCloudThreadHistoryAdapter";
 import { CloudFileAttachmentAdapter } from "./CloudFileAttachmentAdapter";
 import { isRecord } from "../../../utils/json/is-json";
+import { CORE_SDK } from "./sdkIdentity";
 
 type ThreadData = {
   externalId: string | undefined;
@@ -17,6 +18,7 @@ type ThreadData = {
 
 export type CloudThreadListAdapterOptions = {
   cloud?: AssistantCloud | undefined;
+  sdk?: SdkIdentity | undefined;
 
   create?: (() => Promise<ThreadData>) | undefined;
   delete?: ((threadId: string) => Promise<void>) | undefined;
@@ -43,6 +45,7 @@ export const useCloudRuntimeAdapters = (
     () => ({
       history,
       attachments,
+      feedback: history.feedback,
     }),
     [history, attachments],
   );
@@ -115,6 +118,10 @@ export const createCloudThreadListAdapter = (
     return inMemory;
   }
 
+  cloud.registerSdk?.(CORE_SDK);
+  const sdk = getOptions().sdk;
+  if (sdk) cloud.registerSdk?.(sdk);
+
   return {
     list: async ({ after } = {}) => {
       const {

package/src/react/runtimes/cloud/sdkIdentity.ts

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

package/src/react/runtimes/cloud/useCloudThreadListAdapter.test.tsx

@@ -36,9 +36,11 @@ describe("useCloudThreadListAdapter", () => {
     const cloudDeleteA = vi.fn(async () => {});
     const cloudDeleteB = vi.fn(async () => {});
     const cloudA = {
+      registerSdk: vi.fn(),
       threads: { delete: cloudDeleteA },
     } as unknown as AssistantCloud;
     const cloudB = {
+      registerSdk: vi.fn(),
       threads: { delete: cloudDeleteB },
     } as unknown as AssistantCloud;
     const committed: { current: RemoteThreadListAdapter | null } = {
@@ -117,7 +119,10 @@ describe("useCloudThreadListAdapter", () => {
       .fn()
       .mockResolvedValueOnce({ threads: activeThreads })
       .mockResolvedValueOnce({ threads: archivedThreads });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const page = await result.current.list();
@@ -149,7 +154,10 @@ describe("useCloudThreadListAdapter", () => {
       .mockResolvedValueOnce({ threads: firstPage })
       .mockResolvedValueOnce({ threads: [] })
       .mockResolvedValueOnce({ threads: secondPage });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const first = await result.current.list();
@@ -186,7 +194,10 @@ describe("useCloudThreadListAdapter", () => {
       .mockResolvedValueOnce({ threads: archivedPage1 })
       .mockResolvedValueOnce({ threads: activePage2 })
       .mockResolvedValueOnce({ threads: archivedPage2 });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const page1 = await result.current.list();
@@ -213,7 +224,10 @@ describe("useCloudThreadListAdapter", () => {
       .fn()
       .mockResolvedValueOnce({ threads: activeThreads })
       .mockResolvedValueOnce({ threads: [] });
-    const cloud = { threads: { list } } as unknown as AssistantCloud;
+    const cloud = {
+      registerSdk: vi.fn(),
+      threads: { list },
+    } as unknown as AssistantCloud;
     const { result } = renderHook(() => useCloudThreadListAdapter({ cloud }));
 
     const page = await result.current.list({ after: "thread-20" });