@assistant-ui/core 0.2.20 → 0.2.22

package/src/tests/attachment-adapters.test.ts

@@ -2,10 +2,22 @@ import { describe, expect, it } from "vitest";
 import type { PendingAttachment } from "../types/attachment";
 import {
   type AttachmentAdapter,
+  fileMatchesAccept,
   SimpleImageAttachmentAdapter,
   SimpleTextAttachmentAdapter,
 } from "../adapters/attachment";
 
+describe("fileMatchesAccept", () => {
+  it("matches MIME types with parameters", () => {
+    expect(
+      fileMatchesAccept(
+        { name: "data.json", type: "application/json; charset=utf-8" },
+        "application/json",
+      ),
+    ).toBe(true);
+  });
+});
+
 describe("SimpleTextAttachmentAdapter", () => {
   const makeFile = (contents: string, name = "notes.md") =>
     new File([contents], name, { type: "text/markdown" });
@@ -16,7 +28,7 @@ describe("SimpleTextAttachmentAdapter", () => {
     })) as PendingAttachment;
 
     expect(pending).toMatchObject({
-      id: "notes.md",
+      id: expect.any(String),
       type: "document",
       name: "notes.md",
       contentType: "text/markdown",
@@ -61,7 +73,7 @@ describe("SimpleImageAttachmentAdapter", () => {
     })) as PendingAttachment;
 
     expect(pending).toMatchObject({
-      id: "pixel.png",
+      id: expect.any(String),
       type: "image",
       name: "pixel.png",
       contentType: "image/png",

package/src/tests/auiV0Encode.test.ts

@@ -1,5 +1,5 @@
 import { describe, expect, it } from "vitest";
-import { auiV0Encode } from "../react/runtimes/cloud/auiV0";
+import { auiV0Decode, auiV0Encode } from "../react/runtimes/cloud/auiV0";
 
 describe("auiV0Encode", () => {
   it("preserves document source parts in the core cloud encoder", () => {
@@ -52,4 +52,137 @@ describe("auiV0Encode", () => {
       },
     ]);
   });
+
+  it("preserves user attachments in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "please review this" }],
+      attachments: [
+        {
+          id: "att-1",
+          type: "document",
+          name: "proposal.pdf",
+          contentType: "application/pdf",
+          status: { type: "complete" },
+          content: [
+            {
+              type: "file",
+              data: "data:application/pdf;base64,JVBERi0xLjQ=",
+              mimeType: "application/pdf",
+              filename: "proposal.pdf",
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(encoded.attachments).toEqual([
+      {
+        id: "att-1",
+        type: "document",
+        name: "proposal.pdf",
+        contentType: "application/pdf",
+        status: { type: "complete" },
+        content: [
+          {
+            type: "file",
+            data: "data:application/pdf;base64,JVBERi0xLjQ=",
+            mimeType: "application/pdf",
+            filename: "proposal.pdf",
+          },
+        ],
+      },
+    ]);
+  });
+
+  it("omits missing attachment contentType in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "please review this" }],
+      attachments: [
+        {
+          id: "att-1",
+          type: "document",
+          name: "notes.txt",
+          status: { type: "complete" },
+          content: [{ type: "text", text: "notes" }],
+        },
+      ],
+    });
+
+    expect(encoded.attachments).toEqual([
+      {
+        id: "att-1",
+        type: "document",
+        name: "notes.txt",
+        status: { type: "complete" },
+        content: [{ type: "text", text: "notes" }],
+      },
+    ]);
+  });
+});
+
+describe("auiV0Decode", () => {
+  it("restores user attachments from core cloud history", () => {
+    const content = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [{ type: "text", text: "please review this" }],
+      attachments: [
+        {
+          id: "att-1",
+          type: "document",
+          name: "proposal.pdf",
+          contentType: "application/pdf",
+          status: { type: "complete" },
+          content: [
+            {
+              type: "file",
+              data: "data:application/pdf;base64,JVBERi0xLjQ=",
+              mimeType: "application/pdf",
+              filename: "proposal.pdf",
+            },
+          ],
+        },
+      ],
+    });
+
+    const decoded = auiV0Decode({
+      id: "cloud",
+      parent_id: null,
+      height: 0,
+      created_at: new Date("2026-03-15T00:00:00.000Z"),
+      updated_at: new Date("2026-03-15T00:00:00.000Z"),
+      format: "aui/v0",
+      content: content as never,
+    });
+
+    expect(decoded.message.role).toBe("user");
+    if (decoded.message.role !== "user") throw new Error("expected user");
+    expect(decoded.message.attachments).toEqual([
+      {
+        id: "att-1",
+        type: "document",
+        name: "proposal.pdf",
+        contentType: "application/pdf",
+        status: { type: "complete" },
+        content: [
+          {
+            type: "file",
+            data: "data:application/pdf;base64,JVBERi0xLjQ=",
+            mimeType: "application/pdf",
+            filename: "proposal.pdf",
+          },
+        ],
+      },
+    ]);
+  });
 });

package/src/tests/base-composer-runtime-core-addAttachment.test.ts

@@ -1,6 +1,9 @@
 import { describe, expect, it, vi } from "vitest";
 import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
-import type { AttachmentAdapter } from "../adapters/attachment";
+import {
+  SimpleTextAttachmentAdapter,
+  type AttachmentAdapter,
+} from "../adapters/attachment";
 import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
 import type { PendingAttachment } from "../types/attachment";
 
@@ -125,6 +128,84 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     expect(onError).not.toHaveBeenCalled();
   });
 
+  it("adds prepared attachments when File is unavailable", async () => {
+    const composer = makeComposer();
+    const fileConstructor = globalThis.File;
+    vi.stubGlobal("File", undefined);
+
+    try {
+      await composer.addAttachment({
+        name: "notes.txt",
+        contentType: "text/plain",
+        content: [{ type: "text", text: "hello" }],
+      });
+    } finally {
+      vi.stubGlobal("File", fileConstructor);
+    }
+
+    expect(composer.attachments[0]).toMatchObject({
+      type: "document",
+      name: "notes.txt",
+      contentType: "text/plain",
+      content: [{ type: "text", text: "hello" }],
+      status: { type: "complete" },
+    });
+  });
+
+  it("uses the adapter for foreign files that expose content", async () => {
+    const add = vi.fn(makeAdapter().add);
+    const composer = makeComposer(makeAdapter({ add }));
+    const foreignFile = {
+      name: "photo.png",
+      type: "image/png",
+      lastModified: 0,
+      content: [{ type: "text", text: "implementation detail" }],
+    } as File;
+
+    await composer.addAttachment(foreignFile);
+
+    expect(add).toHaveBeenCalledWith({ file: foreignFile });
+    expect(composer.attachments[0]).toMatchObject({
+      type: "image",
+      name: "photo.png",
+      contentType: "image/png",
+    });
+  });
+
+  it("accepts JSON files with the application/json media type", async () => {
+    const composer = makeComposer(new SimpleTextAttachmentAdapter());
+
+    await expect(
+      composer.addAttachment(
+        new File(["{}"], "data.json", { type: "application/json" }),
+      ),
+    ).resolves.toBeUndefined();
+
+    expect(composer.attachments[0]).toMatchObject({
+      type: "document",
+      name: "data.json",
+      contentType: "application/json",
+    });
+  });
+
+  it("keeps different files with the same name as separate attachments", async () => {
+    const composer = makeComposer(new SimpleTextAttachmentAdapter());
+
+    await composer.addAttachment(
+      new File(["first"], "notes.txt", { type: "text/plain" }),
+    );
+    await composer.addAttachment(
+      new File(["second"], "notes.txt", { type: "text/plain" }),
+    );
+
+    expect(composer.attachments).toHaveLength(2);
+    expect(composer.attachments[0]!.id).not.toBe(composer.attachments[1]!.id);
+    expect(composer.attachments.map((attachment) => attachment.name)).toEqual([
+      "notes.txt",
+      "notes.txt",
+    ]);
+  });
+
   it("does not let subscriber errors mask the original throw", async () => {
     const composer = makeComposer(makeAdapter());
     composer.unstable_on("attachmentAddError", () => {
@@ -177,10 +258,46 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     expect(onAdd).not.toHaveBeenCalled();
     expect(composer.attachments).toHaveLength(1);
     const att = composer.attachments[0]!;
-    expect(att.status.type).toBe("incomplete");
-    if (att.status.type === "incomplete") {
-      expect(att.status.reason).toBe("error");
-    }
+    expect(att.status).toEqual({
+      type: "incomplete",
+      reason: "error",
+      message: "network error",
+    });
+  });
+
+  it("forwards the status message when adapter yields an errored attachment with one", async () => {
+    const composer = makeComposer(
+      makeAdapter({
+        add: async ({ file }) => ({
+          id: "att-3",
+          type: "image",
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: {
+            type: "incomplete",
+            reason: "error",
+            message: "Failed to upload file: 403 Forbidden",
+          },
+        }),
+      }),
+    );
+    const onError = vi.fn();
+    composer.unstable_on("attachmentAddError", onError);
+
+    await composer.addAttachment(
+      new File(["x"], "f.png", { type: "image/png" }),
+    );
+
+    expect(onError).toHaveBeenCalledTimes(1);
+    expect(onError).toHaveBeenCalledWith(
+      expect.objectContaining({
+        reason: "adapter-error",
+        message: "Failed to upload file: 403 Forbidden",
+        attachmentId: "att-3",
+      }),
+    );
+    expect(onError.mock.calls[0]![0]).not.toHaveProperty("error");
   });
 
   it("emits attachmentAddError with attachment id when adapter yields an errored attachment", async () => {
@@ -209,6 +326,7 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     expect(onError).toHaveBeenCalledWith(
       expect.objectContaining({
         reason: "adapter-error",
+        message: "Attachment upload did not complete successfully.",
         attachmentId: "att-2",
       }),
     );