@assistant-ui/core 0.3.16 → 0.3.18

package/src/tests/RemoteThreadListThreadListRuntimeCore-load-race.test.ts

@@ -36,6 +36,163 @@ describe("RemoteThreadListThreadListRuntimeCore load race", () => {
     expect(core.threadIds[0]).toBe(newId);
     expect(core.threadIds).toContain("t1");
   });
+
+  it("keeps one slot when the list reports the thread just initialized", async () => {
+    const listDeferred = deferred<ListResult>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      initialize: vi.fn(async () => ({
+        remoteId: "remote-1",
+        externalId: "remote-1",
+      })),
+    });
+    const core = createCore(adapter);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    await core.switchToNewThread();
+    const localId = core.newThreadId!;
+    await core.initialize(localId);
+
+    listDeferred.resolve({
+      threads: [
+        { status: "regular", remoteId: "remote-1", externalId: "remote-1" },
+      ],
+    });
+    await loadPromise;
+
+    expect(Object.keys(core.threadItems)).toEqual([localId]);
+    expect(core.threadIds).toEqual([localId]);
+    expect(core.getItemById("remote-1")?.id).toBe(localId);
+    expect(core.mainThreadId).toBe(localId);
+
+    await core.delete("remote-1");
+
+    expect(core.getItemById(localId)).toBeUndefined();
+    expect(core.getItemById("remote-1")).toBeUndefined();
+    expect(core.threadIds).toEqual([]);
+  });
+
+  it("collapses a slot the list minted while initialize was in flight", async () => {
+    const listDeferred = deferred<ListResult>();
+    const initializeDeferred = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      initialize: vi.fn(() => initializeDeferred.promise),
+    });
+    const core = createCore(adapter);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    await core.switchToNewThread();
+    const localId = core.newThreadId!;
+    const initializePromise = core.initialize(localId);
+
+    listDeferred.resolve({
+      threads: [
+        { status: "regular", remoteId: "remote-1", externalId: "remote-1" },
+      ],
+    });
+    await loadPromise;
+
+    initializeDeferred.resolve({
+      remoteId: "remote-1",
+      externalId: "remote-1",
+    });
+    await initializePromise;
+
+    expect(Object.keys(core.threadItems)).toEqual([localId]);
+    expect(core.threadIds).toEqual([localId]);
+    expect(core.getItemById("remote-1")?.id).toBe(localId);
+
+    await core.delete("remote-1");
+
+    expect(core.getItemById(localId)).toBeUndefined();
+    expect(core.getItemById("remote-1")).toBeUndefined();
+    expect(core.threadIds).toEqual([]);
+  });
+
+  it("keeps the initialized runtime when its listed duplicate is selected", async () => {
+    const listDeferred = deferred<ListResult>();
+    const initializeDeferred = deferred<{
+      remoteId: string;
+      externalId: undefined;
+    }>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      initialize: vi.fn(() => initializeDeferred.promise),
+    });
+    const core = createCore(adapter);
+    const hookManager = (
+      core as unknown as {
+        _hookManager: { stopThreadRuntime: (threadId: string) => void };
+      }
+    )._hookManager;
+    const stopThreadRuntime = vi.spyOn(hookManager, "stopThreadRuntime");
+
+    const loadPromise = core.getLoadThreadsPromise();
+    await core.switchToNewThread();
+    const localId = core.newThreadId!;
+    const initializePromise = core.initialize(localId);
+
+    listDeferred.resolve({
+      threads: [
+        { status: "regular", remoteId: "remote-1", externalId: "remote-1" },
+      ],
+    });
+    await loadPromise;
+    await core.switchToThread("remote-1");
+
+    initializeDeferred.resolve({
+      remoteId: "remote-1",
+      externalId: undefined,
+    });
+    await initializePromise;
+
+    expect(core.mainThreadId).toBe(localId);
+    expect(core.threadIds).toEqual([localId]);
+    expect(Object.keys(core.threadItems)).toEqual([localId]);
+    expect(core.getItemById("remote-1")?.id).toBe(localId);
+    expect(core.getItemById("remote-1")?.externalId).toBe("remote-1");
+    expect(stopThreadRuntime).toHaveBeenCalledWith("remote-1");
+    expect(stopThreadRuntime).not.toHaveBeenCalledWith(localId);
+  });
+
+  it("does not leave the collapsed slot in both lists when the race reported it archived", async () => {
+    const listDeferred = deferred<ListResult>();
+    const initializeDeferred = deferred<{
+      remoteId: string;
+      externalId: string;
+    }>();
+    const adapter = makeAdapter({
+      list: vi.fn(() => listDeferred.promise),
+      initialize: vi.fn(() => initializeDeferred.promise),
+    });
+    const core = createCore(adapter);
+
+    const loadPromise = core.getLoadThreadsPromise();
+    await core.switchToNewThread();
+    const localId = core.newThreadId!;
+    const initializePromise = core.initialize(localId);
+
+    listDeferred.resolve({
+      threads: [
+        { status: "archived", remoteId: "remote-1", externalId: "remote-1" },
+      ],
+    });
+    await loadPromise;
+
+    initializeDeferred.resolve({
+      remoteId: "remote-1",
+      externalId: "remote-1",
+    });
+    await initializePromise;
+
+    expect(Object.keys(core.threadItems)).toEqual([localId]);
+    expect(core.threadIds).toEqual([localId]);
+    expect(core.archivedThreadIds).toEqual([]);
+  });
 });
 
 describe("preserveMidLoadTransitions", () => {
@@ -49,6 +206,7 @@ describe("preserveMidLoadTransitions", () => {
     lists: { threadIds?: string[]; archivedThreadIds?: string[] } = {},
   ): RemoteThreadState => ({
     isLoading: false,
+    loadError: undefined,
     isLoadingMore: false,
     cursor: undefined,
     newThreadId: undefined,

package/src/tests/RemoteThreadListThreadListRuntimeCore-loadMore.test.ts

@@ -195,6 +195,30 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     expect(core.hasMore).toBe(false);
   });
 
+  it("clears loadingMore when the superseded request never settles", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [{ status: "regular", remoteId: "a", externalId: "a" }],
+        nextCursor: "c1",
+      })
+      .mockReturnValueOnce(new Promise<never>(() => {}))
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "fresh", externalId: "fresh" },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    await core.getLoadThreadsPromise();
+    void core.loadMore();
+    await core.reload();
+
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.isLoadingMore).toBe(false);
+  });
+
   it("releases the dedup handle after a rejection so retries can proceed", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     const listFn = vi
@@ -241,6 +265,60 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     expect(core.threadIds).toEqual(["a", "b"]);
   });
 
+  it("refreshes a thread repeated on a later page instead of dropping it", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "a", externalId: "a", title: "old" },
+        ],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "a",
+            externalId: "a",
+            title: "updated",
+          },
+          { status: "regular", remoteId: "b", externalId: "b", title: "New" },
+        ],
+      });
+    const core = createCore(makeAdapter({ list: listFn }));
+
+    await core.getLoadThreadsPromise();
+    await core.loadMore();
+
+    expect(core.threadIds).toEqual(["a", "b"]);
+    expect(core.getItemById("a")?.title).toBe("updated");
+  });
+
+  it("moves a thread whose status flips between pages", async () => {
+    const listFn = vi
+      .fn<ListFn>()
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "regular", remoteId: "a", externalId: "a", title: "A" },
+          { status: "regular", remoteId: "b", externalId: "b", title: "B" },
+        ],
+        nextCursor: "c1",
+      })
+      .mockResolvedValueOnce({
+        threads: [
+          { status: "archived", remoteId: "a", externalId: "a", title: "A" },
+        ],
+      });
+    const core = createCore(makeAdapter({ list: listFn }));
+
+    await core.getLoadThreadsPromise();
+    await core.loadMore();
+
+    expect(core.threadIds).toEqual(["b"]);
+    expect(core.archivedThreadIds).toEqual(["a"]);
+    expect(core.getItemById("a")?.status).toBe("archived");
+  });
+
   it("__internal_setOptions clears cursor and dedup handles on adapter swap, then refetches via the new adapter", async () => {
     const firstAdapter = makeAdapter({
       list: vi.fn<ListFn>(async () => ({

package/src/tests/RemoteThreadListThreadListRuntimeCore-reload.test.ts

@@ -95,6 +95,58 @@ describe("RemoteThreadListThreadListRuntimeCore.reload", () => {
     expect(core.threadIds).not.toContain("stale");
   });
 
+  it("clears loading when the superseded request never settles", async () => {
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockReturnValueOnce(new Promise<never>(() => {}))
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "fresh",
+            externalId: "fresh",
+            title: "Fresh",
+          },
+        ],
+      });
+    const adapter = makeAdapter({ list: listFn });
+    const core = createCore(adapter);
+
+    void core.getLoadThreadsPromise();
+    await core.reload();
+
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.isLoading).toBe(false);
+  });
+
+  it("clears loading once the fresh list arrives, before the superseded request settles", async () => {
+    const first = deferred<RemoteThreadListResponse>();
+    const listFn = vi
+      .fn<() => Promise<RemoteThreadListResponse>>()
+      .mockReturnValueOnce(first.promise)
+      .mockResolvedValueOnce({
+        threads: [
+          {
+            status: "regular",
+            remoteId: "fresh",
+            externalId: "fresh",
+            title: "Fresh",
+          },
+        ],
+      });
+    const core = createCore(makeAdapter({ list: listFn }));
+
+    void core.getLoadThreadsPromise();
+    await core.reload();
+
+    expect(core.threadIds).toEqual(["fresh"]);
+    expect(core.isLoading).toBe(false);
+
+    first.resolve({ threads: [] });
+    await Promise.resolve();
+    expect(core.isLoading).toBe(false);
+  });
+
   it("recovers after a failed initial load", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     const listFn = vi

package/src/tests/RemoteThreadListThreadListRuntimeCore-title-race.test.ts

@@ -6,6 +6,95 @@ import {
 } from "./remote-thread-list-test-helpers";
 
 describe("RemoteThreadListThreadListRuntimeCore title generation", () => {
+  it("preserves an existing title when generation returns no title", async () => {
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-1",
+            externalId: "thread-1",
+            title: "Existing title",
+          },
+        ],
+      })),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const internals = core as unknown as {
+      _hookManager: { getThreadRuntimeCore: () => { messages: never[] } };
+    };
+    internals._hookManager.getThreadRuntimeCore = () => ({ messages: [] });
+
+    await core.generateTitle("thread-1");
+
+    expect(adapter.generateTitle).toHaveBeenCalledOnce();
+    expect(core.getItemById("thread-1")?.title).toBe("Existing title");
+  });
+
+  it("keeps a manual rename made during automatic title generation", async () => {
+    const generatedTitle = deferred<ReadableStream>();
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({
+        threads: [
+          {
+            status: "regular" as const,
+            remoteId: "thread-1",
+            externalId: "thread-1",
+            title: "New chat",
+          },
+        ],
+      })),
+      generateTitle: vi.fn(async () => generatedTitle.promise as never),
+    });
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+
+    const internals = core as unknown as {
+      _hookManager: { getThreadRuntimeCore: () => { messages: never[] } };
+    };
+    internals._hookManager.getThreadRuntimeCore = () => ({ messages: [] });
+
+    const generation = core.generateTitle("thread-1", { automatic: true });
+    await vi.waitFor(() => {
+      expect(adapter.generateTitle).toHaveBeenCalledOnce();
+    });
+    await core.rename("thread-1", "Manual title");
+
+    generatedTitle.resolve(
+      new ReadableStream({
+        start(controller) {
+          controller.enqueue({
+            type: "part-start",
+            path: [0],
+            part: { type: "text" },
+          });
+          controller.enqueue({
+            type: "text-delta",
+            path: [0],
+            textDelta: "Generated title",
+          });
+          controller.enqueue({ type: "part-finish", path: [0] });
+          controller.close();
+        },
+      }),
+    );
+    await generation;
+
+    expect(core.getItemById("thread-1")?.title).toBe("Manual title");
+    expect(adapter.rename).toHaveBeenNthCalledWith(
+      1,
+      "thread-1",
+      "Manual title",
+    );
+    expect(adapter.rename).toHaveBeenNthCalledWith(
+      2,
+      "thread-1",
+      "Manual title",
+    );
+  });
+
   it("keeps a generated title when an earlier rename completes during another update", async () => {
     const reloadRequest = deferred<{
       threads: {

package/src/tests/attachment-adapters.test.ts

@@ -8,6 +8,20 @@ import {
 } from "../adapters/attachment";
 
 describe("fileMatchesAccept", () => {
+  it.each([
+    ["BACKUP.TAR.GZ", ".tar.gz"],
+    [".env", ".env"],
+  ])("accepts %s for %s", (name, accept) => {
+    expect(fileMatchesAccept({ name, type: "" }, accept)).toBe(true);
+  });
+
+  it.each([
+    ["png", ".png"],
+    ["foo.mjs", ".js"],
+  ])("rejects %s for %s", (name, accept) => {
+    expect(fileMatchesAccept({ name, type: "" }, accept)).toBe(false);
+  });
+
   it("matches MIME types with parameters", () => {
     expect(
       fileMatchesAccept(

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

@@ -103,6 +103,45 @@ describe("BaseComposerRuntimeCore", () => {
     expect(listener).not.toHaveBeenCalled();
   });
 
+  it("reset keeps discarded text out of later dictation results", async () => {
+    let emitSpeech!: (result: DictationAdapter.Result) => void;
+    composer.setDictationAdapter({
+      listen: () => ({
+        status: { type: "running" },
+        stop: async () => {},
+        cancel: () => {},
+        onSpeechStart: () => () => {},
+        onSpeechEnd: () => () => {},
+        onSpeech: (callback) => {
+          emitSpeech = callback;
+          return () => {};
+        },
+      }),
+    });
+
+    composer.setText("old");
+    composer.startDictation();
+    try {
+      await composer.reset();
+      expect(composer.text).toBe("");
+      emitSpeech({ transcript: "new", isFinal: true });
+      expect(composer.text).toBe("new");
+
+      emitSpeech({ transcript: "pending", isFinal: false });
+      expect(composer.text).toBe("new pending");
+      await composer.reset();
+      expect(composer.text).toBe("");
+      expect(composer.dictation?.transcript).toBeUndefined();
+
+      emitSpeech({ transcript: "next", isFinal: false });
+      expect(composer.text).toBe("next");
+      emitSpeech({ transcript: "next final", isFinal: true });
+      expect(composer.text).toBe("next final");
+    } finally {
+      composer.stopDictation();
+      await Promise.resolve();
+    }
+  });
   it("send includes quote in metadata and clears it", async () => {
     const quote = { text: "quoted", messageId: "m1" };
     composer.setText("reply");

package/src/tests/external-store-optimistic-id.test.ts

@@ -0,0 +1,79 @@
+import { describe, it, expect, vi } from "vitest";
+import { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
+import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { ModelContextProvider } from "../model-context/types";
+import type { ThreadMessage } from "../types/message";
+
+const createContextProvider = (): ModelContextProvider => ({
+  getModelContext: () => ({}),
+});
+
+const createUserMessage = (id: string, text = "Hello"): ThreadMessage =>
+  ({
+    id,
+    role: "user" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    attachments: [],
+    metadata: {
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createAssistantMessage = (id: string, text = "Hi there"): ThreadMessage =>
+  ({
+    id,
+    role: "assistant" as const,
+    createdAt: new Date(),
+    content: [{ type: "text" as const, text }],
+    status: { type: "complete" as const, reason: "stop" as const },
+    metadata: {
+      unstable_state: null,
+      unstable_annotations: [],
+      unstable_data: [],
+      steps: [],
+      custom: {},
+    },
+  }) as ThreadMessage;
+
+const createAdapter = (
+  messages: readonly ThreadMessage[],
+  isRunning: boolean,
+): ExternalStoreAdapter<ThreadMessage> => ({
+  messages,
+  isRunning,
+  onNew: vi.fn(async () => {}),
+});
+
+describe("ExternalStoreThreadRuntimeCore optimistic placeholder id", () => {
+  it("keeps one placeholder id per pending response and issues a fresh one per episode", () => {
+    const u1 = createUserMessage("u1");
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createAdapter([u1], true),
+    );
+    const first = core.messages.at(-1)!;
+    expect(first.role).toBe("assistant");
+    expect(first.content).toHaveLength(0);
+
+    core.__internal_setAdapter(createAdapter([u1], true));
+    core.__internal_setAdapter(createAdapter([u1], true));
+    expect(core.messages.at(-1)!.id).toBe(first.id);
+
+    const u2 = createUserMessage("u2", "follow-up");
+    core.__internal_setAdapter(createAdapter([u1, u2], true));
+    const second = core.messages.at(-1)!;
+    expect(second.role).toBe("assistant");
+    expect(second.id).not.toBe(first.id);
+
+    const a1 = createAssistantMessage("a1");
+    core.__internal_setAdapter(createAdapter([u1, u2, a1], false));
+    expect(core.messages.at(-1)!.id).toBe("a1");
+
+    const u3 = createUserMessage("u3", "again");
+    core.__internal_setAdapter(createAdapter([u1, u2, a1, u3], true));
+    const third = core.messages.at(-1)!;
+    expect(third.role).toBe("assistant");
+    expect(third.id).not.toBe(second.id);
+  });
+});