@assistant-ui/core 0.2.21 → 0.2.23

package/src/tests/RemoteThreadListThreadListRuntimeCore-switchToThread-order.test.ts

@@ -0,0 +1,223 @@
+import { describe, expect, it, vi } from "vitest";
+import type { RemoteThreadMetadata } from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+  setStartThreadRuntime,
+} from "./remote-thread-list-test-helpers";
+
+const thread = (id: string): RemoteThreadMetadata => ({
+  status: "regular",
+  remoteId: id,
+  externalId: id,
+  title: id,
+});
+
+describe("RemoteThreadListThreadListRuntimeCore.switchToThread order", () => {
+  it("preserves the latest switch when an earlier fetch resolves last", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const fetchC = deferred<RemoteThreadMetadata>();
+    const adapter = makeAdapter({
+      fetch: vi.fn((id: string) =>
+        id === "thread-b" ? fetchB.promise : fetchC.promise,
+      ),
+    });
+    const core = createCore(adapter);
+
+    const switchToB = core.switchToThread("thread-b");
+    const switchToC = core.switchToThread("thread-c");
+
+    fetchC.resolve(thread("thread-c"));
+    await switchToC;
+    fetchB.resolve(thread("thread-b"));
+    await switchToB;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-c")?.id);
+  });
+
+  it("preserves the latest switch when an earlier runtime starts last", async () => {
+    const runtimeB = deferred<unknown>();
+    const runtimeC = deferred<unknown>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [thread("thread-b"), thread("thread-c")],
+      })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    setStartThreadRuntime(core, (id) =>
+      id === core.getItemById("thread-b")?.id
+        ? runtimeB.promise
+        : runtimeC.promise,
+    );
+
+    const switchToB = core.switchToThread("thread-b");
+    const switchToC = core.switchToThread("thread-c");
+
+    runtimeC.resolve({});
+    await switchToC;
+    runtimeB.resolve({});
+    await switchToB;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-c")?.id);
+  });
+
+  it("invalidates an earlier switch while a new thread request is pending", async () => {
+    const initializeThread = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const runtimeB = deferred<unknown>();
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initializeThread.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-b")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const initialNewThreadId = core.newThreadId;
+    if (!initialNewThreadId) throw new Error("Expected an initial new thread");
+
+    const threadBId = core.getItemById("thread-b")?.id;
+    setStartThreadRuntime(core, (id) =>
+      id === threadBId ? runtimeB.promise : Promise.resolve({}),
+    );
+
+    const initialize = core.initialize(initialNewThreadId);
+    const switchToB = core.switchToThread("thread-b");
+    const switchToNewThread = core.switchToNewThread();
+
+    runtimeB.resolve({});
+    await switchToB;
+
+    expect(core.mainThreadId).not.toBe(threadBId);
+
+    initializeThread.resolve({
+      remoteId: "initialized-thread",
+      externalId: "initialized-thread",
+    });
+    await initialize;
+    await switchToNewThread;
+
+    expect(core.mainThreadId).toBe(core.getItemById(core.newThreadId!)?.id);
+  });
+
+  it("does not let a pending new thread request override a later switch", async () => {
+    const initializeThread = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const adapter = makeAdapter({
+      initialize: vi.fn(() => initializeThread.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-c")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const initialNewThreadId = core.newThreadId;
+    if (!initialNewThreadId) throw new Error("Expected an initial new thread");
+
+    const initialize = core.initialize(initialNewThreadId);
+    const switchToNewThread = core.switchToNewThread();
+    await core.switchToThread("thread-c");
+
+    initializeThread.resolve({
+      remoteId: "initialized-thread",
+      externalId: "initialized-thread",
+    });
+    await initialize;
+    await switchToNewThread;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-c")?.id);
+  });
+
+  it("keeps mutations waiting when a newer switch fails", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const newThreadRuntime = deferred<unknown>();
+    const adapter = makeAdapter({
+      fetch: vi.fn(() => fetchB.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-a")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const threadAId = core.getItemById("thread-a")?.id;
+    const newThreadId = core.newThreadId;
+    if (!newThreadId) throw new Error("Expected an initial new thread");
+
+    setStartThreadRuntime(core, (id) =>
+      id === core.getItemById(newThreadId)?.id
+        ? newThreadRuntime.promise
+        : Promise.resolve({}),
+    );
+
+    const deleteA = core.delete("thread-a");
+    const switchToB = core.switchToThread("thread-b");
+    const switchToBResult = expect(switchToB).rejects.toThrow("fetch failed");
+
+    newThreadRuntime.resolve({});
+    fetchB.reject(new Error("fetch failed"));
+
+    await switchToBResult;
+    await deleteA;
+
+    expect(core.mainThreadId).not.toBe(threadAId);
+    expect(core.mainThreadId).toBe(core.getItemById(core.newThreadId!)?.id);
+  });
+
+  it("lets a newer successful switch move the mutation target away", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const newThreadRuntime = deferred<unknown>();
+    const adapter = makeAdapter({
+      fetch: vi.fn(() => fetchB.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-a")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const newThreadId = core.newThreadId;
+    if (!newThreadId) throw new Error("Expected an initial new thread");
+
+    setStartThreadRuntime(core, (id) =>
+      id === core.getItemById(newThreadId)?.id
+        ? newThreadRuntime.promise
+        : Promise.resolve({}),
+    );
+
+    const deleteA = core.delete("thread-a");
+    const switchToB = core.switchToThread("thread-b");
+
+    newThreadRuntime.resolve({});
+    fetchB.resolve(thread("thread-b"));
+
+    await switchToB;
+    await deleteA;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-b")?.id);
+  });
+
+  it("does not let a mutation cancel an existing pending switch", async () => {
+    const fetchB = deferred<RemoteThreadMetadata>();
+    const adapter = makeAdapter({
+      fetch: vi.fn(() => fetchB.promise),
+      list: vi.fn(async () => ({ threads: [thread("thread-a")] })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const switchToB = core.switchToThread("thread-b");
+    const deleteA = core.delete("thread-a");
+
+    fetchB.resolve(thread("thread-b"));
+
+    await switchToB;
+    await deleteA;
+
+    expect(core.mainThreadId).toBe(core.getItemById("thread-b")?.id);
+  });
+});

package/src/tests/RemoteThreadListThreadListRuntimeCore-switchToThread-position.test.ts

@@ -0,0 +1,121 @@
+import { describe, it, expect, vi } from "vitest";
+import type {
+  RemoteThreadListResponse,
+  RemoteThreadMetadata,
+} from "../runtimes/remote-thread-list/types";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+const thread = (id: string): RemoteThreadMetadata => ({
+  status: "regular",
+  remoteId: id,
+  externalId: id,
+  title: id,
+});
+
+const archivedThread = (id: string): RemoteThreadMetadata => ({
+  status: "archived",
+  remoteId: id,
+  externalId: id,
+  title: id,
+});
+
+describe("RemoteThreadListThreadListRuntimeCore.switchToThread position", () => {
+  it("keeps the position a concurrent list() already gave the thread", async () => {
+    const TARGET = "thread-target";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, TARGET);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(TARGET);
+
+    // `list()` resolves first and places TARGET at the top, as the most recent.
+    listDeferred.resolve({
+      threads: [thread(TARGET), thread("thread-a"), thread("thread-b")],
+    });
+    await loadPromise;
+
+    expect(core.threadIds).toEqual([TARGET, "thread-a", "thread-b"]);
+
+    fetchDeferred.resolve(thread(TARGET));
+    await switchPromise;
+
+    // The fetch path must not filter TARGET out of position and re-append it.
+    expect(core.threadIds).toEqual([TARGET, "thread-a", "thread-b"]);
+  });
+
+  it("appends a thread that is genuinely absent from the loaded list", async () => {
+    const TARGET = "thread-target";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, TARGET);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(TARGET);
+
+    // `list()` resolves first but does not include TARGET (e.g. it is past the
+    // first page).
+    listDeferred.resolve({
+      threads: [thread("thread-a"), thread("thread-b")],
+    });
+    await loadPromise;
+
+    expect(core.threadIds).toEqual(["thread-a", "thread-b"]);
+
+    fetchDeferred.resolve(thread(TARGET));
+    await switchPromise;
+
+    // An absent thread may live on an unloaded page; appending keeps it below
+    // every loaded (newer) thread instead of pinning it to the top.
+    expect(core.threadIds).toEqual(["thread-a", "thread-b", TARGET]);
+  });
+
+  it("keeps the position a concurrent list() gave an archived thread", async () => {
+    const TARGET = "thread-target";
+    const listDeferred = deferred<RemoteThreadListResponse>();
+    const fetchDeferred = deferred<RemoteThreadMetadata>();
+
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      fetch: vi.fn(() => fetchDeferred.promise),
+    });
+
+    const core = createCore(adapter, TARGET);
+    // Stub unarchive so auto-unarchive doesn't move the thread into `threadIds`
+    // via `updateStatusReducer`, hiding the position written by the fetch path.
+    (
+      core as unknown as { unarchive: (id: string) => Promise<void> }
+    ).unarchive = async () => {};
+
+    const loadPromise = core.getLoadThreadsPromise();
+    const switchPromise = core.switchToThread(TARGET);
+
+    listDeferred.resolve({
+      threads: [archivedThread(TARGET), archivedThread("thread-a")],
+    });
+    await loadPromise;
+
+    expect(core.archivedThreadIds).toEqual([TARGET, "thread-a"]);
+
+    fetchDeferred.resolve(archivedThread(TARGET));
+    await switchPromise;
+
+    expect(core.archivedThreadIds).toEqual([TARGET, "thread-a"]);
+  });
+});

package/src/tests/auiV0Encode.test.ts

@@ -53,6 +53,35 @@ describe("auiV0Encode", () => {
     ]);
   });
 
+  it("preserves a pending tool-call approval in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "requires-action", reason: "tool-calls" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "send_email",
+          args: {},
+          argsText: "{}",
+          approval: { id: "a1" },
+        },
+      ],
+    });
+
+    const toolCall = encoded.content.find((p) => p.type === "tool-call");
+    expect(toolCall).toMatchObject({ approval: { id: "a1" } });
+  });
+
   it("preserves user attachments in the core cloud encoder", () => {
     const encoded = auiV0Encode({
       id: "m1",
@@ -129,6 +158,51 @@ describe("auiV0Encode", () => {
 });
 
 describe("auiV0Decode", () => {
+  it("round-trips a pending tool-call approval so a paused run stays resumable", () => {
+    const content = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "requires-action", reason: "tool-calls" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        {
+          type: "tool-call",
+          toolCallId: "call-1",
+          toolName: "send_email",
+          args: {},
+          argsText: "{}",
+          approval: { id: "a1" },
+        },
+      ],
+    });
+
+    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,
+    });
+
+    if (decoded.message.role !== "assistant")
+      throw new Error("expected assistant");
+    const toolCall = decoded.message.content.find(
+      (p) => p.type === "tool-call",
+    );
+    expect(toolCall?.type === "tool-call" && toolCall.approval).toEqual({
+      id: "a1",
+    });
+  });
+
   it("restores user attachments from core cloud history", () => {
     const content = auiV0Encode({
       id: "local",

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

@@ -128,6 +128,50 @@ 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());