@assistant-ui/core 0.3.17 → 0.3.19

package/src/tests/RemoteThreadListThreadListRuntimeCore-initialize-adapter-change.test.ts

@@ -0,0 +1,38 @@
+import { describe, expect, it, vi } from "vitest";
+import {
+  createCore,
+  deferred,
+  makeAdapter,
+} from "./remote-thread-list-test-helpers";
+
+type InitializeResult = { remoteId: string; externalId: string };
+
+describe("RemoteThreadListThreadListRuntimeCore initialize", () => {
+  it("keeps the initialization task on the promoted slot when the adapter changes mid-flight", async () => {
+    const initializing = deferred<InitializeResult>();
+    const core = createCore(
+      makeAdapter({ initialize: vi.fn(() => initializing.promise) }),
+    );
+
+    await core.switchToNewThread();
+    const localId = core.newThreadId!;
+    const pending = core.initialize(localId);
+
+    // An adapter swap advances the generation without resetting the store, so
+    // the completion still applies its optimistic transform while `then`
+    // declines to reconcile against the retired adapter.
+    core.__internal_setOptions({
+      adapter: makeAdapter(),
+      runtimeHook: () => ({}) as never,
+    });
+
+    initializing.resolve({ remoteId: "remote-1", externalId: "external-1" });
+    await expect(pending).rejects.toThrow();
+
+    const item = core.getItemById(localId);
+    expect(item?.status).toBe("regular");
+    await expect(
+      item?.status === "new" ? undefined : item?.initializeTask,
+    ).resolves.toEqual({ remoteId: "remote-1", externalId: "external-1" });
+  });
+});

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/auiV0Encode.test.ts

@@ -236,6 +236,36 @@ describe("auiV0Encode", () => {
     ]);
   });
 
+  it("preserves reasoning provider metadata", () => {
+    const encoded = auiV0Encode({
+      id: "m1",
+      createdAt: new Date(),
+      role: "assistant",
+      status: { type: "complete", reason: "stop" },
+      content: [
+        {
+          type: "reasoning",
+          text: "thinking",
+          providerMetadata: { "assistant-ui": { duration: 3200 } },
+        },
+      ],
+      metadata: {
+        unstable_state: null,
+        unstable_annotations: [],
+        unstable_data: [],
+        steps: [],
+        custom: {},
+      },
+    });
+    expect(encoded.content).toEqual([
+      {
+        type: "reasoning",
+        text: "thinking",
+        providerMetadata: { "assistant-ui": { duration: 3200 } },
+      },
+    ]);
+  });
+
   it("preserves reasoning summaries and omits absent summaries", () => {
     const encoded = auiV0Encode({
       id: "m1",
@@ -639,4 +669,274 @@ describe("auiV0Decode", () => {
       { type: "data", name: "PredictState", data: '{"steps":["a","b"]}' },
     ]);
   });
+
+  it("round-trips parent IDs and tool-call state", () => {
+    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: "answer", parentId: "text-parent" },
+        {
+          type: "reasoning",
+          text: "thinking",
+          parentId: "reasoning-parent",
+        },
+        {
+          type: "source",
+          sourceType: "url",
+          id: "source-url",
+          url: "https://example.com",
+          parentId: "url-parent",
+        },
+        {
+          type: "source",
+          sourceType: "document",
+          id: "source-document",
+          title: "notes",
+          mediaType: "text/plain",
+          parentId: "document-parent",
+        },
+        {
+          type: "file",
+          data: "file-1",
+          mimeType: "application/pdf",
+          parentId: "file-parent",
+        },
+        {
+          type: "tool-call",
+          toolCallId: "tool-1",
+          toolName: "review",
+          args: { document: "proposal" },
+          argsText: '{"document":"proposal"}',
+          parentId: "tool-parent",
+          interrupt: { type: "human", payload: { question: "continue?" } },
+          timing: { startedAt: 10, completedAt: 20 },
+          mcp: {
+            app: { resourceUri: "ui://review", serverId: "server-1" },
+          },
+          messages: [
+            {
+              id: "nested",
+              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: "nested", parentId: "nested-parent" },
+              ],
+            },
+          ],
+        },
+        {
+          type: "generative-ui",
+          id: "ui-1",
+          parentId: "ui-parent",
+          spec: { root: { component: "Card", props: { title: "Review" } } },
+        },
+      ],
+    });
+
+    expect(content.content).toEqual([
+      { type: "text", text: "answer", parentId: "text-parent" },
+      {
+        type: "reasoning",
+        text: "thinking",
+        parentId: "reasoning-parent",
+      },
+      {
+        type: "source",
+        sourceType: "url",
+        id: "source-url",
+        url: "https://example.com",
+        parentId: "url-parent",
+      },
+      {
+        type: "source",
+        sourceType: "document",
+        id: "source-document",
+        title: "notes",
+        mediaType: "text/plain",
+        parentId: "document-parent",
+      },
+      {
+        type: "file",
+        data: "file-1",
+        mimeType: "application/pdf",
+        parentId: "file-parent",
+      },
+      {
+        type: "tool-call",
+        toolCallId: "tool-1",
+        toolName: "review",
+        args: { document: "proposal" },
+        parentId: "tool-parent",
+        interrupt: { type: "human", payload: { question: "continue?" } },
+        timing: { startedAt: 10, completedAt: 20 },
+        mcp: {
+          app: { resourceUri: "ui://review", serverId: "server-1" },
+        },
+        messages: [
+          {
+            id: "nested",
+            createdAt: "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: "nested", parentId: "nested-parent" },
+            ],
+          },
+        ],
+      },
+      {
+        type: "generative-ui",
+        id: "ui-1",
+        parentId: "ui-parent",
+        spec: { root: { component: "Card", props: { title: "Review" } } },
+      },
+    ]);
+
+    const decoded = auiV0Decode({
+      id: "cloud",
+      parent_id: null,
+      format: "aui/v0",
+      content: content as never,
+      created_at: new Date("2026-03-15T00:00:00.000Z"),
+    });
+
+    if (decoded.message.role !== "assistant")
+      throw new Error("expected assistant");
+    expect(decoded.message.content).toEqual([
+      { type: "text", text: "answer", parentId: "text-parent" },
+      {
+        type: "reasoning",
+        text: "thinking",
+        parentId: "reasoning-parent",
+      },
+      {
+        type: "source",
+        sourceType: "url",
+        id: "source-url",
+        url: "https://example.com",
+        parentId: "url-parent",
+      },
+      {
+        type: "source",
+        sourceType: "document",
+        id: "source-document",
+        title: "notes",
+        mediaType: "text/plain",
+        parentId: "document-parent",
+      },
+      {
+        type: "file",
+        data: "file-1",
+        mimeType: "application/pdf",
+        parentId: "file-parent",
+      },
+      expect.objectContaining({
+        type: "tool-call",
+        toolCallId: "tool-1",
+        toolName: "review",
+        args: { document: "proposal" },
+        argsText: '{"document":"proposal"}',
+        parentId: "tool-parent",
+        interrupt: { type: "human", payload: { question: "continue?" } },
+        timing: { startedAt: 10, completedAt: 20 },
+        mcp: {
+          app: { resourceUri: "ui://review", serverId: "server-1" },
+        },
+        messages: [
+          expect.objectContaining({
+            id: "nested",
+            createdAt: new Date("2026-03-15T00:00:00.000Z"),
+            role: "assistant",
+            content: [
+              { type: "text", text: "nested", parentId: "nested-parent" },
+            ],
+          }),
+        ],
+      }),
+      {
+        type: "generative-ui",
+        id: "ui-1",
+        parentId: "ui-parent",
+        spec: { root: { component: "Card", props: { title: "Review" } } },
+      },
+    ]);
+  });
+
+  it("keeps audio message and attachment parts as audio", () => {
+    const content = auiV0Encode({
+      id: "local",
+      createdAt: new Date("2026-03-15T00:00:00.000Z"),
+      role: "user",
+      metadata: { custom: {} },
+      content: [
+        {
+          type: "audio",
+          audio: { data: "SUQzAw==", format: "mp3" },
+        },
+      ],
+      attachments: [
+        {
+          id: "attachment",
+          type: "file",
+          name: "recording",
+          status: { type: "complete" },
+          content: [
+            {
+              type: "audio",
+              audio: { data: "data:audio/wav;base64,UklGRg==", format: "wav" },
+            },
+          ],
+        },
+      ],
+    });
+
+    expect(content.content).toEqual([
+      { type: "audio", audio: { data: "SUQzAw==", format: "mp3" } },
+    ]);
+    expect(content.attachments?.[0]?.content).toEqual([
+      {
+        type: "audio",
+        audio: { data: "data:audio/wav;base64,UklGRg==", format: "wav" },
+      },
+    ]);
+
+    const decoded = auiV0Decode({
+      id: "cloud",
+      parent_id: null,
+      format: "aui/v0",
+      content: content as never,
+      created_at: new Date("2026-03-15T00:00:00.000Z"),
+    });
+
+    if (decoded.message.role !== "user") throw new Error("expected user");
+    expect(decoded.message.content).toEqual(content.content);
+    expect(decoded.message.attachments[0]?.content).toEqual(
+      content.attachments?.[0]?.content,
+    );
+  });
 });

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

@@ -5,6 +5,7 @@ import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-cor
 import type { PendingAttachment } from "../types/attachment";
 import { MessageNotSentError } from "../types/error";
 import { BaseComposerRuntimeCore } from "../runtime/base/base-composer-runtime-core";
+import { LocalRuntimeCore } from "../runtimes/local/local-runtime-core";
 
 const makeAdapter = (
   overrides: Partial<AttachmentAdapter> = {},
@@ -379,6 +380,56 @@ describe("BaseComposerRuntimeCore.send restore-on-failure", () => {
     await removePromise;
   });
 
+  it("excludes cleared attachments when the upload finishes before adapter removal", async () => {
+    const upload = Promise.withResolvers<void>();
+    const removal = Promise.withResolvers<void>();
+    const adapter = makeAdapter({
+      send: async (attachment) => {
+        await upload.promise;
+        return { ...attachment, status: { type: "complete" }, content: [] };
+      },
+      remove: () => removal.promise,
+    });
+    const core = new LocalRuntimeCore(
+      {
+        adapters: {
+          chatModel: { run: async () => ({ content: [] }) },
+          attachments: adapter,
+        },
+      },
+      undefined,
+    );
+    const thread = core.threads.getMainThreadRuntimeCore();
+    const composer = thread.composer;
+    composer.setText("hello");
+    await composer.addAttachment(textFile());
+    await composer.addAttachment({
+      id: "ready",
+      name: "ready.txt",
+      content: [],
+    });
+
+    const sendPromise = composer.send({ startRun: false });
+    const clearPromise = composer.clearAttachments();
+    expect(composer.attachments).toEqual([]);
+    await composer.addAttachment({
+      id: "later",
+      name: "later.txt",
+      content: [],
+    });
+    upload.resolve();
+    await sendPromise;
+
+    expect(thread.messages).toMatchObject([
+      { content: [{ type: "text", text: "hello" }], attachments: [] },
+    ]);
+    expect(composer.attachments.map((attachment) => attachment.id)).toEqual([
+      "later",
+    ]);
+    removal.resolve();
+    await clearPromise;
+  });
+
   it("releases the in-flight lock on reset so a stalled send cannot brick the composer", async () => {
     const adapter = makeAdapter({
       send: () => new Promise(() => {}),