@assistant-ui/core 0.3.18 → 0.3.20

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

@@ -4,8 +4,13 @@ import {
   hasUpcomingMessage,
 } from "../runtimes/external-store/external-store-thread-runtime-core";
 import type { ExternalStoreAdapter } from "../runtimes/external-store/external-store-adapter";
+import type { RealtimeVoiceAdapter } from "../adapters/voice";
 import type { ModelContextProvider } from "../model-context/types";
-import type { AppendMessage, ThreadMessage } from "../types/message";
+import type {
+  AppendMessage,
+  ThreadAssistantMessage,
+  ThreadMessage,
+} from "../types/message";
 import { createMessageQueue } from "../runtime/queue/message-queue";
 import { getThreadMessageText } from "../utils/text";
 import { invalidateThreadRuntime } from "../runtime/utils/thread-runtime-lifecycle";
@@ -26,21 +31,23 @@ const createUserMessage = (id: string, text = "Hello"): ThreadMessage =>
     },
   }) 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 createAssistantMessage = (
+  id: string,
+  text = "Hi there",
+): ThreadAssistantMessage => ({
+  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: {},
+  },
+});
 
 const createBaseAdapter = (
   overrides: Partial<ExternalStoreAdapter<ThreadMessage>> = {},
@@ -456,6 +463,63 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(lastCall).toEqual([]);
     });
 
+    it.each([
+      { label: "without setMessages", withSetMessages: false, ids: ["u1"] },
+      { label: "with setMessages", withSetMessages: true, ids: [] },
+    ])(
+      "publishes only resolvable messages through the rollback $label",
+      async ({ withSetMessages, ids }) => {
+        const setMessages = vi.fn();
+        const adapter = () =>
+          createBaseAdapter({
+            messages: [createUserMessage("u1", "cancel me")],
+            isRunning: true,
+            onCancel: vi.fn(),
+            ...(withSetMessages && { setMessages }),
+          });
+        const core = new ExternalStoreThreadRuntimeCore(
+          contextProvider,
+          adapter(),
+        );
+        const unresolved = () =>
+          core.messages
+            .filter((m) => !core.getMessageById(m.id))
+            .map((m) => m.id);
+        expect(core.messages).toHaveLength(2);
+
+        core.cancelRun();
+        expect(unresolved()).toEqual([]);
+
+        core.__internal_setAdapter(adapter());
+        expect(unresolved()).toEqual([]);
+
+        await new Promise((resolve) => setTimeout(resolve, 0));
+        expect(unresolved()).toEqual([]);
+        expect(core.messages.map((m) => m.id)).toEqual(ids);
+      },
+    );
+
+    it("keeps the published messages array when cancel rolls nothing back", async () => {
+      const messages = [createUserMessage("u1"), createAssistantMessage("a1")];
+      const adapter = () =>
+        createBaseAdapter({
+          messages: [...messages],
+          isRunning: true,
+          onCancel: vi.fn(),
+        });
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        adapter(),
+      );
+      core.__internal_setAdapter(adapter());
+      const published = core.messages;
+
+      core.cancelRun();
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      expect(core.messages).toBe(published);
+    });
+
     it("evicts an empty optimistic head on cancel", async () => {
       const optimisticAssistant = {
         ...createAssistantMessage("server-msg", ""),
@@ -1117,6 +1181,44 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       ).resolves.toBeUndefined();
     });
 
+    it("emits a decision after an approval callback accepts", async () => {
+      const message: ThreadMessage = {
+        ...createAssistantMessage("assistant-1"),
+        status: { type: "requires-action", reason: "tool-calls" },
+        content: [
+          {
+            type: "tool-call",
+            toolCallId: "tool-1",
+            toolName: "review",
+            args: {},
+            argsText: "{}",
+            approval: { id: "approval-1" },
+          },
+        ],
+      } as ThreadMessage;
+      const core = new ExternalStoreThreadRuntimeCore(
+        contextProvider,
+        createBaseAdapter({
+          messages: [message],
+          onRespondToToolApproval: () => {},
+        }),
+      );
+      const answered = vi.fn();
+      core.unstable_on("toolApprovalAnswered", answered);
+
+      await core.respondToToolApproval({
+        approvalId: "approval-1",
+        approved: true,
+      });
+
+      expect(answered).toHaveBeenCalledWith({
+        messageId: "assistant-1",
+        toolCallId: "tool-1",
+        toolName: "review",
+        approved: true,
+      });
+    });
+
     it("handles rejected onCancel callbacks", async () => {
       const error = new Error("cancel failed");
       const consoleError = vi
@@ -1262,3 +1364,254 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
     });
   });
 });
+
+describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
+  const createVoiceAdapter = () => {
+    let statusCallback:
+      | ((status: RealtimeVoiceAdapter.Status) => void)
+      | undefined;
+    let transcriptCallback:
+      | ((transcript: RealtimeVoiceAdapter.TranscriptItem) => void)
+      | undefined;
+    const session: RealtimeVoiceAdapter.Session = {
+      status: { type: "running" },
+      isMuted: false,
+      disconnect: vi.fn(),
+      mute: vi.fn(),
+      unmute: vi.fn(),
+      onStatusChange: (callback) => {
+        statusCallback = callback;
+        return () => {
+          statusCallback = undefined;
+        };
+      },
+      onTranscript: (callback) => {
+        transcriptCallback = callback;
+        return () => {
+          transcriptCallback = undefined;
+        };
+      },
+      onModeChange: () => () => {},
+      onVolumeChange: () => () => {},
+    };
+    return {
+      adapter: { connect: () => session } satisfies RealtimeVoiceAdapter,
+      emitStatus: (status: RealtimeVoiceAdapter.Status) =>
+        statusCallback?.(status),
+      emitTranscript: (transcript: RealtimeVoiceAdapter.TranscriptItem) =>
+        transcriptCallback?.(transcript),
+    };
+  };
+
+  const createVoiceCore = ({ commit = true }: { commit?: boolean } = {}) => {
+    const voiceAdapter = createVoiceAdapter();
+    const onNew = vi.fn(async () => {});
+    const onEdit = vi.fn(async () => {});
+    const onReload = vi.fn(async () => {});
+    const onResume = vi.fn(async () => {});
+    const onVoiceTranscript = vi.fn();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onNew,
+        onEdit,
+        onReload,
+        onResume,
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+    voiceAdapter.emitTranscript({
+      role: "assistant",
+      text: "Hello",
+      isFinal: true,
+    });
+    const transcript = core.messages[0]!;
+    if (commit) {
+      core.__internal_setAdapter(
+        createBaseAdapter({
+          messages: [transcript],
+          onNew,
+          onEdit,
+          onReload,
+          onResume,
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter },
+        }),
+      );
+      core.disconnectVoice();
+    }
+    return {
+      core,
+      onNew,
+      onEdit,
+      onReload,
+      onResume,
+      transcriptId: transcript.id,
+    };
+  };
+
+  it("hands a final transcript to onVoiceTranscript and drops the side list copy once the host carries it", () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    try {
+      voiceAdapter.emitTranscript({
+        role: "user",
+        text: "Hello",
+        isFinal: true,
+      });
+      const message = core.messages[0]!;
+
+      expect(message.role).toBe("user");
+      expect(getThreadMessageText(message)).toBe("Hello");
+      expect(message.metadata.modality).toBe("voice");
+
+      expect(onVoiceTranscript).toHaveBeenCalledExactlyOnceWith(message);
+
+      core.__internal_setAdapter(
+        createBaseAdapter({
+          messages: [message],
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter },
+        }),
+      );
+
+      expect(core.messages.filter(({ id }) => id === message.id)).toEqual([
+        message,
+      ]);
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("keeps transcripts for the session when the host has no onVoiceTranscript", () => {
+    const voiceAdapter = createVoiceAdapter();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({ adapters: { voice: voiceAdapter.adapter } }),
+    );
+    core.connectVoice();
+
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+
+    expect(core.messages).toHaveLength(1);
+
+    core.disconnectVoice();
+
+    expect(core.messages).toEqual([]);
+  });
+
+  it("parents a send after the session ended on the last repository message", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onNew = vi.fn(async () => {});
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onNew,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    try {
+      voiceAdapter.emitTranscript({
+        role: "user",
+        text: "Hello",
+        isFinal: true,
+      });
+      const transcript = core.messages[0]!;
+      voiceAdapter.emitStatus({ type: "ended", reason: "finished" });
+
+      await core.append({
+        parentId: transcript.id,
+        sourceId: null,
+        role: "user",
+        content: [{ type: "text", text: "Follow up" }],
+        attachments: [],
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        runConfig: {},
+        startRun: false,
+      });
+
+      expect(onNew).toHaveBeenCalledExactlyOnceWith(
+        expect.objectContaining({ parentId: null }),
+      );
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("rejects a text send while connected before reaching the store", async () => {
+    const { core, onNew, onEdit, transcriptId } = createVoiceCore({
+      commit: false,
+    });
+    try {
+      const edit: AppendMessage = {
+        parentId: null,
+        sourceId: transcriptId,
+        role: "user",
+        content: [{ type: "text", text: "again" }],
+        attachments: [],
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        runConfig: {},
+      };
+
+      await expect(core.append(edit)).rejects.toThrow(
+        "Cannot send a text message while a voice session is connected",
+      );
+      await expect(core.append({ ...edit, startRun: false })).rejects.toThrow(
+        "Cannot send a text message while a voice session is connected",
+      );
+      expect(onNew).not.toHaveBeenCalled();
+      expect(onEdit).not.toHaveBeenCalled();
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("rejects a run while connected before reaching the store", async () => {
+    const { core, onReload, onResume, transcriptId } = createVoiceCore({
+      commit: false,
+    });
+    try {
+      await expect(
+        core.startRun({
+          parentId: null,
+          sourceId: transcriptId,
+          runConfig: {},
+        }),
+      ).rejects.toThrow(
+        "Cannot start a run while a voice session is connected",
+      );
+      await expect(
+        core.resumeRun({
+          parentId: null,
+          sourceId: transcriptId,
+          runConfig: {},
+        }),
+      ).rejects.toThrow(
+        "Cannot start a run while a voice session is connected",
+      );
+      expect(onReload).not.toHaveBeenCalled();
+      expect(onResume).not.toHaveBeenCalled();
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+});

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

@@ -1282,6 +1282,37 @@ describe("ExternalStoreThreadRuntimeCore - deleteMessage via setMessages", () =>
     }
   });
 
+  it("notifies the eviction when the host resyncs synchronously", async () => {
+    let current = [
+      message("u1", "user", "one"),
+      message("a1", "assistant", "two"),
+      message("u2", "user", "three"),
+      message("a2", "assistant", "four"),
+    ];
+    const store = (): ExternalStoreAdapter =>
+      makeStore({
+        messages: current,
+        setMessages: (m: import("../types/message").ThreadMessage[]) => {
+          current = m;
+          runtime.__internal_setAdapter(store());
+        },
+      });
+    const runtime = new ExternalStoreThreadRuntimeCore(
+      mockContextProvider,
+      store(),
+    );
+
+    const observed: (readonly string[])[] = [];
+    runtime.subscribe(() => {
+      observed.push(runtime.getBranches("a2"));
+    });
+
+    await runtime.deleteMessage("u2");
+
+    expect(runtime.messages.map((m) => m.id)).toEqual(["u1", "a1", "a2"]);
+    expect(observed.at(-1)).toEqual(["a2"]);
+  });
+
   it("evicts the deleted message on the onDelete path too", async () => {
     let current = [
       message("u1", "user", "hi"),

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

@@ -76,6 +76,75 @@ const renderThread = () => {
 };
 
 describe("ExternalThread attachments", () => {
+  describe.each(["clearAttachments", "reset"] as const)(
+    "%s cleanup",
+    (method) => {
+      it.each(["first throw", "later throw", "rejection", "multiple failures"])(
+        "attempts all pending removals after %s and still rejects",
+        async (failure) => {
+          const error = new Error("removal failed");
+          const remove = vi.fn((attachment: PendingAttachment) => {
+            const fails =
+              attachment.id === (failure === "later throw" ? "two" : "one");
+            if (fails) {
+              if (failure === "rejection") return Promise.reject(error);
+              throw error;
+            }
+            if (failure === "multiple failures" && attachment.id === "two") {
+              return Promise.reject(new Error("another failure"));
+            }
+            return Promise.resolve();
+          });
+          const aui = renderThreadWithProps({
+            attachmentAdapter: {
+              accept: "*",
+              add: async ({ file }) => ({
+                id: file.name,
+                type: "file",
+                name: file.name,
+                contentType: "text/plain",
+                file,
+                status: { type: "requires-action", reason: "composer-send" },
+              }),
+              send: vi.fn(),
+              remove,
+            },
+          });
+          const composer = () => aui().thread().composer();
+          await act(async () => {
+            await composer().addAttachment(
+              new File(["data"], "one", { type: "text/plain" }),
+            );
+            await composer().addAttachment({
+              id: "complete",
+              name: "saved.txt",
+              contentType: "text/plain",
+              content: [],
+            });
+            await composer().addAttachment(
+              new File(["data"], "two", { type: "text/plain" }),
+            );
+            await composer().addAttachment(
+              new File(["data"], "three", { type: "text/plain" }),
+            );
+          });
+          await waitFor(() =>
+            expect(composer().getState().attachments).toHaveLength(4),
+          );
+
+          await act(async () => {
+            await expect(composer()[method]()).rejects.toBe(error);
+          });
+
+          expect(
+            remove.mock.calls.map(([attachment]) => attachment.id),
+          ).toEqual(["one", "two", "three"]);
+          expect(composer().getState().attachments).toEqual([]);
+        },
+      );
+    },
+  );
+
   it("uses generated IDs unless a prepared attachment supplies one", async () => {
     const aui = renderThread();
     mockGenerateId
@@ -174,12 +243,12 @@ describe("ExternalThread attachments", () => {
 
   it("preserves foreign files that expose content", async () => {
     const aui = renderThread();
-    const foreignFile = {
-      name: "photo.png",
-      type: "image/png",
-      lastModified: 0,
-      content: [{ type: "text", text: "implementation detail" }],
-    } as File;
+    const foreignFile = Object.assign(
+      new File([""], "photo.png", { type: "image/png" }),
+      {
+        content: [{ type: "text", text: "implementation detail" }],
+      },
+    );
 
     await act(() => aui().thread.composer().addAttachment(foreignFile));
 
@@ -306,7 +375,7 @@ describe("ExternalThread attachments", () => {
 
   it("preserves composer state while attachments are prepared for send", async () => {
     let resolveSend!: (attachment: CompleteAttachment) => void;
-    const onNew = vi.fn();
+    const onNew = vi.fn<NonNullable<ExternalThreadProps["onNew"]>>();
     const file = new File(["data"], "notes.txt", { type: "text/plain" });
     const adapter = {
       accept: "*",
@@ -334,10 +403,10 @@ describe("ExternalThread attachments", () => {
     act(() => {
       composer().setText("first message");
       composer().setRole("assistant");
-      composer().setRunConfig({ model: "model-a" });
+      composer().setRunConfig({ custom: { model: "model-a" } });
       composer().send();
       composer().setRole("system");
-      composer().setRunConfig({ model: "model-b" });
+      composer().setRunConfig({ custom: { model: "model-b" } });
     });
     await act(async () => {
       resolveSend({
@@ -353,7 +422,7 @@ describe("ExternalThread attachments", () => {
     await waitFor(() => expect(onNew).toHaveBeenCalledTimes(1));
     expect(onNew.mock.calls[0]![0]).toMatchObject({
       role: "assistant",
-      runConfig: { model: "model-a" },
+      runConfig: { custom: { model: "model-a" } },
     });
   });
 
@@ -862,8 +931,8 @@ describe("cancelled edit sessions", () => {
         name: "notes.txt",
         contentType: "text/plain",
         file: new File(["data"], "notes.txt", { type: "text/plain" }),
-        status: { type: "pending", reason: "uploading", progress: 0 },
-      } as PendingAttachment);
+        status: { type: "running", reason: "uploading", progress: 0 },
+      });
       await addPromise.catch(() => {});
     });
 
@@ -895,15 +964,14 @@ describe("cancelled edit sessions", () => {
       onEdit: () => {},
       attachmentAdapter: {
         accept: "*",
-        add: async ({ file }: { file: File }) =>
-          ({
-            id: "pending-1",
-            type: "document",
-            name: file.name,
-            contentType: file.type,
-            file,
-            status: { type: "pending", reason: "uploading", progress: 0 },
-          }) as PendingAttachment,
+        add: async ({ file }: { file: File }) => ({
+          id: "pending-1",
+          type: "document",
+          name: file.name,
+          contentType: file.type,
+          file,
+          status: { type: "running", reason: "uploading", progress: 0 },
+        }),
         send: async () => ({}) as never,
         remove,
       },
@@ -968,8 +1036,8 @@ describe("cancelled edit sessions", () => {
         name: "notes.txt",
         contentType: "text/plain",
         file: new File(["data"], "notes.txt", { type: "text/plain" }),
-        status: { type: "pending", reason: "uploading", progress: 0 },
-      } as PendingAttachment);
+        status: { type: "running", reason: "uploading", progress: 0 },
+      });
       await addPromise;
     });
 

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

@@ -78,11 +78,19 @@ describe("ExternalThread feedback", () => {
     expect(withAdapter().thread.getState().capabilities.feedback).toBe(true);
   });
 
-  it("throws on submitFeedback when no adapter is configured", () => {
+  it("marks assistant feedback locally without an adapter", async () => {
     const { aui } = renderThreadWithProps({});
-    expect(() =>
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" }),
-    ).toThrow("Feedback adapter not configured");
+
+    await act(async () => {
+      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+    });
+
+    await waitFor(() => {
+      expect(
+        aui().thread.message({ id: "a1" }).getState().metadata
+          .submittedFeedback,
+      ).toEqual({ type: "positive" });
+    });
   });
 
   it("submits feedback to the adapter and marks the assistant message", async () => {
@@ -90,23 +98,28 @@ describe("ExternalThread feedback", () => {
     const { aui } = renderThreadWithProps({ feedbackAdapter: adapter });
 
     await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "positive" });
+      aui()
+        .thread.message({ id: "a1" })
+        .submitFeedback({ type: "positive", comment: "Helpful summary" });
     });
 
     expect(submit).toHaveBeenCalledTimes(1);
     expect(submit).toHaveBeenCalledWith({
       message: MESSAGES[1],
       type: "positive",
+      comment: "Helpful summary",
     });
     await waitFor(() => {
       expect(
         aui().thread.message({ id: "a1" }).getState().metadata
           .submittedFeedback,
-      ).toEqual({ type: "positive" });
+      ).toEqual({ type: "positive", comment: "Helpful summary" });
     });
 
     await act(async () => {
-      aui().thread.message({ id: "a1" }).submitFeedback({ type: "negative" });
+      aui()
+        .thread.message({ id: "a1" })
+        .submitFeedback({ type: "negative", comment: "   " });
     });
 
     expect(submit).toHaveBeenLastCalledWith({