@assistant-ui/core 0.3.13 → 0.3.15

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

@@ -0,0 +1,383 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+  setStartThreadRuntime,
+} from "./remote-thread-list-test-helpers";
+
+const thread = (remoteId: string) => ({
+  remoteId,
+  externalId: remoteId,
+  status: "regular" as const,
+  title: remoteId,
+});
+
+describe("RemoteThreadList adapter changes", () => {
+  it("clears the selected thread and cached data from the previous adapter", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const listAdapterB = vi.fn(async () => ({
+      threads: [thread("thread-b")],
+    }));
+    const adapterB = makeAdapter({ list: listAdapterB });
+    const core = createCore(adapterA);
+    const started: string[] = [];
+    setStartThreadRuntime(core, async (id) => {
+      started.push(id);
+      return {};
+    });
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+    expect(core.getItemById(core.mainThreadId)?.remoteId).toBe("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+
+    await core.getLoadThreadsPromise();
+    expect(listAdapterB).toHaveBeenCalledTimes(1);
+    expect(core.threadIds).toEqual(["thread-b"]);
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById(core.mainThreadId)?.remoteId).not.toBe("thread-a");
+    expect(started).toContain(core.mainThreadId);
+
+    await expect(core.rename("thread-a", "leaked")).rejects.toThrow(
+      'Thread "thread-a" not found',
+    );
+    expect(adapterB.rename).not.toHaveBeenCalled();
+  });
+
+  it("does not resume an old adapter mutation through the new adapter", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    const runtimeStart = deferred<unknown>();
+    setStartThreadRuntime(core, () => runtimeStart.promise);
+    const archiveTask = core.archive("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    runtimeStart.resolve({});
+
+    await expect(archiveTask).rejects.toThrow("adapter changed");
+    expect(adapterA.archive).not.toHaveBeenCalled();
+    expect(adapterB.archive).not.toHaveBeenCalled();
+  });
+
+  it("preserves an adapter failure that races an adapter change", async () => {
+    const unarchiveRequest = deferred<void>();
+    const adapterA = makeAdapter({
+      list: async () => ({
+        threads: [{ ...thread("thread-a"), status: "archived" as const }],
+      }),
+      unarchive: vi.fn(() => unarchiveRequest.promise),
+    });
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const unarchiveTask = core.unarchive("thread-a");
+    await vi.waitFor(() => expect(adapterA.unarchive).toHaveBeenCalledOnce());
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    const failure = new Error("network error");
+    unarchiveRequest.reject(failure);
+
+    await expect(unarchiveTask).rejects.toBe(failure);
+  });
+
+  it("does not apply a late initialize to the replacement adapter state", async () => {
+    const initializeRequest = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [] }),
+      initialize: vi.fn(() => initializeRequest.promise),
+    });
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const localId = core.newThreadId;
+    expect(localId).toBeDefined();
+    const initializeTask = core.initialize(localId!);
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    initializeRequest.resolve({
+      remoteId: "leaked",
+      externalId: "leaked",
+    });
+    await expect(initializeTask).rejects.toThrow("adapter changed");
+    expect(core.getItemById("leaked")).toBeUndefined();
+    expect(core.threadIds).not.toContain("leaked");
+
+    await core.getLoadThreadsPromise();
+    expect(core.getItemById(core.mainThreadId)?.status).toBe("new");
+    expect(core.getItemById(core.mainThreadId)?.remoteId).toBeUndefined();
+    await expect(core.initialize(core.mainThreadId)).resolves.toEqual({
+      remoteId: core.mainThreadId,
+      externalId: core.mainThreadId,
+    });
+  });
+
+  it("selects a controlled thread that arrives on the replacement page", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA, "thread-a");
+
+    await core.getLoadThreadsPromise();
+    core.__internal_load();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+      threadId: "thread-b",
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById(core.mainThreadId)?.remoteId).toBe("thread-b");
+  });
+
+  it("keeps the unsent draft runtime across an empty-list adapter swap", async () => {
+    const adapterA = makeAdapter();
+    const adapterB = makeAdapter();
+    const core = createCore(adapterA);
+    const stopped: string[] = [];
+    const hookManager = (
+      core as unknown as {
+        _hookManager: { stopThreadRuntime: (id: string) => void };
+      }
+    )._hookManager;
+    const originalStop = hookManager.stopThreadRuntime.bind(hookManager);
+    hookManager.stopThreadRuntime = (id: string) => {
+      stopped.push(id);
+      originalStop(id);
+    };
+
+    await core.getLoadThreadsPromise();
+    const draftId = core.mainThreadId;
+    expect(core.getItemById(draftId)?.status).toBe("new");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.mainThreadId).toBe(draftId);
+    expect(core.getItemById(draftId)?.status).toBe("new");
+    expect(stopped).not.toContain(draftId);
+  });
+
+  it("stops runtimes for threads missing from the replacement list", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA);
+    const stopped: string[] = [];
+    const hookManager = (
+      core as unknown as {
+        _hookManager: { stopThreadRuntime: (id: string) => void };
+      }
+    )._hookManager;
+    const originalStop = hookManager.stopThreadRuntime.bind(hookManager);
+    hookManager.stopThreadRuntime = (id: string) => {
+      stopped.push(id);
+      originalStop(id);
+    };
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(stopped).toContain("thread-a");
+    expect(stopped).not.toContain(core.mainThreadId);
+  });
+
+  it("does not reject when a controlled thread is missing from the replacement adapter", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+      fetch: vi.fn(async () => {
+        throw new Error("not found");
+      }),
+    });
+    const core = createCore(adapterA, "thread-a");
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+      threadId: "thread-a",
+    });
+    await expect(core.getLoadThreadsPromise()).resolves.toBeUndefined();
+    await vi.waitFor(() => {
+      expect(adapterB.fetch).toHaveBeenCalledWith("thread-a");
+    });
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById(core.mainThreadId)?.status).toBe("new");
+  });
+
+  it("reuses the preserved unsent draft when the selected thread is missing after swap", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: async () => ({ threads: [thread("thread-b")] }),
+    });
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    const draftId = core.newThreadId;
+    expect(draftId).toBeDefined();
+    await core.switchToThread("thread-a");
+    expect(core.mainThreadId).toBe("thread-a");
+    expect(core.newThreadId).toBe(draftId);
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.mainThreadId).toBe(draftId);
+    expect(core.newThreadId).toBe(draftId);
+    expect(core.getItemById(draftId!)?.status).toBe("new");
+    expect(
+      Object.values(core.threadItems).filter((item) => item.status === "new"),
+    ).toHaveLength(1);
+  });
+
+  it("does not send a rename through the replacement adapter while its list is pending", 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),
+    });
+    const core = createCore(adapterA);
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await expect(core.rename("thread-a", "leaked")).rejects.toThrow(
+      "adapter changed",
+    );
+    await expect(core.switchToThread("thread-a")).rejects.toThrow(
+      "adapter changed",
+    );
+    expect(adapterB.rename).not.toHaveBeenCalled();
+
+    listB.resolve({ threads: [thread("thread-b")] });
+    await core.getLoadThreadsPromise();
+    expect(adapterB.rename).not.toHaveBeenCalled();
+    expect(core.getItemById("thread-a")).toBeUndefined();
+  });
+
+  it("does not freeze mutations when the replacement list fails", async () => {
+    const adapterA = makeAdapter({
+      list: async () => ({ threads: [thread("thread-a")] }),
+    });
+    const adapterB = makeAdapter({
+      list: vi.fn(async () => {
+        throw new Error("network");
+      }),
+    });
+    const core = createCore(adapterA);
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+
+    await core.getLoadThreadsPromise();
+    await core.switchToThread("thread-a");
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById("thread-a")).toBeUndefined();
+    expect(core.getItemById(core.mainThreadId)?.status).toBe("new");
+    await expect(core.switchToNewThread()).resolves.toBeUndefined();
+    expect(consoleError).toHaveBeenCalled();
+    consoleError.mockRestore();
+  });
+
+  it("keeps a thread initialized while the replacement list is pending", 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;
+    expect(draftId).toBeDefined();
+
+    core.__internal_setOptions({
+      adapter: adapterB,
+      runtimeHook: () => ({}) as never,
+    });
+    await expect(core.initialize(draftId!)).resolves.toEqual({
+      remoteId: "created-on-b",
+      externalId: "created-on-b",
+    });
+
+    listB.resolve({ threads: [thread("thread-b")] });
+    await core.getLoadThreadsPromise();
+
+    expect(core.getItemById(draftId!)?.remoteId).toBe("created-on-b");
+    expect(core.mainThreadId).toBe(draftId);
+    expect(core.threadIds).toContain("created-on-b");
+  });
+});

package/src/tests/session-reset-notification.test.ts

@@ -0,0 +1,145 @@
+import { describe, expect, it, vi } from "vitest";
+import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
+import { LocalRuntimeCore } from "../runtimes/local/local-runtime-core";
+import type { ChatModelAdapter } from "../runtime/utils/chat-model-adapter";
+import type { ThreadMessage } from "../types/message";
+
+async function waitFor(
+  predicate: () => unknown,
+  timeoutMs = 500,
+): Promise<void> {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      await predicate();
+      return;
+    } catch {
+      // retry
+    }
+    await new Promise((r) => setTimeout(r, 5));
+  }
+  await predicate();
+}
+
+const trailingUserMessage = {
+  id: "u1",
+  role: "user",
+  createdAt: new Date(),
+  content: [{ type: "text", text: "draft in flight" }],
+  attachments: [],
+  metadata: { custom: {} },
+} as ThreadMessage;
+
+const toolCallMessage = {
+  id: "a1",
+  role: "assistant",
+  createdAt: new Date(),
+  status: { type: "requires-action", reason: "tool-calls" },
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+  content: [
+    {
+      type: "tool-call",
+      toolCallId: "tool-1",
+      toolName: "send_email",
+      args: { to: "dev@example.com" },
+      argsText: '{"to":"dev@example.com"}',
+    },
+  ],
+} as unknown as ThreadMessage;
+
+const externalThread = () => {
+  const setToolStatuses = vi.fn();
+  const setMessages = vi.fn();
+  const onCancel = vi.fn();
+  const notifyCancelled = vi.fn();
+  const store = {
+    messages: [trailingUserMessage] as ThreadMessage[],
+    onNew: vi.fn(async () => {}),
+    onCancel,
+    setMessages,
+    unstable_enableToolInvocations: true,
+    setToolStatuses,
+    queue: {
+      __internal_notifyCancelled: notifyCancelled,
+    } as never,
+  };
+  const core = new ExternalStoreRuntimeCore(store);
+  core.registerModelContextProvider({
+    getModelContext: () => ({
+      tools: {
+        send_email: {
+          parameters: { type: "object", properties: {} },
+          execute: vi.fn(() => new Promise(() => {})),
+        },
+      },
+    }),
+  });
+  return {
+    core,
+    store,
+    thread: core.threads.getMainThreadRuntimeCore(),
+    setToolStatuses,
+    setMessages,
+    onCancel,
+    notifyCancelled,
+  };
+};
+
+const driveExecutingTool = async (
+  harness: ReturnType<typeof externalThread>,
+) => {
+  harness.core.setAdapter({
+    ...harness.store,
+    messages: [trailingUserMessage, toolCallMessage],
+  });
+  await waitFor(() => {
+    const statuses = harness.setToolStatuses.mock.lastCall?.[0] as
+      | Record<string, { type: string }>
+      | undefined;
+    expect(statuses?.["tool-1"]?.type).toBe("executing");
+  });
+};
+
+describe("unstable_notifySessionReset", () => {
+  it("clears session-scoped tool state once and parks queued work", async () => {
+    const harness = externalThread();
+    await driveExecutingTool(harness);
+
+    harness.setToolStatuses.mockClear();
+    harness.thread.unstable_notifySessionReset();
+
+    expect(harness.setToolStatuses).toHaveBeenCalledTimes(1);
+    expect(harness.setToolStatuses).toHaveBeenLastCalledWith({});
+    expect(harness.notifyCancelled).toHaveBeenCalledTimes(1);
+  });
+
+  it("carries no run-cancel semantics", async () => {
+    const harness = externalThread();
+    await driveExecutingTool(harness);
+
+    harness.thread.unstable_notifySessionReset();
+
+    expect(harness.onCancel).not.toHaveBeenCalled();
+    expect(harness.setMessages).not.toHaveBeenCalled();
+    expect(harness.thread.messages.at(-1)?.id).toBe("a1");
+  });
+
+  it("throws on runtimes without a backing session", () => {
+    const local = new LocalRuntimeCore(
+      {
+        adapters: { chatModel: { async *run() {} } satisfies ChatModelAdapter },
+      },
+      undefined,
+    );
+
+    expect(() =>
+      local.threads.getMainThreadRuntimeCore().unstable_notifySessionReset(),
+    ).toThrow("Runtime does not support resetting sessions.");
+  });
+});

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

@@ -1,8 +1,12 @@
 // @vitest-environment jsdom
 
-import { act, render } from "@testing-library/react";
+import { act, render, waitFor } from "@testing-library/react";
 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 { useRemoteThreadListRuntime } from "../react/runtimes/useRemoteThreadListRuntime";
+import { makeAdapter } from "./remote-thread-list-test-helpers";
 import { RuntimeAdapter } from "../react/RuntimeAdapter";
 import { AssistantRuntimeImpl } from "../runtime/api/assistant-runtime";
 import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
@@ -10,6 +14,15 @@ import type { ExternalStoreAdapter } from "../runtimes/external-store/external-s
 
 type DemoMessage = { id: string; role: "user" | "assistant"; text: string };
 
+const EMPTY_MESSAGES: readonly never[] = [];
+
+const useTestThreadRuntime = () =>
+  useExternalStoreRuntime({
+    messages: EMPTY_MESSAGES,
+    isRunning: false,
+    onNew: async () => {},
+  });
+
 const createRuntime = () => {
   const threads = [
     {
@@ -110,6 +123,57 @@ describe("thread switch events", () => {
     expect(switchedAwayStar).toHaveBeenLastCalledWith({ threadId: "t2" });
   });
 
+  it("delivers threads.selectionChanged with the new and previous thread ids", async () => {
+    const runtime = createRuntime();
+    const selectionChanged = vi.fn();
+    const auiOn = vi.fn();
+    let aui!: ReturnType<typeof useAui>;
+    const Consumer = () => {
+      useAuiEvent(
+        "threads.selectionChanged" as never,
+        selectionChanged as never,
+      );
+      return null;
+    };
+    const Harness = () => {
+      aui = useAui({ threads: RuntimeAdapter(runtime) } as never);
+      return (
+        <AuiProvider value={aui}>
+          <Consumer />
+        </AuiProvider>
+      );
+    };
+    render(<Harness />);
+    await act(async () => {});
+
+    aui.on("threads.selectionChanged" as never, auiOn as never);
+
+    await act(async () => {
+      aui.threads.item({ index: 1 }).switchTo();
+    });
+    await act(async () => {});
+
+    expect(selectionChanged).toHaveBeenCalledExactlyOnceWith({
+      threadId: "t2",
+      previousThreadId: "t1",
+    });
+    expect(auiOn).toHaveBeenCalledExactlyOnceWith({
+      threadId: "t2",
+      previousThreadId: "t1",
+    });
+
+    await act(async () => {
+      aui.threads.item({ index: 0 }).switchTo();
+    });
+    await act(async () => {});
+
+    expect(selectionChanged).toHaveBeenCalledTimes(2);
+    expect(selectionChanged).toHaveBeenLastCalledWith({
+      threadId: "t1",
+      previousThreadId: "t2",
+    });
+  });
+
   it("does not emit for the initially selected thread on mount", async () => {
     const runtime = createRuntime();
     const anySwitch = vi.fn();
@@ -118,6 +182,10 @@ describe("thread switch events", () => {
         { scope: "*", event: "threadListItem.switchedTo" } as never,
         anySwitch as never,
       );
+      useAuiEvent(
+        { scope: "*", event: "threads.selectionChanged" } as never,
+        anySwitch as never,
+      );
       return null;
     };
     const Harness = () => {
@@ -133,4 +201,34 @@ describe("thread switch events", () => {
 
     expect(anySwitch).not.toHaveBeenCalled();
   });
+
+  it("emits when a deep-linked initial thread resolves after mount", async () => {
+    const adapter = makeAdapter();
+    const selectionChanged = vi.fn();
+    const Listener = () => {
+      useAuiEvent("threads.selectionChanged", selectionChanged);
+      return null;
+    };
+    const Harness = () => {
+      const runtime = useRemoteThreadListRuntime({
+        adapter,
+        initialThreadId: "thread-a",
+        runtimeHook: useTestThreadRuntime,
+      });
+      return (
+        <AssistantRuntimeProvider runtime={runtime}>
+          <Listener />
+        </AssistantRuntimeProvider>
+      );
+    };
+    render(<Harness />);
+
+    await waitFor(() => expect(selectionChanged).toHaveBeenCalledTimes(1));
+    const payload = selectionChanged.mock.calls[0]![0] as {
+      threadId: string;
+      previousThreadId: string;
+    };
+    expect(payload.threadId).toBe("thread-a");
+    expect(payload.previousThreadId).toMatch(/^__LOCALID_/);
+  });
 });