@assistant-ui/core 0.3.15 → 0.3.16

package/src/tests/external-thread-attachments.test.tsx

@@ -582,3 +582,176 @@ describe("ExternalThread attachments", () => {
     vi.restoreAllMocks();
   });
 });
+
+describe("cancelled edit sessions", () => {
+  const editSetup = (
+    add: (arg: { file: File }) => Promise<PendingAttachment>,
+  ) =>
+    renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: {
+        accept: "*",
+        add,
+        send: async () => ({}) as never,
+        remove: async () => {},
+      },
+    });
+
+  it("does not leak an in-flight add into the next edit session", async () => {
+    let resolveAdd!: (attachment: PendingAttachment) => void;
+    const aui = editSetup(
+      () =>
+        new Promise<PendingAttachment>((resolve) => {
+          resolveAdd = resolve;
+        }),
+    );
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => {
+      composer().beginEdit();
+    });
+    let addPromise!: Promise<void>;
+    await act(async () => {
+      addPromise = composer().addAttachment(
+        new File(["data"], "notes.txt", { type: "text/plain" }),
+      );
+    });
+    await act(async () => {
+      composer().cancel();
+    });
+    await act(async () => {
+      composer().beginEdit();
+    });
+    await act(async () => {
+      resolveAdd({
+        id: "leak-1",
+        type: "document",
+        name: "notes.txt",
+        contentType: "text/plain",
+        file: new File(["data"], "notes.txt", { type: "text/plain" }),
+        status: { type: "pending", reason: "uploading", progress: 0 },
+      } as PendingAttachment);
+      await addPromise.catch(() => {});
+    });
+
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
+  it("adapter-removes the session's pending attachments on cancel, sparing prefilled ones", async () => {
+    const remove = vi.fn(async () => {});
+    const aui = renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [
+            {
+              id: "prefilled-1",
+              type: "document",
+              name: "existing.txt",
+              contentType: "text/plain",
+              content: [],
+              status: { type: "complete" },
+            } as unknown as CompleteAttachment,
+          ],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: {
+        accept: "*",
+        add: async ({ file }: { file: File }) =>
+          ({
+            id: "pending-1",
+            type: "document",
+            name: file.name,
+            contentType: file.type,
+            file,
+            status: { type: "pending", reason: "uploading", progress: 0 },
+          }) as PendingAttachment,
+        send: async () => ({}) as never,
+        remove,
+      },
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => {
+      composer().beginEdit();
+    });
+    await act(() =>
+      composer().addAttachment(
+        new File(["data"], "notes.txt", { type: "text/plain" }),
+      ),
+    );
+    expect(composer().getState().attachments).toHaveLength(2);
+
+    await act(async () => {
+      composer().cancel();
+    });
+
+    await waitFor(() => expect(remove).toHaveBeenCalledTimes(1));
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "pending-1" }),
+    );
+
+    await act(async () => {
+      composer().cancel();
+    });
+    expect(remove).toHaveBeenCalledTimes(1);
+  });
+
+  it("keeps the thread composer's in-flight add across a run cancel", async () => {
+    let resolveAdd!: (attachment: PendingAttachment) => void;
+    const aui = renderThreadWithProps({
+      onNew: () => {},
+      onCancel: () => {},
+      attachmentAdapter: {
+        accept: "*",
+        add: () =>
+          new Promise<PendingAttachment>((resolve) => {
+            resolveAdd = resolve;
+          }),
+        send: async () => ({}) as never,
+        remove: async () => {},
+      },
+    });
+    const composer = () => aui().thread().composer();
+
+    let addPromise!: Promise<void>;
+    await act(async () => {
+      addPromise = composer().addAttachment(
+        new File(["data"], "notes.txt", { type: "text/plain" }),
+      );
+    });
+    await act(async () => {
+      composer().cancel();
+    });
+    await act(async () => {
+      resolveAdd({
+        id: "draft-1",
+        type: "document",
+        name: "notes.txt",
+        contentType: "text/plain",
+        file: new File(["data"], "notes.txt", { type: "text/plain" }),
+        status: { type: "pending", reason: "uploading", progress: 0 },
+      } as PendingAttachment);
+      await addPromise;
+    });
+
+    expect(composer().getState().attachments).toMatchObject([
+      { id: "draft-1" },
+    ]);
+  });
+});

package/src/tests/single-thread-list-item.test.tsx

@@ -0,0 +1,47 @@
+// @vitest-environment jsdom
+
+import { cleanup, render } from "@testing-library/react";
+import type { FC } from "react";
+import { afterEach, describe, expect, it } from "vitest";
+import { AuiProvider, useAui } from "@assistant-ui/store";
+import { ExternalThread } from "../store/clients/external-thread";
+import { SingleThreadList } from "../store/clients/single-thread-list";
+
+let aui!: ReturnType<typeof useAui>;
+
+const Capture: FC = () => {
+  aui = useAui();
+  return null;
+};
+
+const App: FC = () => {
+  const value = useAui({
+    threads: SingleThreadList({ thread: ExternalThread({ messages: [] }) }),
+  });
+  return (
+    <AuiProvider value={value}>
+      <Capture />
+    </AuiProvider>
+  );
+};
+
+afterEach(() => {
+  cleanup();
+});
+
+describe("SingleThreadList item selectors", () => {
+  it("resolves index selectors within the regular subset only", () => {
+    render(<App />);
+
+    const mainId = aui.threads.item("main").getState().id;
+    expect(aui.threads.item({ index: 0 }).getState().id).toBe(mainId);
+    expect(aui.threads.item({ index: 0, archived: false }).getState().id).toBe(
+      mainId,
+    );
+
+    expect(aui.threads.getState().archivedThreadIds).toEqual([]);
+    expect(() => aui.threads.item({ index: 0, archived: true })).toThrow(
+      "unknown item selector",
+    );
+  });
+});

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

@@ -1,5 +1,9 @@
 import { describe, expect, it } from "vitest";
-import { fromThreadMessageLike } from "../runtime/utils/thread-message-like";
+import {
+  fromThreadMessageLike,
+  type ThreadMessageLike,
+} from "../runtime/utils/thread-message-like";
+import type { ToolCallMessagePartMcpMetadata } from "../types/message";
 
 const fallbackId = "test-id";
 const fallbackStatus = {
@@ -421,3 +425,37 @@ describe("fromThreadMessageLike provider metadata", () => {
     ]);
   });
 });
+
+describe("fromThreadMessageLike MCP app metadata", () => {
+  it("keeps mcp on tool-call parts", () => {
+    const mcp: ToolCallMessagePartMcpMetadata = {
+      app: { resourceUri: "ui://demo/card" },
+    };
+    const message: ThreadMessageLike = {
+      role: "assistant",
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "show_card",
+          args: {},
+          argsText: "{}",
+          mcp,
+        },
+      ],
+    };
+
+    const result = fromThreadMessageLike(message, fallbackId, fallbackStatus);
+
+    expect(result.content).toEqual([
+      {
+        type: "tool-call",
+        toolCallId: "call-1",
+        toolName: "show_card",
+        args: {},
+        argsText: "{}",
+        mcp,
+      },
+    ]);
+  });
+});

package/src/types/message.ts

@@ -168,9 +168,9 @@ export type ToolApprovalOption = {
   readonly id: string;
   /**
    * Decision class. Drives approved-resolution and default rendering.
-   * Open union: `_`-prefixed custom kinds are never auto-resolved and the
-   * default kit skips them; they must be answered with an explicit
-   * `approved` value (optionally alongside the `optionId`).
+   * Open union: `_`-prefixed custom kinds are never auto-resolved; they must
+   * be answered with an explicit `approved` value (optionally alongside the
+   * `optionId`), which is what the default kit sends when one is chosen.
    */
   readonly kind: ToolApprovalOptionKind | (string & {});
   /** Human label. Renderers supply defaults per kind when omitted. */
@@ -306,6 +306,11 @@ export type ToolCallMessagePartStatus =
       /** Reason the tool call requires action. */
       readonly reason: "tool-calls" | "interrupt";
     }
+  | {
+      readonly type: "incomplete";
+      readonly reason: "tool-calls";
+      readonly error?: ReadonlyJSONValue;
+    }
   | MessagePartStatus;
 
 export type MessageStatus =

package/src/utils/data-url.test.ts

@@ -1,5 +1,9 @@
 import { describe, it, expect } from "vitest";
-import { httpUrlPattern, parseDataUrl } from "./data-url";
+import {
+  httpUrlPattern,
+  parseDataUrl,
+  resolveFilePartSource,
+} from "./data-url";
 
 describe("parseDataUrl", () => {
   it("parses a base64 data URL", () => {
@@ -72,3 +76,50 @@ describe("httpUrlPattern", () => {
     },
   );
 });
+
+describe("resolveFilePartSource", () => {
+  it("uses an explicit url source type for opaque values", () => {
+    expect(
+      resolveFilePartSource({
+        data: "provider-file-id",
+        mimeType: "application/pdf",
+        sourceType: "url",
+      }),
+    ).toEqual({ kind: "url", url: "provider-file-id" });
+  });
+
+  it("uses http URLs as url sources", () => {
+    expect(
+      resolveFilePartSource({
+        data: "https://example.com/file.pdf",
+        mimeType: "application/pdf",
+      }),
+    ).toEqual({ kind: "url", url: "https://example.com/file.pdf" });
+  });
+
+  it("decodes data URLs and uses their media type", () => {
+    expect(
+      resolveFilePartSource({
+        data: "data:image/png;base64,aGVsbG8=",
+        mimeType: "application/octet-stream",
+      }),
+    ).toEqual({
+      kind: "data",
+      data: "aGVsbG8=",
+      mimeType: "image/png",
+    });
+  });
+
+  it("passes through opaque data with its declared media type", () => {
+    expect(
+      resolveFilePartSource({
+        data: "provider-file-id",
+        mimeType: "application/pdf",
+      }),
+    ).toEqual({
+      kind: "data",
+      data: "provider-file-id",
+      mimeType: "application/pdf",
+    });
+  });
+});

package/src/utils/data-url.ts

@@ -1,5 +1,9 @@
 export const httpUrlPattern = /^https?:\/\//i;
 
+export type FilePartSource =
+  | { kind: "url"; url: string }
+  | { kind: "data"; data: string; mimeType: string };
+
 export function parseDataUrl(
   value: string,
 ): { mimeType: string; data: string } | null {
@@ -8,6 +12,23 @@ export function parseDataUrl(
   return { mimeType: match[1]!.toLowerCase(), data: match[2]! };
 }
 
+export const resolveFilePartSource = (part: {
+  data: string;
+  mimeType: string;
+  sourceType?: string | undefined;
+}): FilePartSource => {
+  if (part.sourceType === "url" || httpUrlPattern.test(part.data)) {
+    return { kind: "url", url: part.data };
+  }
+
+  const parsed = parseDataUrl(part.data);
+  return {
+    kind: "data",
+    data: parsed?.data ?? part.data,
+    mimeType: parsed?.mimeType ?? part.mimeType,
+  };
+};
+
 /**
  * Whether a payload is something `new URL()` accepts. Adapters that place a
  * `FileMessagePart` payload into a url-typed wire field use this to decide

package/src/utils/invoke-user-callback.test.ts

@@ -0,0 +1,82 @@
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { invokeUserCallback } from "./invoke-user-callback";
+
+describe("invokeUserCallback", () => {
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  it("invokes a callback synchronously with its arguments", () => {
+    const callback = vi.fn((left: number, right: number) => left + right);
+
+    expect(invokeUserCallback("test", "onSuccess", callback, 2, 3)).toBe(
+      undefined,
+    );
+    expect(callback).toHaveBeenCalledOnce();
+    expect(callback).toHaveBeenCalledWith(2, 3);
+  });
+
+  it("reports and swallows a synchronous throw", () => {
+    const error = new Error("sync failure");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    expect(() =>
+      invokeUserCallback("test", "onError", () => {
+        throw error;
+      }),
+    ).not.toThrow();
+    expect(consoleError).toHaveBeenCalledOnce();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[test] onError callback threw an error",
+      error,
+    );
+  });
+
+  it("reports an asynchronous rejection and resolves", async () => {
+    const error = new Error("async failure");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    await expect(
+      invokeUserCallback("test", "onError", async () => {
+        throw error;
+      }),
+    ).resolves.toBeUndefined();
+    expect(consoleError).toHaveBeenCalledOnce();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[test] onError callback threw an error",
+      error,
+    );
+  });
+
+  it("resolves only after an asynchronous callback settles", async () => {
+    let settleCallback: (() => void) | undefined;
+    const callbackPromise = new Promise<void>((resolve) => {
+      settleCallback = resolve;
+    });
+    let settled = false;
+
+    const result = invokeUserCallback(
+      "test",
+      "onFinish",
+      () => callbackPromise,
+    );
+    void result?.then(() => {
+      settled = true;
+    });
+
+    await Promise.resolve();
+    expect(settled).toBe(false);
+
+    settleCallback?.();
+    await result;
+    expect(settled).toBe(true);
+  });
+
+  it("does nothing when the callback is undefined", () => {
+    expect(invokeUserCallback("test", "onMissing", undefined)).toBeUndefined();
+  });
+});

package/src/utils/invoke-user-callback.ts

@@ -0,0 +1,31 @@
+export function invokeUserCallback<TArgs extends readonly unknown[]>(
+  tag: string,
+  name: string,
+  callback: ((...args: TArgs) => unknown) | undefined,
+  ...args: TArgs
+): void | Promise<void> {
+  if (!callback) return;
+
+  const reportError = (error: unknown) => {
+    try {
+      console.error(`[${tag}] ${name} callback threw an error`, error);
+    } catch {}
+  };
+
+  try {
+    const result = callback(...args);
+    if (
+      result !== null &&
+      (typeof result === "object" || typeof result === "function") &&
+      "then" in result &&
+      typeof result.then === "function"
+    ) {
+      return Promise.resolve(result).then(
+        () => undefined,
+        (error) => reportError(error),
+      );
+    }
+  } catch (error) {
+    reportError(error);
+  }
+}

package/src/utils/normalizePartStatus.ts

@@ -65,7 +65,7 @@ export const toMessagePartStatus = (
 
   if (part.type === "tool-call") {
     if (part.result === undefined) {
-      return message.status as ToolCallMessagePartStatus;
+      return message.status;
     } else {
       return COMPLETE_STATUS;
     }

package/dist/store/scopes/queue-item.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"queue-item.js","names":["FileMessagePart","TextMessagePart","QueuePlacement","QueueItemState","id","prompt","parts","EMPTY_QUEUE_ITEMS","Object","freeze","QueueItemMethods","getState","steer","move","placement","remove","QueueItemMeta","source","query","type","index","QueueItemClientSchema","methods","meta"],"sources":["../../../src/store/scopes/queue-item.ts"],"sourcesContent":["import type { FileMessagePart, TextMessagePart } from \"../../types/message\";\nimport type { QueuePlacement } from \"../../runtime/queue/external-thread-queue-adapter\";\n\nexport type QueueItemState = {\n  readonly id: string;\n  /** @deprecated Derive from the text parts of `parts` instead. Removal after 2026-11-05. */\n  readonly prompt: string;\n  readonly parts: readonly (FileMessagePart | TextMessagePart)[];\n};\n\nexport const EMPTY_QUEUE_ITEMS: readonly QueueItemState[] = Object.freeze([]);\n\nexport type QueueItemMethods = {\n  getState(): QueueItemState;\n  /** @deprecated Use `move({ lane: \"steer\", insertAfter: null })` instead. Removal after 2026-11-05. */\n  steer(): void;\n  move(placement: QueuePlacement): void;\n  remove(): void;\n};\n\nexport type QueueItemMeta = {\n  source: \"composer\";\n  query: { type: \"index\"; index: number } | { type: \"id\"; id: string };\n};\n\nexport type QueueItemClientSchema = {\n  methods: QueueItemMethods;\n  meta: QueueItemMeta;\n};\n"],"mappings":";AAUA,MAAaO,oBAA+CC,OAAOC,OAAO,CAAA,CAAE"}