@assistant-ui/core 0.3.16 → 0.3.18

package/src/tests/remote-thread-list-adapter-switch.test.ts

@@ -51,6 +51,27 @@ describe("RemoteThreadList adapter changes", () => {
     expect(adapterB.rename).not.toHaveBeenCalled();
   });
 
+  it("clears loading when the replaced adapter's list never settles", async () => {
+    const adapterA = makeAdapter({
+      list: vi.fn(() => new Promise<never>(() => {})),
+    });
+    const adapterB = makeAdapter({
+      list: vi.fn(async () => ({ threads: [thread("thread-b")] })),
+    });
+    const core = createCore(adapterA);
+
+    void core.getLoadThreadsPromise();
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.threadIds).toEqual(["thread-b"]);
+    expect(core.isLoading).toBe(false);
+  });
+
   it("does not resume an old adapter mutation through the new adapter", async () => {
     const adapterA = makeAdapter({
       list: async () => ({ threads: [thread("thread-a")] }),
@@ -378,6 +399,50 @@ describe("RemoteThreadList adapter changes", () => {
 
     expect(core.getItemById(draftId!)?.remoteId).toBe("created-on-b");
     expect(core.mainThreadId).toBe(draftId);
-    expect(core.threadIds).toContain("created-on-b");
+    expect(core.threadIds).toContain(draftId);
+    expect(core.getItemById("created-on-b")?.id).toBe(draftId);
+  });
+
+  it("keeps one slot when the replacement list already carries the initialized thread", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const listB = deferred<{ threads: ReturnType<typeof thread>[] }>();
+    const adapterB = makeAdapter({
+      list: vi.fn(() => listB.promise),
+      initialize: vi.fn(async () => ({
+        remoteId: "created-on-b",
+        externalId: "created-on-b",
+      })),
+    });
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const draftId = core.newThreadId;
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.initialize(draftId!);
+
+    listB.resolve({
+      threads: [thread("created-on-b"), thread("thread-b")],
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(
+      Object.values(core.threadItems).filter(
+        (item) => item.remoteId === "created-on-b",
+      ),
+    ).toHaveLength(1);
+    expect(core.threadIds).toEqual([draftId, "thread-b"]);
+    expect(core.getItemById("created-on-b")?.id).toBe(draftId);
+
+    await core.delete("created-on-b");
+
+    expect(core.getItemById("created-on-b")).toBeUndefined();
+    expect(core.getItemById(draftId!)).toBeUndefined();
+    expect(core.threadIds).toEqual(["thread-b"]);
   });
 });

package/src/tests/remote-thread-list-isLoading.test.ts

@@ -26,6 +26,7 @@ type ListResult = {
 
 const INITIAL_STATE: RemoteThreadState = {
   isLoading: true,
+  loadError: undefined,
   isLoadingMore: false,
   cursor: undefined,
   newThreadId: undefined,

package/src/tests/thread-list-runtime-getLoadThreadsPromise.test.ts

@@ -9,6 +9,7 @@ const createMockCore = (
   loadPromise: Promise<void> = Promise.resolve(),
 ): ThreadListRuntimeCore => ({
   isLoading: false,
+  loadError: undefined,
   mainThreadId: MAIN_THREAD_ID,
   newThreadId: undefined,
   threadIds: [MAIN_THREAD_ID],

package/src/tests/thread-switch-events.test.tsx

@@ -5,10 +5,14 @@ import { describe, expect, it, vi } from "vitest";
 import { AuiProvider, useAui, useAuiEvent } from "@assistant-ui/store";
 import { AssistantRuntimeProvider } from "../react/AssistantRuntimeProvider";
 import { useExternalStoreRuntime } from "../react/runtimes/useExternalStoreRuntime";
+import { useLocalRuntime } from "../react/runtimes/useLocalRuntime";
 import { useRemoteThreadListRuntime } from "../react/runtimes/useRemoteThreadListRuntime";
-import { makeAdapter } from "./remote-thread-list-test-helpers";
+import { deferred, makeAdapter } from "./remote-thread-list-test-helpers";
 import { RuntimeAdapter } from "../react/RuntimeAdapter";
-import { AssistantRuntimeImpl } from "../runtime/api/assistant-runtime";
+import {
+  AssistantRuntimeImpl,
+  type AssistantRuntime,
+} from "../runtime/api/assistant-runtime";
 import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
 
@@ -232,3 +236,472 @@ describe("thread switch events", () => {
     expect(payload.previousThreadId).toMatch(/^__LOCALID_/);
   });
 });
+
+const createExternalStoreRuntime = (
+  runningByThreadId: Map<string, boolean>,
+) => {
+  const threads = [
+    { id: "t1", title: "one" },
+    { id: "t2", title: "two" },
+  ];
+  let currentId = "t1";
+  const makeStoreAdapter = (): ExternalStoreAdapter<DemoMessage> => ({
+    messages: EMPTY_MESSAGES,
+    isRunning: runningByThreadId.get(currentId) ?? false,
+    convertMessage: (m) => ({
+      id: m.id,
+      role: m.role,
+      content: [{ type: "text", text: m.text }],
+    }),
+    onNew: async () => {},
+    adapters: {
+      threadList: {
+        threadId: currentId,
+        threads: threads.map((t) => ({
+          status: "regular" as const,
+          id: t.id,
+          title: t.title,
+        })),
+        onSwitchToThread: (threadId: string) => {
+          currentId = threadId;
+          sync();
+        },
+        onSwitchToNewThread: () => {},
+      },
+    },
+  });
+  const core = new ExternalStoreRuntimeCore(makeStoreAdapter());
+  const runtime = new AssistantRuntimeImpl(core);
+  const sync = () => core.setAdapter(makeStoreAdapter());
+  return { runtime, sync };
+};
+
+const listAdapter = () =>
+  makeAdapter({
+    list: vi.fn(async () => ({
+      threads: [
+        { status: "regular" as const, remoteId: "thread-a", title: "A" },
+        { status: "regular" as const, remoteId: "thread-b", title: "B" },
+      ],
+    })),
+  });
+
+const renderRemoteList = (
+  adapter: ReturnType<typeof makeAdapter>,
+  run: () => Promise<{ content: [] }>,
+) => {
+  const globalRunStart = vi.fn();
+  const globalRunEnd = vi.fn();
+  const globalInitialize = vi.fn();
+  const globalModelContextUpdate = vi.fn();
+  const selectedRunStart = vi.fn();
+  const selectedRunEnd = vi.fn();
+  const selectedInitialize = vi.fn();
+  const selectedModelContextUpdate = vi.fn();
+  let runtime!: AssistantRuntime;
+
+  const Listener = () => {
+    useAuiEvent({ scope: "*", event: "thread.runStart" }, globalRunStart);
+    useAuiEvent({ scope: "*", event: "thread.runEnd" }, globalRunEnd);
+    useAuiEvent({ scope: "*", event: "thread.initialize" }, globalInitialize);
+    useAuiEvent(
+      { scope: "*", event: "thread.modelContextUpdate" },
+      globalModelContextUpdate,
+    );
+    useAuiEvent("thread.runStart", selectedRunStart);
+    useAuiEvent("thread.runEnd", selectedRunEnd);
+    useAuiEvent("thread.initialize", selectedInitialize);
+    useAuiEvent("thread.modelContextUpdate", selectedModelContextUpdate);
+    return null;
+  };
+  const Harness = () => {
+    runtime = useRemoteThreadListRuntime({
+      adapter,
+      initialThreadId: "thread-a",
+      runtimeHook: function RuntimeHook() {
+        return useLocalRuntime({ run });
+      },
+    });
+    return (
+      <AssistantRuntimeProvider runtime={runtime}>
+        <Listener />
+      </AssistantRuntimeProvider>
+    );
+  };
+  render(<Harness />);
+
+  return {
+    getRuntime: () => runtime,
+    globalRunStart,
+    globalRunEnd,
+    globalInitialize,
+    globalModelContextUpdate,
+    selectedRunStart,
+    selectedRunEnd,
+    selectedInitialize,
+    selectedModelContextUpdate,
+  };
+};
+
+const switchTo = async (runtime: AssistantRuntime, remoteId: string) => {
+  await act(async () => {
+    await runtime.threads.switchToThread(remoteId);
+  });
+  await waitFor(() => {
+    expect(runtime.threads.mainItem.getState().remoteId).toBe(remoteId);
+  });
+};
+
+describe("ThreadListRuntime.getById", () => {
+  it("keeps background messages and metadata bound to the requested thread", async () => {
+    const harness = renderRemoteList(listAdapter(), async () => ({
+      content: [],
+    }));
+    const runtime = harness.getRuntime();
+    await waitFor(() => {
+      expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+    });
+    await act(async () => {
+      runtime.thread.reset([
+        {
+          id: "message-a",
+          role: "user",
+          content: [{ type: "text", text: "A" }],
+        },
+      ]);
+    });
+    await switchTo(runtime, "thread-b");
+    await act(async () => {
+      runtime.thread.reset([
+        {
+          id: "message-b",
+          role: "user",
+          content: [{ type: "text", text: "B" }],
+        },
+      ]);
+    });
+    const threadBId = runtime.threads.mainItem.getState().id;
+    await switchTo(runtime, "thread-a");
+
+    const threadB = runtime.threads.getById(threadBId);
+    expect(threadB.getState()).toMatchObject({
+      threadId: threadBId,
+      messages: [{ id: "message-b" }],
+      metadata: {
+        id: threadBId,
+        remoteId: "thread-b",
+        title: "B",
+        isMain: false,
+      },
+    });
+    expect(runtime.thread.getState()).toMatchObject({
+      messages: [{ id: "message-a" }],
+      metadata: { remoteId: "thread-a", isMain: true },
+    });
+
+    let observed = threadB.getState();
+    const unsubscribe = threadB.subscribe(() => {
+      observed = threadB.getState();
+    });
+    try {
+      await act(async () => {
+        await runtime.threads.getItemById(threadBId).rename("Renamed B");
+      });
+      expect(observed).toMatchObject({
+        threadId: threadBId,
+        messages: [{ id: "message-b" }],
+        metadata: { title: "Renamed B", isMain: false },
+      });
+
+      await switchTo(runtime, "thread-b");
+      expect(observed.metadata).toMatchObject({
+        title: "Renamed B",
+        isMain: true,
+      });
+      await switchTo(runtime, "thread-a");
+      expect(observed).toMatchObject({
+        threadId: threadBId,
+        messages: [{ id: "message-b" }],
+        metadata: { title: "Renamed B", isMain: false },
+      });
+    } finally {
+      unsubscribe();
+    }
+  });
+});
+
+describe("background thread run events", () => {
+  it("delivers runEnd globally after the running thread is switched away", async () => {
+    const runA = deferred<{ content: [] }>();
+    const harness = renderRemoteList(listAdapter(), () => runA.promise);
+    const runtime = harness.getRuntime();
+
+    await waitFor(() => {
+      expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+    });
+    const threadAId = runtime.threads.mainItem.getState().id;
+
+    await act(async () => {
+      runtime.thread.startRun({ parentId: null });
+    });
+    await waitFor(() => expect(runtime.thread.getState().isRunning).toBe(true));
+    await waitFor(() => {
+      expect(harness.globalRunStart).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadAId,
+      });
+      expect(harness.selectedRunStart).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadAId,
+      });
+    });
+
+    await switchTo(runtime, "thread-b");
+    await act(async () => {
+      runA.resolve({ content: [] });
+    });
+
+    await waitFor(() => {
+      expect(harness.globalRunEnd).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadAId,
+      });
+    });
+    expect(harness.selectedRunEnd).not.toHaveBeenCalled();
+  });
+
+  it("does not duplicate run events while the running thread is switched back and forth", async () => {
+    const runA = deferred<{ content: [] }>();
+    const harness = renderRemoteList(listAdapter(), () => runA.promise);
+    const runtime = harness.getRuntime();
+
+    await waitFor(() => {
+      expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+    });
+    const threadAId = runtime.threads.mainItem.getState().id;
+
+    await act(async () => {
+      runtime.thread.startRun({ parentId: null });
+    });
+    await waitFor(() => expect(runtime.thread.getState().isRunning).toBe(true));
+
+    await switchTo(runtime, "thread-b");
+    await switchTo(runtime, "thread-a");
+    await switchTo(runtime, "thread-b");
+    await switchTo(runtime, "thread-a");
+    await switchTo(runtime, "thread-b");
+
+    await act(async () => {
+      runA.resolve({ content: [] });
+    });
+
+    await waitFor(() => {
+      expect(harness.globalRunEnd).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadAId,
+      });
+    });
+    expect(harness.globalRunStart).toHaveBeenCalledExactlyOnceWith({
+      threadId: threadAId,
+    });
+    expect(harness.selectedRunStart).toHaveBeenCalledExactlyOnceWith({
+      threadId: threadAId,
+    });
+    expect(harness.selectedRunEnd).not.toHaveBeenCalled();
+  });
+
+  it("leaves the run to the selected client when its thread is re-selected", async () => {
+    const runA = deferred<{ content: [] }>();
+    const harness = renderRemoteList(listAdapter(), () => runA.promise);
+    const runtime = harness.getRuntime();
+
+    await waitFor(() => {
+      expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+    });
+    const threadAId = runtime.threads.mainItem.getState().id;
+
+    await act(async () => {
+      runtime.thread.startRun({ parentId: null });
+    });
+    await waitFor(() => expect(runtime.thread.getState().isRunning).toBe(true));
+
+    await switchTo(runtime, "thread-b");
+    await switchTo(runtime, "thread-a");
+
+    await act(async () => {
+      runA.resolve({ content: [] });
+    });
+
+    await waitFor(() => {
+      expect(harness.selectedRunEnd).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadAId,
+      });
+    });
+    expect(harness.globalRunEnd).toHaveBeenCalledExactlyOnceWith({
+      threadId: threadAId,
+    });
+    expect(harness.globalRunStart).toHaveBeenCalledExactlyOnceWith({
+      threadId: threadAId,
+    });
+    expect(harness.selectedRunStart).toHaveBeenCalledExactlyOnceWith({
+      threadId: threadAId,
+    });
+  });
+
+  it("reports the start and end of a run that is never selected", async () => {
+    const backgroundRun = deferred<{ content: [] }>();
+    const harness = renderRemoteList(
+      listAdapter(),
+      () => backgroundRun.promise,
+    );
+    const runtime = harness.getRuntime();
+
+    await waitFor(() => {
+      expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+    });
+    await switchTo(runtime, "thread-b");
+    const threadBId = runtime.threads.mainItem.getState().id;
+    const threadB = runtime.threads.getById(threadBId);
+    await switchTo(runtime, "thread-a");
+
+    await act(async () => {
+      threadB.startRun({ parentId: null });
+    });
+    await waitFor(() => {
+      expect(harness.globalRunStart).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadBId,
+      });
+    });
+
+    await act(async () => {
+      backgroundRun.resolve({ content: [] });
+    });
+    await waitFor(() => {
+      expect(harness.globalRunEnd).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadBId,
+      });
+    });
+    expect(harness.selectedRunStart).not.toHaveBeenCalled();
+    expect(harness.selectedRunEnd).not.toHaveBeenCalled();
+  });
+
+  it("reports lifecycle events from a thread that is never selected", async () => {
+    const backgroundRun = deferred<{ content: [] }>();
+    const harness = renderRemoteList(
+      listAdapter(),
+      () => backgroundRun.promise,
+    );
+    const runtime = harness.getRuntime();
+
+    await waitFor(() => {
+      expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+    });
+    await switchTo(runtime, "thread-b");
+    const threadBId = runtime.threads.mainItem.getState().id;
+    const threadB = runtime.threads.getById(threadBId);
+    await switchTo(runtime, "thread-a");
+
+    let updateModelContext!: () => void;
+    const unregisterModelContext = runtime.registerModelContextProvider({
+      getModelContext: () => ({}),
+      subscribe: (callback) => {
+        updateModelContext = callback;
+        return () => {};
+      },
+    });
+    vi.clearAllMocks();
+
+    await act(async () => {
+      threadB.startRun({ parentId: null });
+    });
+    await waitFor(() => {
+      expect(harness.globalInitialize).toHaveBeenCalledExactlyOnceWith({
+        threadId: threadBId,
+      });
+    });
+
+    await act(async () => {
+      updateModelContext();
+    });
+    await waitFor(() => {
+      expect(harness.globalModelContextUpdate).toHaveBeenCalledWith({
+        threadId: threadBId,
+      });
+    });
+
+    expect(harness.selectedInitialize).not.toHaveBeenCalled();
+    unregisterModelContext();
+
+    await act(async () => {
+      backgroundRun.resolve({ content: [] });
+    });
+  });
+
+  it.each([
+    { operation: "delete", state: "deleted" },
+    { operation: "detach", state: "detached" },
+  ] as const)(
+    "stops reporting a background run once its thread is $state",
+    async ({ operation }) => {
+      const runA = deferred<{ content: [] }>();
+      const runSettled = vi.fn();
+      const harness = renderRemoteList(listAdapter(), async () => {
+        const result = await runA.promise;
+        runSettled();
+        return result;
+      });
+      const runtime = harness.getRuntime();
+
+      await waitFor(() => {
+        expect(runtime.threads.mainItem.getState().remoteId).toBe("thread-a");
+      });
+      const threadAId = runtime.threads.mainItem.getState().id;
+
+      await act(async () => {
+        runtime.thread.startRun({ parentId: null });
+      });
+      await waitFor(() =>
+        expect(runtime.thread.getState().isRunning).toBe(true),
+      );
+      await switchTo(runtime, "thread-b");
+
+      await act(async () => {
+        const item = runtime.threads.getItemById(threadAId);
+        if (operation === "delete") await item.delete();
+        else item.detach();
+      });
+      await act(async () => {
+        runA.resolve({ content: [] });
+      });
+
+      await waitFor(() => expect(runSettled).toHaveBeenCalledExactlyOnceWith());
+      expect(harness.globalRunEnd).not.toHaveBeenCalled();
+    },
+  );
+
+  it("emits nothing for a thread list that keeps only the main runtime", async () => {
+    const runningByThreadId = new Map<string, boolean>();
+    const { runtime, sync } = createExternalStoreRuntime(runningByThreadId);
+    const globalRunEnd = vi.fn();
+    const Listener = () => {
+      useAuiEvent({ scope: "*", event: "thread.runEnd" }, globalRunEnd);
+      return null;
+    };
+    const Harness = () => {
+      const aui = useAui({ threads: RuntimeAdapter(runtime) } as never);
+      return (
+        <AuiProvider value={aui}>
+          <Listener />
+        </AuiProvider>
+      );
+    };
+    render(<Harness />);
+    await act(async () => {});
+
+    runningByThreadId.set("t1", true);
+    await act(async () => sync());
+    await waitFor(() => expect(runtime.thread.getState().isRunning).toBe(true));
+
+    await act(async () => {
+      await runtime.threads.switchToThread("t2");
+    });
+    expect(runtime.threads.getState().mainThreadId).toBe("t2");
+    expect(globalRunEnd).not.toHaveBeenCalled();
+  });
+});

package/src/tests/tools-scope-migration.test.tsx

@@ -23,6 +23,34 @@ afterEach(() => {
 });
 
 describe("Tools model-context registration", () => {
+  it("registers and removes a tool UI named __proto__", async () => {
+    let aui!: AnyClient;
+    const Harness = () => {
+      aui = useAui({ tools: Tools({}) } as never);
+      return null;
+    };
+    render(<Harness />);
+
+    let remove!: () => void;
+    await act(async () => {
+      remove = aui.tools().setToolUI("__proto__", () => null);
+      await vi.waitFor(() => {
+        const toolUIs = aui.tools().getState().toolUIs;
+        expect(Object.hasOwn(toolUIs, "__proto__")).toBe(true);
+        expect(toolUIs.__proto__).toHaveLength(1);
+      });
+    });
+
+    await act(async () => {
+      remove();
+      await vi.waitFor(() =>
+        expect(Object.hasOwn(aui.tools().getState().toolUIs, "__proto__")).toBe(
+          false,
+        ),
+      );
+    });
+  });
+
   it("migrates to a structurally replaced modelContext scope", async () => {
     let aui!: AnyClient;
     const Harness = ({ generation }: { generation: number }) => {

package/src/types/attachment.ts

@@ -57,3 +57,7 @@ export const isCreateAttachment = (
   attachment: File | CreateAttachment,
 ): attachment is CreateAttachment =>
   "content" in attachment && !("lastModified" in attachment);
+
+export const isAttachmentComplete = (
+  attachment: Attachment,
+): attachment is CompleteAttachment => attachment.status.type === "complete";