@assistant-ui/core 0.2.20 → 0.2.21

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,40 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     expect(onError).not.toHaveBeenCalled();
   });
 
+  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 +214,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 +282,7 @@ describe("BaseComposerRuntimeCore.addAttachment error events", () => {
     expect(onError).toHaveBeenCalledWith(
       expect.objectContaining({
         reason: "adapter-error",
+        message: "Attachment upload did not complete successfully.",
         attachmentId: "att-2",
       }),
     );

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

@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from "vitest";
+import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { PendingAttachment } from "../types/attachment";
+
+const makeAdapter = (
+  overrides: Partial<AttachmentAdapter> = {},
+): AttachmentAdapter => ({
+  accept: "*",
+  add: async ({ file }: { file: File }): Promise<PendingAttachment> => ({
+    id: "att-1",
+    type: "image",
+    name: file.name,
+    contentType: file.type,
+    file,
+    status: { type: "requires-action", reason: "composer-send" },
+  }),
+  remove: async () => {},
+  send: async (a) => ({ ...a, status: { type: "complete" }, content: [] }),
+  ...overrides,
+});
+
+const makeComposer = (adapter?: AttachmentAdapter) => {
+  const append = vi.fn();
+  const runtime = {
+    append,
+    cancelRun: vi.fn(),
+    subscribe: vi.fn(() => () => {}),
+    capabilities: { cancel: false },
+    messages: [],
+    getModelContext: () => ({ unstable_composerMetadata: undefined }),
+    adapters: adapter ? { attachments: adapter } : undefined,
+  } as unknown as Omit<ThreadRuntimeCore, "composer"> & {
+    adapters?: { attachments?: AttachmentAdapter };
+  };
+  const composer = new DefaultThreadComposerRuntimeCore(runtime);
+  return { composer, append };
+};
+
+const textFile = () => new File(["content"], "f.txt", { type: "text/plain" });
+
+describe("BaseComposerRuntimeCore.send restore-on-failure", () => {
+  it("restores text, attachments, and quote when an upload fails", async () => {
+    const adapter = makeAdapter({
+      send: async () => {
+        throw new Error("upload failed");
+      },
+    });
+    const { composer, append } = makeComposer(adapter);
+
+    composer.setText("hello");
+    await composer.addAttachment(textFile());
+    composer.setQuote({ text: "quoted", messageId: "m-1" });
+    const originalAttachments = composer.attachments;
+
+    await expect(composer.send()).rejects.toThrow("upload failed");
+
+    expect(composer.text).toBe("hello");
+    expect(composer.attachments).toEqual(originalAttachments);
+    expect(composer.attachments).toHaveLength(1);
+    expect(composer.quote).toEqual({ text: "quoted", messageId: "m-1" });
+    expect(append).not.toHaveBeenCalled();
+  });
+
+  it("does not clobber text the user typed while the upload was in flight", async () => {
+    let rejectSend!: (e: Error) => void;
+    const adapter = makeAdapter({
+      send: () =>
+        new Promise((_resolve, reject) => {
+          rejectSend = reject;
+        }),
+    });
+    const { composer, append } = makeComposer(adapter);
+
+    composer.setText("hello");
+    await composer.addAttachment(textFile());
+
+    const sendPromise = composer.send();
+    composer.setText("new draft");
+    rejectSend(new Error("upload failed"));
+
+    await expect(sendPromise).rejects.toThrow("upload failed");
+
+    expect(composer.text).toBe("new draft");
+    expect(composer.attachments).toHaveLength(0);
+    expect(append).not.toHaveBeenCalled();
+  });
+
+  it("does not clobber a quote the user set while the upload was in flight", async () => {
+    let rejectSend!: (e: Error) => void;
+    const adapter = makeAdapter({
+      send: () =>
+        new Promise((_resolve, reject) => {
+          rejectSend = reject;
+        }),
+    });
+    const { composer, append } = makeComposer(adapter);
+
+    composer.setText("hello");
+    await composer.addAttachment(textFile());
+
+    const sendPromise = composer.send();
+    composer.setQuote({ text: "new quote", messageId: "m-2" });
+    rejectSend(new Error("upload failed"));
+
+    await expect(sendPromise).rejects.toThrow("upload failed");
+
+    expect(composer.quote).toEqual({ text: "new quote", messageId: "m-2" });
+    expect(composer.text).toBe("");
+    expect(composer.attachments).toHaveLength(0);
+    expect(append).not.toHaveBeenCalled();
+  });
+
+  it("sends and clears the composer on a successful upload", async () => {
+    const { composer, append } = makeComposer(makeAdapter());
+
+    composer.setText("hello");
+    await composer.addAttachment(textFile());
+
+    await composer.send();
+
+    expect(composer.isEmpty).toBe(true);
+    expect(composer.attachments).toHaveLength(0);
+    expect(append).toHaveBeenCalledTimes(1);
+    const message = append.mock.calls[0]![0];
+    expect(message.content).toEqual([{ type: "text", text: "hello" }]);
+    expect(message.attachments).toHaveLength(1);
+    expect(message.attachments[0].status).toEqual({ type: "complete" });
+  });
+
+  it("sends a text-only message with no attachment adapter", async () => {
+    const { composer, append } = makeComposer();
+
+    composer.setText("hello");
+
+    await composer.send();
+
+    expect(composer.isEmpty).toBe(true);
+    expect(append).toHaveBeenCalledTimes(1);
+    expect(append.mock.calls[0]![0].content).toEqual([
+      { type: "text", text: "hello" },
+    ]);
+  });
+});

package/src/tests/thread-message-like.test.ts

@@ -160,4 +160,44 @@ describe("fromThreadMessageLike", () => {
       expect(result.content).toEqual([]);
     });
   });
+
+  describe("providerMetadata passthrough", () => {
+    it("keeps providerMetadata on text, reasoning, and tool-call parts", () => {
+      const providerMetadata = { acme: { agentName: "researcher" } };
+      const result = fromThreadMessageLike(
+        {
+          role: "assistant",
+          content: [
+            { type: "text", text: "hi", providerMetadata },
+            { type: "reasoning", text: "thinking", providerMetadata },
+            {
+              type: "tool-call",
+              toolCallId: "tc-1",
+              toolName: "search",
+              args: { query: "hi" },
+              providerMetadata,
+            },
+          ],
+        },
+        fallbackId,
+        fallbackStatus,
+      );
+
+      expect(result.content[0]).toMatchObject({
+        type: "text",
+        text: "hi",
+        providerMetadata,
+      });
+      expect(result.content[1]).toMatchObject({
+        type: "reasoning",
+        text: "thinking",
+        providerMetadata,
+      });
+      expect(result.content[2]).toMatchObject({
+        type: "tool-call",
+        toolCallId: "tc-1",
+        providerMetadata,
+      });
+    });
+  });
 });

package/src/types/attachment.ts

@@ -13,6 +13,7 @@ export type PendingAttachmentStatus =
   | {
       type: "incomplete";
       reason: "error" | "upload-paused";
+      message?: string;
     };
 
 export type CompleteAttachmentStatus = {

package/src/types/error.test.ts

@@ -0,0 +1,122 @@
+import { describe, it, expect } from "vitest";
+import {
+  toAssistantError,
+  isAssistantError,
+  type AssistantError,
+} from "./error";
+
+describe("toAssistantError", () => {
+  it("converts an Error instance", () => {
+    expect(toAssistantError(new Error("boom"))).toEqual({
+      code: "unknown",
+      message: "boom",
+    });
+  });
+
+  it("converts a string", () => {
+    expect(toAssistantError("plain failure")).toEqual({
+      code: "unknown",
+      message: "plain failure",
+    });
+  });
+
+  it("converts a plain object", () => {
+    const value = { foo: 1 };
+    expect(toAssistantError(value)).toEqual({
+      code: "unknown",
+      message: `[object] ${String(value)}`,
+    });
+  });
+
+  it("converts a thrown Symbol", () => {
+    const value = Symbol("x");
+    expect(toAssistantError(value)).toEqual({
+      code: "unknown",
+      message: `[symbol] ${String(value)}`,
+    });
+  });
+
+  it("converts a thrown number", () => {
+    expect(toAssistantError(42)).toEqual({
+      code: "unknown",
+      message: "[number] 42",
+    });
+  });
+
+  it("converts a thrown null", () => {
+    expect(toAssistantError(null)).toEqual({
+      code: "unknown",
+      message: "[object] null",
+    });
+  });
+
+  it("converts an object whose toString throws", () => {
+    const value = {
+      toString() {
+        throw new Error("toString failed");
+      },
+    };
+    expect(toAssistantError(value)).toEqual({
+      code: "unknown",
+      message: "[object]",
+    });
+  });
+
+  it("passes an AssistantError through unchanged", () => {
+    const error: AssistantError = {
+      code: "network",
+      message: "offline",
+      severity: "warning",
+      display: "toast",
+    };
+    expect(toAssistantError(error)).toBe(error);
+  });
+});
+
+describe("isAssistantError", () => {
+  it("accepts a minimal valid value", () => {
+    expect(isAssistantError({ code: "unknown", message: "x" })).toBe(true);
+  });
+
+  it("accepts optional severity and display literals", () => {
+    expect(
+      isAssistantError({
+        code: "provider",
+        message: "rate limited",
+        severity: "info",
+        display: "silent",
+      }),
+    ).toBe(true);
+  });
+
+  it("rejects non-objects", () => {
+    expect(isAssistantError("fail")).toBe(false);
+    expect(isAssistantError(null)).toBe(false);
+    expect(isAssistantError(undefined)).toBe(false);
+  });
+
+  it("rejects missing code or message", () => {
+    expect(isAssistantError({ code: "unknown" })).toBe(false);
+    expect(isAssistantError({ message: "x" })).toBe(false);
+  });
+
+  it("rejects a bad severity literal", () => {
+    expect(
+      isAssistantError({
+        code: "unknown",
+        message: "x",
+        severity: "fatal",
+      }),
+    ).toBe(false);
+  });
+
+  it("rejects a bad display literal", () => {
+    expect(
+      isAssistantError({
+        code: "unknown",
+        message: "x",
+        display: "modal",
+      }),
+    ).toBe(false);
+  });
+});

package/src/types/error.ts

@@ -0,0 +1,74 @@
+export type ErrorSeverity = "critical" | "warning" | "info";
+
+export type ErrorDisplay = "inline" | "toast" | "silent" | "dev-only";
+
+export type AssistantErrorCode =
+  | "unknown"
+  | "network"
+  | "provider"
+  | (string & {});
+
+export type AssistantError = {
+  readonly code: AssistantErrorCode;
+  readonly message: string;
+  readonly severity?: ErrorSeverity;
+  readonly display?: ErrorDisplay;
+};
+
+const ERROR_SEVERITIES: readonly string[] = ["critical", "warning", "info"];
+
+const ERROR_DISPLAYS: readonly string[] = [
+  "inline",
+  "toast",
+  "silent",
+  "dev-only",
+];
+
+export const isAssistantError = (value: unknown): value is AssistantError => {
+  if (typeof value !== "object" || value === null) return false;
+  const candidate = value as Record<string, unknown>;
+  if (
+    typeof candidate.code !== "string" ||
+    typeof candidate.message !== "string"
+  ) {
+    return false;
+  }
+  if (
+    "severity" in candidate &&
+    candidate.severity !== undefined &&
+    (typeof candidate.severity !== "string" ||
+      !ERROR_SEVERITIES.includes(candidate.severity))
+  ) {
+    return false;
+  }
+  if (
+    "display" in candidate &&
+    candidate.display !== undefined &&
+    (typeof candidate.display !== "string" ||
+      !ERROR_DISPLAYS.includes(candidate.display))
+  ) {
+    return false;
+  }
+  return true;
+};
+
+export const toAssistantError = (error: unknown): AssistantError => {
+  if (isAssistantError(error)) return error;
+  if (error instanceof Error) {
+    return { code: "unknown", message: error.message };
+  }
+  if (typeof error === "string") {
+    return { code: "unknown", message: error };
+  }
+  try {
+    return {
+      code: "unknown",
+      message: `[${typeof error}] ${String(error)}`,
+    };
+  } catch {
+    return {
+      code: "unknown",
+      message: `[${typeof error}]`,
+    };
+  }
+};

package/src/types/index.ts

@@ -2,6 +2,7 @@ export type {
   // Message parts
   TextMessagePart,
   ReasoningMessagePart,
+  PartProviderMetadata,
   SourceProviderMetadata,
   SourceMessagePart,
   ImageMessagePart,