@assistant-ui/core 0.3.18 → 0.3.19

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

@@ -1,7 +1,8 @@
-import { describe, it, expect, vi, beforeEach } from "vitest";
+import { beforeEach, describe, expect, it, onTestFinished, vi } from "vitest";
 import { BaseComposerRuntimeCore } from "../runtime/base/base-composer-runtime-core";
 import type { AttachmentAdapter } from "../adapters/attachment";
 import type { DictationAdapter } from "../adapters/speech";
+import { WebSpeechDictationAdapter } from "../adapters/speech";
 import type { CreateAttachment, PendingAttachment } from "../types/attachment";
 import type { AppendMessage } from "../types/message";
 import type { SendOptions } from "../runtime/interfaces/composer-runtime-core";
@@ -75,6 +76,71 @@ describe("BaseComposerRuntimeCore", () => {
     expect(listener).not.toHaveBeenCalled();
   });
 
+  it.each(["", "Existing text"])(
+    "replaces the complete browser dictation preview after %j",
+    async (baseText) => {
+      vi.useFakeTimers();
+      onTestFinished(() => {
+        vi.unstubAllGlobals();
+        vi.useRealTimers();
+      });
+      const listeners = new Map<string, EventListener>();
+      class Recognition {
+        addEventListener(type: string, listener: EventListener) {
+          listeners.set(type, listener);
+        }
+        start() {}
+        stop() {
+          listeners.get("end")!(new Event("end"));
+        }
+        abort() {
+          this.stop();
+        }
+      }
+      vi.stubGlobal("window", { SpeechRecognition: Recognition });
+      composer.setDictationAdapter(new WebSpeechDictationAdapter());
+      composer.setText(baseText);
+      composer.startDictation();
+      onTestFinished(() => composer.stopDictation());
+      const emit = (results: [string, boolean][], resultIndex = 0) => {
+        listeners.get("result")!({
+          resultIndex,
+          results: results.map(([transcript, isFinal]) => ({
+            0: { transcript },
+            isFinal,
+          })),
+        } as unknown as Event);
+      };
+      const prefix = baseText ? `${baseText} ` : "";
+
+      emit([
+        ["hello ", false],
+        ["world", false],
+      ]);
+      expect(composer.text).toBe(`${prefix}hello world`);
+      emit([["hello ", false]], 1);
+      expect(composer.text).toBe(`${prefix}hello `);
+      emit([]);
+      expect(composer.text).toBe(baseText);
+      emit([
+        ["hello ", true],
+        ["world", false],
+      ]);
+      expect(composer.text).toBe(`${prefix}hello world`);
+      emit(
+        [
+          ["hello ", true],
+          ["world", true],
+        ],
+        1,
+      );
+      expect(composer.text).toBe(`${prefix}hello world`);
+      expect(composer.dictation?.transcript).toBeUndefined();
+      composer.stopDictation();
+      await Promise.resolve();
+    },
+  );
+
   it("isEmpty returns true for whitespace-only text", () => {
     composer.setText("   ");
     expect(composer.isEmpty).toBe(true);
@@ -103,6 +169,56 @@ describe("BaseComposerRuntimeCore", () => {
     expect(listener).not.toHaveBeenCalled();
   });
 
+  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();
+          });
+          composer.setAttachmentAdapter({
+            accept: "*",
+            add: vi.fn(),
+            send: vi.fn(),
+            remove,
+          });
+          composer.setAttachments([
+            makePendingAttachment("one"),
+            {
+              id: "complete",
+              type: "file",
+              name: "saved.txt",
+              contentType: "text/plain",
+              content: [],
+              status: { type: "complete" },
+            },
+            makePendingAttachment("two"),
+            makePendingAttachment("three"),
+          ]);
+
+          await expect(composer[method]()).rejects.toBe(error);
+
+          expect(
+            remove.mock.calls.map(([attachment]) => attachment.id),
+          ).toEqual(["one", "two", "three"]);
+          expect(composer.attachments).toEqual([]);
+        },
+      );
+    },
+  );
+
   it("reset keeps discarded text out of later dictation results", async () => {
     let emitSpeech!: (result: DictationAdapter.Result) => void;
     composer.setDictationAdapter({
@@ -226,9 +342,14 @@ describe("BaseComposerRuntimeCore", () => {
   });
 
   it("handles rejected dictation shutdowns", async () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+    const stopError = new Error("shutdown failed");
     const session: DictationAdapter.Session = {
       status: { type: "running" },
-      stop: vi.fn().mockRejectedValue(new Error("shutdown failed")),
+      stop: vi.fn().mockRejectedValue(stopError),
       cancel: vi.fn(),
       onSpeechStart: vi.fn(() => () => {}),
       onSpeechEnd: vi.fn(() => () => {}),
@@ -248,11 +369,202 @@ describe("BaseComposerRuntimeCore", () => {
       expect(session.stop).toHaveBeenCalledOnce();
       expect(composer.dictation).toBeUndefined();
       expect(unhandledRejection).not.toHaveBeenCalled();
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] Dictation session stop rejected",
+        stopError,
+      );
     } finally {
       process.off("unhandledRejection", unhandledRejection);
     }
   });
 
+  it("handles synchronously throwing dictation shutdowns", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+    const stopError = new Error("shutdown failed");
+    const session: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn(() => {
+        throw stopError;
+      }),
+      cancel: vi.fn(),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+      onSpeech: vi.fn(() => () => {}),
+    };
+    composer.setDictationAdapter({ listen: () => session });
+    composer.startDictation();
+
+    expect(() => composer.stopDictation()).not.toThrow();
+
+    expect(composer.dictation).toBeUndefined();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Dictation session stop threw",
+      stopError,
+    );
+  });
+
+  it("finishes dictation cleanup when an unsubscribe throws", async () => {
+    const cleanupError = new Error("cleanup failed");
+    const laterCleanup = vi.fn();
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+    const session: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: vi.fn(() => () => {
+        throw cleanupError;
+      }),
+      onSpeechStart: vi.fn(() => laterCleanup),
+      onSpeechEnd: vi.fn(() => () => {}),
+    };
+    composer.setDictationAdapter({ listen: () => session });
+
+    composer.startDictation();
+    composer.stopDictation();
+    await new Promise((resolve) => setTimeout(resolve, 0));
+
+    expect(laterCleanup).toHaveBeenCalledOnce();
+    expect(composer.dictation).toBeUndefined();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Dictation cleanup threw",
+      cleanupError,
+    );
+  });
+
+  it("sends after a dictation unsubscribe throws", async () => {
+    const cleanupError = new Error("cleanup failed");
+    const cancelError = new Error("cancel failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+    composer.setDictationAdapter({
+      listen: () => ({
+        status: { type: "running" },
+        stop: vi.fn().mockResolvedValue(undefined),
+        cancel: vi.fn(() => {
+          throw cancelError;
+        }),
+        onSpeech: () => () => {
+          throw cleanupError;
+        },
+        onSpeechStart: () => () => {},
+        onSpeechEnd: () => () => {},
+      }),
+    });
+    composer.setText("send me");
+    composer.startDictation();
+
+    await composer.send();
+
+    expect(composer.sentMessages).toHaveLength(1);
+    expect(composer.sentMessages[0]?.content).toEqual([
+      { type: "text", text: "send me" },
+    ]);
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Dictation session cancel threw",
+      cancelError,
+    );
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Dictation cleanup threw",
+      cleanupError,
+    );
+  });
+
+  it("starts replacement dictation when the old session stop throws", () => {
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => {});
+    onTestFinished(() => consoleError.mockRestore());
+    const stopError = new Error("shutdown failed");
+    const firstSession: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn(() => {
+        throw stopError;
+      }),
+      cancel: vi.fn(),
+      onSpeech: () => () => {},
+      onSpeechStart: () => () => {},
+      onSpeechEnd: () => () => {},
+    };
+    const secondSession: DictationAdapter.Session = {
+      ...firstSession,
+      stop: vi.fn().mockResolvedValue(undefined),
+    };
+    const listen = vi
+      .fn()
+      .mockReturnValueOnce(firstSession)
+      .mockReturnValueOnce(secondSession);
+    composer.setDictationAdapter({ listen });
+    composer.startDictation();
+
+    expect(() => composer.startDictation()).not.toThrow();
+
+    expect(listen).toHaveBeenCalledTimes(2);
+    expect(composer.dictation).toBeDefined();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Dictation session stop threw",
+      stopError,
+    );
+    composer.stopDictation();
+  });
+
+  it("publishes cleared state when replacement session creation throws", () => {
+    const listenError = new Error("listen failed");
+    const firstSession: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: () => () => {},
+      onSpeechStart: () => () => {},
+      onSpeechEnd: () => () => {},
+    };
+    const listen = vi
+      .fn()
+      .mockReturnValueOnce(firstSession)
+      .mockImplementationOnce(() => {
+        throw listenError;
+      });
+    composer.setDictationAdapter({ listen });
+    const states: Array<string | undefined> = [];
+    composer.subscribe(() => states.push(composer.dictation?.status.type));
+    composer.startDictation();
+    states.length = 0;
+
+    expect(() => composer.startDictation()).toThrow(listenError);
+
+    expect(composer.dictation).toBeUndefined();
+    expect(states).toEqual([undefined]);
+  });
+
+  it("replaces dictation without publishing an intermediate cleared state", async () => {
+    const session = (): DictationAdapter.Session => ({
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: () => () => {},
+      onSpeechStart: () => () => {},
+      onSpeechEnd: () => () => {},
+    });
+    composer.setDictationAdapter({ listen: session });
+    const states: Array<string | undefined> = [];
+    composer.subscribe(() => states.push(composer.dictation?.status.type));
+    composer.startDictation();
+    states.length = 0;
+
+    composer.startDictation();
+
+    expect(states).toEqual(["running"]);
+    composer.stopDictation();
+    await Promise.resolve();
+  });
+
   describe("CreateAttachment (external source)", () => {
     const makeCreateAttachment = (
       overrides?: Partial<CreateAttachment>,

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

@@ -4,6 +4,7 @@ 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 { createMessageQueue } from "../runtime/queue/message-queue";
@@ -1117,6 +1118,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 +1301,115 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
     });
   });
 });
+
+describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
+  const createVoiceAdapter = () => {
+    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: () => () => {},
+      onTranscript: (callback) => {
+        transcriptCallback = callback;
+        return () => {
+          transcriptCallback = undefined;
+        };
+      },
+      onModeChange: () => () => {},
+      onVolumeChange: () => () => {},
+    };
+    return {
+      adapter: { connect: () => session } satisfies RealtimeVoiceAdapter,
+      emitTranscript: (transcript: RealtimeVoiceAdapter.TranscriptItem) =>
+        transcriptCallback?.(transcript),
+    };
+  };
+
+  const createVoiceCore = () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onNew = vi.fn(async () => {});
+    const onEdit = vi.fn(async () => {});
+    const onReload = vi.fn(async () => {});
+    const onResume = vi.fn(async () => {});
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onNew,
+        onEdit,
+        onReload,
+        onResume,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+    voiceAdapter.emitTranscript({
+      role: "assistant",
+      text: "Hello",
+      isFinal: true,
+    });
+    return {
+      core,
+      onNew,
+      onEdit,
+      onReload,
+      onResume,
+      transcriptId: core.messages[0]!.id,
+    };
+  };
+
+  it("rejects an edit resubmission of a transcript before reaching the store", async () => {
+    const { core, onNew, onEdit, transcriptId } = createVoiceCore();
+    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(
+        "Voice transcript messages cannot be edited",
+      );
+      await expect(core.append({ ...edit, startRun: false })).rejects.toThrow(
+        "Voice transcript messages cannot be edited",
+      );
+      expect(onNew).not.toHaveBeenCalled();
+      expect(onEdit).not.toHaveBeenCalled();
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("rejects reloading a transcript before reaching the store", async () => {
+    const { core, onReload, onResume, transcriptId } = createVoiceCore();
+    try {
+      await expect(
+        core.startRun({
+          parentId: null,
+          sourceId: transcriptId,
+          runConfig: {},
+        }),
+      ).rejects.toThrow("Voice transcript messages cannot be reloaded");
+      await expect(
+        core.resumeRun({
+          parentId: null,
+          sourceId: transcriptId,
+          runConfig: {},
+        }),
+      ).rejects.toThrow("Voice transcript messages cannot be reloaded");
+      expect(onReload).not.toHaveBeenCalled();
+      expect(onResume).not.toHaveBeenCalled();
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+});

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

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

@@ -203,6 +203,40 @@ describe("ExternalThread part status", () => {
   });
 });
 
+describe("ExternalThread tasks", () => {
+  it("derives nested conversations and resolves their task scope", () => {
+    const { aui } = renderThread({
+      messages: [
+        assistantMessageWithContent({ type: "running" }, [
+          {
+            type: "tool-call",
+            toolCallId: "delegate-1",
+            toolName: "delegate",
+            args: {},
+            argsText: "{}",
+            messages: [
+              assistantMessageWithContent(
+                { type: "running" },
+                [],
+                "nested-message-1",
+              ),
+            ],
+          },
+        ]),
+      ],
+      isRunning: true,
+    });
+
+    const [task] = aui().thread.getState().tasks;
+    expect(task).toMatchObject({
+      id: "delegate-1",
+      toolName: "delegate",
+      messageId: "a1",
+    });
+    expect(aui().thread.task({ id: "delegate-1" }).getState()).toBe(task);
+  });
+});
+
 describe("ExternalThread unset optional callbacks", () => {
   it("throws a capability error when the callback prop is not set", () => {
     const { aui } = renderThread({