@assistant-ui/core 0.3.17 → 0.3.18

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

@@ -113,6 +113,52 @@ describe("RemoteThreadListThreadListRuntimeCore load race", () => {
     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<{
@@ -160,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-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-thread-list-runtime-core.test.ts

@@ -2,6 +2,7 @@ import { describe, expect, it, vi } from "vitest";
 import { ExternalStoreThreadListRuntimeCore } from "../runtimes/external-store/external-store-thread-list-runtime-core";
 import type { ExternalStoreThreadRuntimeCore } from "../runtimes/external-store/external-store-thread-runtime-core";
 import { ExternalStoreThreadRuntimeCore as ExternalStoreThreadRuntimeCoreImpl } from "../runtimes/external-store/external-store-thread-runtime-core";
+import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-runtime-core";
 import type { ExternalStoreThreadListAdapter } from "../runtimes/external-store/external-store-adapter";
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
 import type { ModelContextProvider } from "../model-context/types";
@@ -109,10 +110,56 @@ describe("ExternalStoreThreadListRuntimeCore - construction", () => {
     // Two empty-adapter constructions should share the frozen DEFAULT_THREAD_DATA
     // singleton rather than each getting a fresh `{ ... }` clone.
     expect(a.threadItems).toBe(b.threadItems);
+    expect(Object.getPrototypeOf(a.threadItems)).toBeNull();
   });
+
+  it.each(["__proto__", "constructor", "toString"])(
+    "returns undefined for an absent prototype-named thread id %s",
+    (threadId) => {
+      const core = new ExternalStoreThreadListRuntimeCore(
+        makeAdapter(),
+        makeFactory(),
+      );
+
+      expect(core.getItemById(threadId)).toBeUndefined();
+      expect(Object.hasOwn(core.threadItems, threadId)).toBe(false);
+    },
+  );
 });
 
 describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
+  it("updates subscribed loading state when thread ids and arrays stay unchanged", () => {
+    const threadList = makeAdapter({
+      threadId: "thread-alpha",
+      threads: [{ id: "thread-alpha", status: "regular" }],
+      archivedThreads: [],
+      isLoading: true,
+    });
+    const adapter: ExternalStoreAdapter = {
+      messages: [],
+      onNew: async () => {},
+      adapters: { threadList },
+    };
+    const core = new ExternalStoreRuntimeCore(adapter);
+    const runtime = new ThreadListRuntimeImpl(core.threads);
+    const seen: boolean[] = [];
+    const unsubscribe = runtime.subscribe(() => {
+      seen.push(runtime.getState().isLoading);
+    });
+    expect(runtime.getState().isLoading).toBe(true);
+
+    for (const isLoading of [false, true, undefined, false]) {
+      core.setAdapter({
+        ...adapter,
+        adapters: { threadList: { ...threadList, isLoading } },
+      });
+    }
+
+    expect(seen).toEqual([false, true, false]);
+    expect(runtime.getState().isLoading).toBe(false);
+    unsubscribe();
+  });
+
   it("updates mainThreadId when adapter.threadId changes", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),
@@ -198,6 +245,42 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     expect(item?.id).toBe("thread-beta");
   });
 
+  it.each(["__proto__", "constructor", "toString"])(
+    "synthesizes a main entry for a prototype-named thread id %s",
+    (threadId) => {
+      const core = new ExternalStoreThreadListRuntimeCore(
+        makeAdapter({ threadId }),
+        makeFactory(),
+      );
+
+      expect(core.getItemById(threadId)).toEqual(
+        expect.objectContaining({ id: threadId, status: "regular" }),
+      );
+      expect(Object.hasOwn(core.threadItems, threadId)).toBe(true);
+      expect(Object.getPrototypeOf(core.threadItems)).toBeNull();
+    },
+  );
+
+  it.each(["regular", "archived"] as const)(
+    "preserves a prototype-named %s adapter entry",
+    (status) => {
+      const adapter: ExternalStoreThreadListAdapter =
+        status === "regular"
+          ? { threads: [{ id: "__proto__", status }] }
+          : { archivedThreads: [{ id: "__proto__", status }] };
+      const core = new ExternalStoreThreadListRuntimeCore(
+        makeAdapter(adapter),
+        makeFactory(),
+      );
+
+      expect(core.getItemById("__proto__")).toEqual(
+        expect.objectContaining({ id: "__proto__", status }),
+      );
+      expect(Object.hasOwn(core.threadItems, "__proto__")).toBe(true);
+      expect(Object.getPrototypeOf(core.threadItems)).toBeNull();
+    },
+  );
+
   it("does not retain stale synthesized entries across mainThreadId switches", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),

package/src/tests/external-store-thread-runtime-core-adapter.test.ts

@@ -160,26 +160,35 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(onNew).not.toHaveBeenCalled();
     });
 
-    it("throws when adapter has no onEdit and parentId differs from head", async () => {
-      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
-      const adapter = createBaseAdapter({ messages });
-      const core = new ExternalStoreThreadRuntimeCore(contextProvider, adapter);
+    it.each(["u1", null])(
+      "rejects parent %s without onEdit",
+      async (parentId) => {
+        const messages = [
+          createUserMessage("u1"),
+          createAssistantMessage("a1"),
+        ];
+        const adapter = createBaseAdapter({ messages });
+        const core = new ExternalStoreThreadRuntimeCore(
+          contextProvider,
+          adapter,
+        );
 
-      const appendMessage: AppendMessage = {
-        role: "user",
-        content: [{ type: "text", text: "Edit" }],
-        attachments: [],
-        createdAt: new Date(),
-        parentId: "u1",
-        sourceId: null,
-        runConfig: undefined,
-        metadata: { custom: {} },
-      } as AppendMessage;
+        const appendMessage: AppendMessage = {
+          role: "user",
+          content: [{ type: "text", text: "Edit" }],
+          attachments: [],
+          createdAt: new Date(),
+          parentId,
+          sourceId: null,
+          runConfig: undefined,
+          metadata: { custom: {} },
+        } as AppendMessage;
 
-      await expect(core.append(appendMessage)).rejects.toThrow(
-        "Runtime does not support editing messages.",
-      );
-    });
+        await expect(core.append(appendMessage)).rejects.toThrow(
+          "Runtime does not support editing messages.",
+        );
+      },
+    );
   });
 
   describe("startRun", () => {

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

@@ -4,6 +4,7 @@ import { act, render, waitFor } from "@testing-library/react";
 import type { FC } from "react";
 import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
 import { AuiProvider, useAui } from "@assistant-ui/store";
+import { CompositeAttachmentAdapter } from "../adapters/attachment";
 import type {
   ExternalThreadMessage,
   ExternalThreadProps,
@@ -404,6 +405,53 @@ describe("ExternalThread attachments", () => {
     },
   );
 
+  it("preserves pending attachments when adapter removal fails", async () => {
+    const error = new Error("remove failed");
+    const remove = vi.fn(async () => {
+      throw error;
+    });
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const adapter = {
+      accept: "*",
+      add: async () => ({
+        id: "att-1",
+        type: "file" as const,
+        name: file.name,
+        contentType: file.type,
+        file,
+        status: {
+          type: "requires-action" as const,
+          reason: "composer-send" as const,
+        },
+      }),
+      send: async () => ({}) as never,
+      remove,
+    };
+    const aui = renderThreadWithProps({ attachmentAdapter: adapter });
+    const composer = () => aui().thread.composer();
+
+    await act(() => composer().addAttachment(file));
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+
+    await expect(
+      act(() => composer().attachment({ id: "att-1" }).remove()),
+    ).rejects.toBe(error);
+
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "att-1" }),
+    );
+    expect(composer().getState().attachments).toHaveLength(1);
+    await waitFor(() =>
+      expect(composer().getState().attachments[0]?.status).toEqual({
+        type: "incomplete",
+        reason: "error",
+        message: "remove failed",
+      }),
+    );
+  });
+
   it.each([
     [
       "clearAttachments",
@@ -610,6 +658,97 @@ describe("ExternalThread attachments", () => {
     });
   });
 
+  it("removes complete edit attachments without adapter cleanup", async () => {
+    const remove = vi.fn(async () => {});
+    const completeAttachment = {
+      id: "image-1",
+      type: "image",
+      name: "image",
+      content: [{ type: "image", image: "data:image/png;base64,data" }],
+      status: { type: "complete" },
+    } as unknown as CompleteAttachment;
+    const aui = renderThreadWithProps({
+      messages: [
+        {
+          id: "u1",
+          role: "user",
+          content: [{ type: "text", text: "hi" }],
+          createdAt: new Date(0),
+          attachments: [completeAttachment],
+          metadata: { custom: {} },
+        } as unknown as ExternalThreadMessage,
+      ],
+      onEdit: () => {},
+      attachmentAdapter: new CompositeAttachmentAdapter([
+        {
+          accept: "image/*",
+          add: async () => {
+            throw new Error("not used");
+          },
+          send: async () => {
+            throw new Error("not used");
+          },
+          remove,
+        },
+      ]),
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => composer().beginEdit());
+    await waitFor(() =>
+      expect(composer().getState().attachments).toHaveLength(1),
+    );
+    await act(() => composer().attachment({ id: "image-1" }).remove());
+
+    expect(remove).not.toHaveBeenCalled();
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
+  it("calls adapter.remove for pending edit attachments", async () => {
+    const remove = vi.fn(async () => {});
+    const file = new File(["data"], "notes.txt", { type: "text/plain" });
+    const aui = 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: async () => ({
+          id: "pending-1",
+          type: "document" as const,
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: {
+            type: "requires-action" as const,
+            reason: "composer-send" as const,
+          },
+        }),
+        send: async () => ({}) as never,
+        remove,
+      },
+    });
+    const composer = () => aui().thread.message({ id: "u1" }).composer();
+
+    await act(async () => composer().beginEdit());
+    await act(() => composer().addAttachment(file));
+    await act(() => composer().attachment({ id: "pending-1" }).remove());
+
+    expect(remove).toHaveBeenCalledTimes(1);
+    expect(remove).toHaveBeenCalledWith(
+      expect.objectContaining({ id: "pending-1" }),
+    );
+    expect(composer().getState().attachments).toEqual([]);
+  });
+
   it("merges the failed send into a draft the user already modified", async () => {
     vi.spyOn(console, "error").mockImplementation(() => {});
     let rejectSend!: (reason: unknown) => void;

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

@@ -229,6 +229,29 @@ describe("ExternalThread unset optional callbacks", () => {
   });
 });
 
+describe("ExternalThread append parent selection", () => {
+  it("passes an explicit null parent to the host", () => {
+    const onNew = vi.fn();
+    const { aui } = renderThread({
+      messages: [assistantMessage({ type: "complete", reason: "stop" })],
+      onNew,
+    });
+
+    aui().thread.append({
+      parentId: null,
+      content: [{ type: "text", text: "new root" }],
+      startRun: false,
+    });
+
+    expect(onNew).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({
+        parentId: null,
+        content: [{ type: "text", text: "new root" }],
+      }),
+    );
+  });
+});
+
 describe("ExternalThread composer", () => {
   it("dispatches a synchronous setText + send sequence", async () => {
     const onNew = vi.fn();

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

@@ -352,6 +352,84 @@ const switchTo = async (runtime: AssistantRuntime, remoteId: string) => {
   });
 };
 
+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: [] }>();