@assistant-ui/core 0.3.13 → 0.3.15

package/src/tests/MessageRepository.test.ts

@@ -180,6 +180,24 @@ describe("MessageRepository", () => {
   });
 
   describe("Branch management", () => {
+    const createLongBranchMessages = (
+      messageCount: number,
+    ): Array<{ message: ThreadMessage; parentId: string | null }> => {
+      const messages: Array<{
+        message: ThreadMessage;
+        parentId: string | null;
+      }> = [{ message: createTestMessage({ id: "root" }), parentId: null }];
+
+      for (let index = 0; index < messageCount; index++) {
+        messages.push({
+          message: createTestMessage({ id: `branch-${index}` }),
+          parentId: index === 0 ? "root" : `branch-${index - 1}`,
+        });
+      }
+
+      return messages;
+    };
+
     it("should create multiple branches from a parent message", () => {
       const parent = createTestMessage({ id: "parent-id" });
       const branch1 = createTestMessage({ id: "branch1-id" });
@@ -222,6 +240,36 @@ describe("MessageRepository", () => {
       expect(messages2.map((m) => m.id)).toEqual(["parent-id", "branch2-id"]);
     });
 
+    it("should operate on a long message history without overflowing the stack", () => {
+      const messageCount = 30_000;
+      const messages = createLongBranchMessages(messageCount);
+
+      messages.push({
+        message: createTestMessage({ id: "alternate" }),
+        parentId: "root",
+      });
+
+      repository.import({ headId: "alternate", messages });
+      repository.switchToBranch("branch-0");
+
+      expect(repository.headId).toBe(`branch-${messageCount - 1}`);
+
+      repository.deleteMessage("branch-0", "root");
+
+      expect(repository.getMessage("branch-1")).toMatchObject({
+        parentId: "root",
+        index: 1,
+      });
+      expect(repository.headId).toBe(`branch-${messageCount - 1}`);
+
+      repository.resetHead("root");
+
+      expect(repository.getMessages().map((message) => message.id)).toEqual([
+        "root",
+      ]);
+      expect(() => repository.getMessage("branch-1")).toThrow();
+    }, 20_000);
+
     it("should throw error when switching to a non-existent branch", () => {
       expect(() => {
         repository.switchToBranch("non-existent-id");

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

@@ -3,10 +3,10 @@ import { createCore, makeAdapter } from "./remote-thread-list-test-helpers";
 import { InMemoryThreadListAdapter } from "../runtimes/remote-thread-list/adapter/in-memory";
 
 describe("RemoteThreadListThreadListRuntimeCore errors", () => {
-  it("includes the requested thread id when a thread is missing", () => {
+  it("includes the requested thread id when a thread is missing", async () => {
     const core = createCore(makeAdapter());
 
-    expect(() => core.rename("missing-thread", "New title")).toThrow(
+    await expect(core.rename("missing-thread", "New title")).rejects.toThrow(
       'Thread "missing-thread" not found while renaming it.',
     );
   });

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

@@ -268,6 +268,7 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     await core.getLoadThreadsPromise();
     expect(secondList).toHaveBeenCalledTimes(1);
     expect(core.threadIds).toEqual(["new"]);
+    expect(core.getItemById("old")).toBeUndefined();
   });
 
   it("ignores an in-flight loadMore response when the adapter swaps mid-flight", async () => {
@@ -289,23 +290,24 @@ describe("RemoteThreadListThreadListRuntimeCore.loadMore", () => {
     await core.getLoadThreadsPromise();
     const stale = core.loadMore();
 
-    const secondAdapter = makeAdapter({
-      list: vi.fn<ListFn>(async () => ({
-        threads: [{ status: "regular", remoteId: "ignored", externalId: "x" }],
-      })),
-    });
+    const secondList = vi.fn<ListFn>(async () => ({
+      threads: [{ status: "regular", remoteId: "fresh", externalId: "fresh" }],
+    }));
+    const secondAdapter = makeAdapter({ list: secondList });
     core.__internal_setOptions({
       adapter: secondAdapter,
       runtimeHook: () => ({}) as never,
     });
+    const replacementLoad = core.getLoadThreadsPromise();
 
     slow.resolve({
       threads: [{ status: "regular", remoteId: "stale", externalId: "stale" }],
       nextCursor: "stale-cursor",
     });
     await stale;
+    await replacementLoad;
 
-    expect(core.threadIds).toEqual(["p1"]);
+    expect(core.threadIds).toEqual(["fresh"]);
     expect(core.hasMore).toBe(false);
     expect(core.isLoadingMore).toBe(false);
   });

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

@@ -63,6 +63,31 @@ describe("RemoteThreadListThreadListRuntimeCore.switchToThread unarchive option"
     expect(core.mainThreadId).toBe(core.getItemById(THREAD_ID)?.id);
   });
 
+  it("restores an initialized draft's archived thread when unarchive fails", async () => {
+    const THREAD_ID = "archived-initialized-draft";
+    const error = new Error("unarchive failed");
+    const adapter = makeAdapter({
+      list: vi.fn(async () => ({ threads: [archivedThread(THREAD_ID)] })),
+      unarchive: vi.fn(async () => {
+        throw error;
+      }),
+    });
+
+    const core = createCore(adapter);
+    await core.getLoadThreadsPromise();
+    const draftId = core.newThreadId;
+    if (draftId === undefined) throw new Error("Expected seeded draft");
+    await core.initialize(draftId);
+    expect(core.newThreadId).toBeUndefined();
+    await core.switchToThread(THREAD_ID, { unarchive: false });
+
+    await expect(core.unarchive(THREAD_ID)).rejects.toBe(error);
+    expect(core.mainThreadId).not.toBe(THREAD_ID);
+    expect(core.getItemById(THREAD_ID)?.status).toBe("archived");
+    expect(core.archivedThreadIds).toContain(THREAD_ID);
+    expect(core.threadIds).not.toContain(THREAD_ID);
+  });
+
   it("does not call unarchive when the target is already regular, regardless of option", async () => {
     const THREAD_ID = "regular-target";
     const adapter = makeAdapter({

package/src/tests/auiV0Encode.test.ts

@@ -330,6 +330,33 @@ describe("auiV0Encode", () => {
       { type: "data", name: "telemetry", data: { runs: 3 } },
     ]);
   });
+
+  it("preserves data message parts verbatim in the core cloud encoder", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "text", text: "planned" },
+        { type: "data", name: "PredictState", data: { steps: ["a"] } },
+        { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+      ],
+    });
+
+    expect(encoded.content).toEqual([
+      { type: "text", text: "planned" },
+      { type: "data", name: "PredictState", data: { steps: ["a"] } },
+      { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+    ]);
+  });
 });
 
 describe("auiV0Decode", () => {
@@ -573,4 +600,43 @@ describe("auiV0Decode", () => {
     const toolCall = message.content.find((p) => p.type === "tool-call");
     expect(toolCall).toHaveProperty("result", false);
   });
+
+  it("round-trips data message parts, keeping repeated names in order", () => {
+    const content = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+      content: [
+        { type: "text", text: "planned" },
+        { type: "data", name: "PredictState", data: { steps: ["a"] } },
+        { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+      ],
+    });
+
+    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");
+    expect(decoded.message.content).toEqual([
+      { type: "text", text: "planned" },
+      { type: "data", name: "PredictState", data: { steps: ["a"] } },
+      { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
+    ]);
+  });
 });

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

@@ -158,6 +158,36 @@ describe("BaseComposerRuntimeCore.send restore-on-failure", () => {
     expect(append).toHaveBeenCalledTimes(1);
   });
 
+  it("snapshots role and run config before uploading attachments", async () => {
+    let resolveSend!: () => void;
+    const adapter = makeAdapter({
+      send: (a) =>
+        new Promise((resolve) => {
+          resolveSend = () =>
+            resolve({ ...a, status: { type: "complete" }, content: [] });
+        }),
+    });
+    const { composer, append } = makeComposer(adapter);
+
+    composer.setText("hello");
+    composer.setRole("assistant");
+    composer.setRunConfig({ custom: { modelName: "model-a" } });
+    await composer.addAttachment(textFile());
+
+    const sendPromise = composer.send();
+    composer.setRole("system");
+    composer.setRunConfig({ custom: { modelName: "model-b" } });
+    resolveSend();
+    await sendPromise;
+
+    expect(append).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: "assistant",
+        runConfig: { custom: { modelName: "model-a" } },
+      }),
+    );
+  });
+
   it("keeps an attachment added while the upload was in flight", async () => {
     let resolveSend!: () => void;
     const adapter = makeAdapter({

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

@@ -186,6 +186,34 @@ describe("BaseComposerRuntimeCore", () => {
     expect(composer.attachmentAccept).toBe("image/*");
   });
 
+  it("handles rejected dictation shutdowns", async () => {
+    const session: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockRejectedValue(new Error("shutdown failed")),
+      cancel: vi.fn(),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+      onSpeech: vi.fn(() => () => {}),
+    };
+    const unhandledRejection = vi.fn();
+    composer.setDictationAdapter({ listen: () => session });
+    process.on("unhandledRejection", unhandledRejection);
+
+    try {
+      composer.startDictation();
+      expect(composer.dictation).toBeDefined();
+
+      composer.stopDictation();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(session.stop).toHaveBeenCalledOnce();
+      expect(composer.dictation).toBeUndefined();
+      expect(unhandledRejection).not.toHaveBeenCalled();
+    } finally {
+      process.off("unhandledRejection", unhandledRejection);
+    }
+  });
+
   describe("CreateAttachment (external source)", () => {
     const makeCreateAttachment = (
       overrides?: Partial<CreateAttachment>,

package/src/tests/composer-can-cancel.test.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it, vi } from "vitest";
+import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
+import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type { ThreadMessage } from "../types/message";
+
+type ThreadRuntimeStub = Omit<ThreadRuntimeCore, "composer"> & {
+  notify: () => void;
+};
+
+const makeRuntimeStub = (
+  overrides: Partial<ThreadRuntimeCore> = {},
+): ThreadRuntimeStub => {
+  const subscribers = new Set<() => void>();
+  return {
+    append: vi.fn(),
+    cancelRun: vi.fn(),
+    getModelContext: () => ({}),
+    subscribe: (cb: () => void) => {
+      subscribers.add(cb);
+      return () => subscribers.delete(cb);
+    },
+    capabilities: { cancel: true },
+    messages: [],
+    isDisabled: false,
+    isSendDisabled: false,
+    isLoading: false,
+    composer: { runConfig: {} },
+    notify: () => {
+      for (const cb of subscribers) cb();
+    },
+    ...overrides,
+  } as unknown as ThreadRuntimeStub;
+};
+
+const runningAssistant = {
+  id: "a1",
+  role: "assistant",
+  status: { type: "running" },
+} as ThreadMessage;
+
+describe("DefaultThreadComposerRuntimeCore.canCancel", () => {
+  it("is false when the runtime is idle even if cancel is supported", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(makeRuntimeStub());
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("is false when cancel is not a capability", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({
+        capabilities: { cancel: false },
+        isRunning: true,
+      }),
+    );
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("is true while the runtime reports isRunning", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({ isRunning: true }),
+    );
+    expect(composer.canCancel).toBe(true);
+  });
+
+  it("is true while the trailing assistant message is running", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({ messages: [runningAssistant] }),
+    );
+    expect(composer.canCancel).toBe(true);
+  });
+
+  it("stays false after a runtime notify while idle", () => {
+    const stub = makeRuntimeStub();
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    stub.notify();
+    expect(composer.canCancel).toBe(false);
+  });
+
+  it("notifies subscribers when a run starts", () => {
+    const stub = makeRuntimeStub();
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    const onChange = vi.fn();
+    composer.subscribe(onChange);
+
+    (stub as { isRunning?: boolean }).isRunning = true;
+    stub.notify();
+
+    expect(onChange).toHaveBeenCalled();
+    expect(composer.canCancel).toBe(true);
+  });
+
+  it("returns to false when the run ends", () => {
+    const stub = makeRuntimeStub({ isRunning: true });
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    expect(composer.canCancel).toBe(true);
+
+    (stub as { isRunning?: boolean }).isRunning = false;
+    stub.notify();
+
+    expect(composer.canCancel).toBe(false);
+  });
+});

package/src/tests/empty-thread-core.test.ts

@@ -2,6 +2,12 @@ import { describe, it, expect } from "vitest";
 import { EMPTY_THREAD_CORE } from "../runtimes/remote-thread-list/empty-thread-core";
 
 describe("EMPTY_THREAD_CORE", () => {
+  it("reads no messages, branches, or exported repository", () => {
+    expect(EMPTY_THREAD_CORE.getMessageById("a")).toBeUndefined();
+    expect(EMPTY_THREAD_CORE.getBranches("a")).toEqual([]);
+    expect(EMPTY_THREAD_CORE.export()).toEqual({ messages: [] });
+  });
+
   it("has isLoading=true so it is not mistaken for an empty conversation", () => {
     expect(EMPTY_THREAD_CORE.isLoading).toBe(true);
   });

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

@@ -1,7 +1,10 @@
 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 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";
 import { ThreadListRuntimeImpl } from "../runtime/api/thread-list-runtime";
 
 const makeFactory = (overrides: Record<string, unknown> = {}) =>
@@ -18,6 +21,21 @@ const makeAdapter = (
   overrides: Partial<ExternalStoreThreadListAdapter> = {},
 ): ExternalStoreThreadListAdapter => ({ ...overrides });
 
+const mockContextProvider: ModelContextProvider = {
+  getModelContext: () => ({}),
+};
+
+const appendMessage = () => ({
+  parentId: null,
+  sourceId: null,
+  runConfig: {},
+  role: "user" as const,
+  content: [{ type: "text" as const, text: "hello" }],
+  attachments: [],
+  metadata: { custom: {} },
+  createdAt: new Date(0),
+});
+
 describe("ExternalStoreThreadListRuntimeCore - construction", () => {
   it("assigns a resolvable fallback mainThreadId when adapter has no threadId", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
@@ -149,6 +167,26 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
     expect(callback).toHaveBeenCalled();
   });
 
+  it("notifies later subscribers when an earlier subscriber throws", () => {
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      makeFactory(),
+    );
+    const error = new Error("subscriber failed");
+    const laterSubscriber = vi.fn();
+
+    core.subscribe(() => {
+      throw error;
+    });
+    core.subscribe(laterSubscriber);
+
+    expect(() =>
+      core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" })),
+    ).toThrow(error);
+    expect(core.mainThreadId).toBe("thread-beta");
+    expect(laterSubscriber).toHaveBeenCalledOnce();
+  });
+
   it("synthesizes mainThreadId entry after a switch to a threadId not in the threads list", () => {
     const core = new ExternalStoreThreadListRuntimeCore(
       makeAdapter({ threadId: "thread-alpha" }),
@@ -175,6 +213,69 @@ describe("ExternalStoreThreadListRuntimeCore - __internal_setAdapter", () => {
       "thread-gamma",
     ]);
   });
+
+  it("dispatches an append before a thread switch", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const onNew = vi.fn(async () => {});
+    const firstRuntime = new ExternalStoreThreadRuntimeCoreImpl(
+      mockContextProvider,
+      { messages: [], onNew } as ExternalStoreAdapter,
+    );
+    firstRuntime.__internal_setGetInitializePromise(() => initialization);
+    const secondRuntime = new ExternalStoreThreadRuntimeCoreImpl(
+      mockContextProvider,
+      { messages: [], onNew: vi.fn() } as ExternalStoreAdapter,
+    );
+    const factory = vi
+      .fn()
+      .mockReturnValueOnce(firstRuntime)
+      .mockReturnValueOnce(secondRuntime);
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter({ threadId: "thread-alpha" }),
+      factory,
+    );
+
+    const appendPromise = firstRuntime.append(appendMessage());
+    await Promise.resolve();
+
+    expect(onNew).toHaveBeenCalledTimes(1);
+
+    core.__internal_setAdapter(makeAdapter({ threadId: "thread-beta" }));
+    resolveInitialization();
+
+    await appendPromise;
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
+});
+
+describe("ExternalStoreThreadListRuntimeCore - detach", () => {
+  it("leaves the main thread's pending append alone when an item detaches", async () => {
+    let resolveInitialization!: () => void;
+    const initialization = new Promise<void>((resolve) => {
+      resolveInitialization = resolve;
+    });
+    const onNew = vi.fn(async () => {});
+    const runtime = new ExternalStoreThreadRuntimeCoreImpl(
+      mockContextProvider,
+      { messages: [], onNew } as ExternalStoreAdapter,
+    );
+    runtime.__internal_setGetInitializePromise(() => initialization);
+    const core = new ExternalStoreThreadListRuntimeCore(
+      makeAdapter(),
+      vi.fn(() => runtime),
+    );
+
+    const appendPromise = runtime.append(appendMessage());
+    await Promise.resolve();
+    await core.detach();
+    resolveInitialization();
+
+    await appendPromise;
+    expect(onNew).toHaveBeenCalledTimes(1);
+  });
 });
 
 describe("ExternalStoreThreadListRuntimeCore - isMain via ThreadListRuntimeImpl", () => {