@assistant-ui/core 0.3.18 → 0.3.20

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,77 @@ describe("CloudFileAttachmentAdapter", () => {
       "Attachment not uploaded",
     );
   });
+
+  it("does not finish an upload removed while requesting its URL", async () => {
+    const presigned =
+      deferred<
+        Awaited<
+          ReturnType<AssistantCloud["files"]["generatePresignedUploadUrl"]>
+        >
+      >();
+    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({
+      success: true,
+      signedUrl: "https://storage.example/upload",
+      expiresAt: "2026-09-16T00:00:00.000Z",
+      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,13 +2,26 @@ 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 { isJSONValue, isRecord } from "../../../utils/json/is-json";
+import {
+  MAX_STORED_MESSAGE_DEPTH,
+  isStoredAuiV0RolePart,
+  isStoredMessageRole,
+  parseStoredAttachment,
+  parseStoredDate,
+} from "../../../runtime/utils/stored-message-parts";
 import type {
   ReadonlyJSONObject,
   ReadonlyJSONValue,
@@ -33,11 +46,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 +64,7 @@ type AuiV0MessagePart =
       readonly url: string;
       readonly title?: string;
       readonly providerMetadata?: SourceProviderMetadata;
+      readonly parentId?: string;
     }
   | {
       readonly type: "source";
@@ -55,25 +74,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 +88,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 +143,7 @@ type AuiV0AttachmentPart =
       readonly mimeType: string;
       readonly filename?: string;
       readonly sourceType?: "url" | "id";
+      readonly parentId?: string;
     }
   | {
       readonly type: "audio";
@@ -131,6 +168,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 +194,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 +218,9 @@ const encodeAttachmentPart = (
         ...(part.sourceType != null
           ? { sourceType: part.sourceType }
           : undefined),
+        ...(part.parentId !== undefined
+          ? { parentId: part.parentId }
+          : undefined),
       };
 
     case "audio":
@@ -234,7 +282,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 +297,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 +316,9 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
               ...(part.providerMetadata != null
                 ? { providerMetadata: part.providerMetadata }
                 : undefined),
+              ...(part.parentId !== undefined
+                ? { parentId: part.parentId }
+                : undefined),
             };
           }
 
@@ -271,6 +334,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 +356,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 +388,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 +404,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}`,
           );
@@ -331,18 +434,130 @@ export function auiV0Encode(message: ThreadMessage): AuiV0Message {
   };
 }
 
+const readableAuiV0Parts = (
+  role: AuiV0Message["role"],
+  content: readonly unknown[],
+  depth: number,
+): AuiV0MessagePart[] =>
+  content.flatMap((part) => {
+    if (!isStoredAuiV0RolePart(role, part)) return [];
+    if (part.type !== "tool-call" || part.messages === undefined)
+      return [part as unknown as AuiV0MessagePart];
+
+    const { messages, ...toolCall } = part;
+    if (!Array.isArray(messages) || depth >= MAX_STORED_MESSAGE_DEPTH)
+      return [toolCall as unknown as AuiV0MessagePart];
+    return [
+      {
+        ...toolCall,
+        messages: messages.flatMap((message) => {
+          const nested = readableAuiV0Message(message, depth + 1);
+          return nested ? [nested] : [];
+        }),
+      } as unknown as AuiV0MessagePart,
+    ];
+  });
+
+const readableAuiV0Attachments = (
+  attachments: readonly unknown[],
+): AuiV0Attachment[] =>
+  attachments.flatMap((attachment) => {
+    const parsed = parseStoredAttachment(attachment, (value) =>
+      isStoredAuiV0RolePart("user", value),
+    );
+    return parsed ? [parsed as unknown as AuiV0Attachment] : [];
+  });
+
+const readableAuiV0Message = (
+  value: unknown,
+  depth: number,
+): AuiV0Message | null => {
+  if (
+    !isRecord(value) ||
+    !isStoredMessageRole(value.role) ||
+    !Array.isArray(value.content)
+  ) {
+    return null;
+  }
+
+  const { role } = value;
+  const content = readableAuiV0Parts(role, value.content, depth);
+  // fromThreadMessageLike takes a system row only with exactly one text part,
+  // so one that no longer matches after filtering is dropped here rather than
+  // costing the row or the tool call that carries it.
+  if (role === "system" && content.length !== 1) return null;
+
+  const { attachments, createdAt, status, metadata, ...rest } = value;
+  // decodeAuiV0Message turns a nested createdAt into a Date without checking
+  // it, and encodeNestedMessage later calls toISOString on the result, so an
+  // unparseable one would reject the next write to the message that holds it.
+  // Dropping the field falls back to the parent's timestamp.
+  const storedCreatedAt = parseStoredDate(createdAt);
+  const readableMetadata =
+    role === "assistant" || !isRecord(metadata)
+      ? metadata
+      : { ...metadata, steps: undefined };
+
+  return {
+    ...rest,
+    ...(storedCreatedAt ? { createdAt } : undefined),
+    // fromThreadMessageLike throws on a status, a metadata.steps or an
+    // attachments list carried by a row whose role cannot hold one, and
+    // auiV0Encode only ever writes each onto the role that can, so dropping a
+    // misplaced field costs no valid data and saves the row.
+    ...(role === "assistant" && status !== undefined ? { status } : undefined),
+    ...(metadata !== undefined ? { metadata: readableMetadata } : undefined),
+    content,
+    ...(role === "user" && Array.isArray(attachments)
+      ? { attachments: readableAuiV0Attachments(attachments) }
+      : undefined),
+  } as unknown as AuiV0Message;
+};
+
+/**
+ * Decodes a stored row, dropping the parts, attachments and nested messages
+ * that cannot be read back instead of rejecting the row, and returning null
+ * when the row itself is unreadable. Loading a thread must not fail because a
+ * single stored row is malformed.
+ */
+export function auiV0DecodeSafely(
+  cloudMessage: CloudMessage & { format: "aui/v0" },
+): ExportedMessageRepositoryItem | null {
+  try {
+    const payload = readableAuiV0Message(cloudMessage.content, 0);
+    if (!payload) throw new Error("stored row is not an aui/v0 message");
+
+    return {
+      parentId: cloudMessage.parent_id,
+      message: decodeAuiV0Message(
+        {
+          ...payload,
+          id: cloudMessage.id,
+          createdAt: cloudMessage.created_at,
+        },
+        cloudMessage.id,
+      ),
+    };
+  } catch (error) {
+    console.warn(
+      `aui/v0: dropping unreadable message ${cloudMessage.id}`,
+      error,
+    );
+    return null;
+  }
+}
+
 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 +565,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" },
+  );