@assistant-ui/core 0.3.19 → 0.3.21

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

@@ -3,7 +3,11 @@ import { BaseComposerRuntimeCore } from "../runtime/base/base-composer-runtime-c
 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 {
+  Attachment,
+  CreateAttachment,
+  PendingAttachment,
+} from "../types/attachment";
 import type { AppendMessage } from "../types/message";
 import type { SendOptions } from "../runtime/interfaces/composer-runtime-core";
 
@@ -29,6 +33,10 @@ class TestComposerCore extends BaseComposerRuntimeCore {
     this._attachmentAdapter = adapter;
   }
 
+  setTestAttachments(attachments: readonly Attachment[]) {
+    this.setAttachments(attachments);
+  }
+
   get canCancel() {
     return false;
   }
@@ -194,7 +202,7 @@ describe("BaseComposerRuntimeCore", () => {
             send: vi.fn(),
             remove,
           });
-          composer.setAttachments([
+          composer.setTestAttachments([
             makePendingAttachment("one"),
             {
               id: "complete",
@@ -437,6 +445,141 @@ describe("BaseComposerRuntimeCore", () => {
     );
   });
 
+  it("rolls back a dictation session when listener setup throws", () => {
+    const setupError = new Error("listener setup failed");
+    const speechCleanup = vi.fn();
+    const session: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: vi.fn(() => speechCleanup),
+      onSpeechStart: vi.fn(() => {
+        throw setupError;
+      }),
+      onSpeechEnd: vi.fn(() => () => {}),
+    };
+    composer.setDictationAdapter({ listen: () => session });
+
+    expect(() => composer.startDictation()).toThrow(setupError);
+
+    expect(session.cancel).toHaveBeenCalledOnce();
+    expect(speechCleanup).toHaveBeenCalledOnce();
+    expect(session.onSpeechEnd).not.toHaveBeenCalled();
+    expect(composer.dictation).toBeUndefined();
+  });
+
+  it("keeps dictation active when the initial subscriber throws", () => {
+    const listenerError = new Error("subscriber failed");
+    const consoleError = vi
+      .spyOn(console, "error")
+      .mockImplementation(() => undefined);
+    onTestFinished(() => consoleError.mockRestore());
+    const session: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: vi.fn(() => () => {}),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+    };
+    composer.setDictationAdapter({ listen: () => session });
+    const unsubscribe = composer.subscribe(() => {
+      throw listenerError;
+    });
+
+    expect(() => composer.startDictation()).not.toThrow();
+
+    expect(composer.dictation).toEqual({
+      status: { type: "running" },
+      inputDisabled: false,
+    });
+    expect(session.onSpeech).toHaveBeenCalledOnce();
+    expect(session.cancel).not.toHaveBeenCalled();
+    expect(consoleError).toHaveBeenCalledWith(
+      "[assistant-ui] Dictation start notification threw",
+      listenerError,
+    );
+    unsubscribe();
+    composer.stopDictation();
+  });
+
+  it("does not wire a session replaced during its initial notification", () => {
+    const firstSession: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: vi.fn(() => () => {}),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+    };
+    const secondSession: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: vi.fn(() => () => {}),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+    };
+    const listen = vi
+      .fn()
+      .mockReturnValueOnce(firstSession)
+      .mockReturnValueOnce(secondSession);
+    composer.setDictationAdapter({ listen });
+    let shouldReplace = true;
+    const unsubscribe = composer.subscribe(() => {
+      if (!shouldReplace) return;
+      shouldReplace = false;
+      composer.startDictation();
+    });
+
+    composer.startDictation();
+
+    expect(firstSession.onSpeech).not.toHaveBeenCalled();
+    expect(firstSession.stop).toHaveBeenCalledOnce();
+    expect(firstSession.cancel).not.toHaveBeenCalled();
+    expect(secondSession.onSpeech).toHaveBeenCalledOnce();
+    expect(composer.dictation).toBeDefined();
+    unsubscribe();
+    composer.stopDictation();
+  });
+
+  it("releases setup handles when registration replaces the session", () => {
+    const firstCleanup = vi.fn();
+    const firstSession: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: vi.fn(() => {
+        composer.startDictation();
+        return firstCleanup;
+      }),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+    };
+    const secondSession: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn().mockResolvedValue(undefined),
+      cancel: vi.fn(),
+      onSpeech: vi.fn(() => () => {}),
+      onSpeechStart: vi.fn(() => () => {}),
+      onSpeechEnd: vi.fn(() => () => {}),
+    };
+    const listen = vi
+      .fn()
+      .mockReturnValueOnce(firstSession)
+      .mockReturnValueOnce(secondSession);
+    composer.setDictationAdapter({ listen });
+
+    composer.startDictation();
+
+    expect(firstCleanup).toHaveBeenCalledOnce();
+    expect(firstSession.onSpeechStart).not.toHaveBeenCalled();
+    expect(firstSession.cancel).not.toHaveBeenCalled();
+    expect(secondSession.onSpeech).toHaveBeenCalledOnce();
+    expect(composer.dictation).toBeDefined();
+    composer.stopDictation();
+  });
+
   it("sends after a dictation unsubscribe throws", async () => {
     const cleanupError = new Error("cleanup failed");
     const cancelError = new Error("cancel failed");
@@ -879,14 +1022,17 @@ describe("BaseComposerRuntimeCore.retractDraft", () => {
 
   it("leaves a changed quote alone", () => {
     const composer = new TestComposerCore();
-    const draft = { text: "returned", quote: { text: "quoted" } };
+    const draft = {
+      text: "returned",
+      quote: { text: "quoted", messageId: "m-1" },
+    };
 
     expect(composer.restoreDraft(draft)).toBe(true);
-    composer.setQuote({ text: "other" });
+    composer.setQuote({ text: "other", messageId: "m-2" });
     composer.retractDraft(draft);
 
     expect(composer.text).toBe("returned");
-    expect(composer.quote).toEqual({ text: "other" });
+    expect(composer.quote).toEqual({ text: "other", messageId: "m-2" });
   });
 
   it("leaves changed attachments alone", () => {
@@ -906,3 +1052,64 @@ describe("BaseComposerRuntimeCore.retractDraft", () => {
     expect(composer.attachments).toHaveLength(1);
   });
 });
+
+describe("BaseComposerRuntimeCore send with a subscriber that restarts dictation", () => {
+  const makeSession = () => {
+    const end = new Set<(result: DictationAdapter.Result) => void>();
+    let listeners = 0;
+    const session: DictationAdapter.Session = {
+      status: { type: "running" },
+      stop: vi.fn(async () => {}),
+      cancel: vi.fn(() => {
+        session.status = { type: "ended", reason: "cancelled" };
+        for (const cb of [...end]) cb({ transcript: "" });
+      }),
+      onSpeechStart: () => {
+        listeners++;
+        return () => listeners--;
+      },
+      onSpeechEnd: (cb) => {
+        end.add(cb);
+        listeners++;
+        return () => {
+          end.delete(cb);
+          listeners--;
+        };
+      },
+      onSpeech: () => {
+        listeners++;
+        return () => listeners--;
+      },
+    };
+    return { session, listeners: () => listeners };
+  };
+
+  it("keeps the session a subscriber starts while send cancels the previous one", async () => {
+    vi.useFakeTimers();
+    onTestFinished(() => {
+      vi.useRealTimers();
+    });
+    const sessions: ReturnType<typeof makeSession>[] = [];
+    const composer = new TestComposerCore();
+    composer.setDictationAdapter({
+      listen: () => {
+        const s = makeSession();
+        sessions.push(s);
+        return s.session;
+      },
+    });
+    composer.subscribe(() => {
+      if (composer.dictation === undefined && sessions.length === 1) {
+        composer.startDictation();
+      }
+    });
+    composer.setText("hello");
+    composer.startDictation();
+    await composer.send();
+
+    expect(sessions).toHaveLength(2);
+    expect(composer.dictation).toBeDefined();
+    expect(sessions[1]!.listeners()).toBe(3);
+    expect(sessions[1]!.session.cancel).not.toHaveBeenCalled();
+  });
+});

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

@@ -1,12 +1,32 @@
 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";
+import type {
+  RuntimeCapabilities,
+  ThreadRuntimeCore,
+} from "../runtime/interfaces/thread-runtime-core";
+import type { ThreadAssistantMessage } from "../types/message";
 
 type ThreadRuntimeStub = Omit<ThreadRuntimeCore, "composer"> & {
   notify: () => void;
 };
 
+const DEFAULT_CAPABILITIES: RuntimeCapabilities = {
+  switchToBranch: false,
+  switchBranchDuringRun: false,
+  edit: false,
+  reload: false,
+  refetchThread: false,
+  delete: false,
+  cancel: true,
+  unstable_copy: false,
+  speech: false,
+  dictation: false,
+  voice: false,
+  attachments: false,
+  feedback: false,
+  queue: false,
+};
+
 const makeRuntimeStub = (
   overrides: Partial<ThreadRuntimeCore> = {},
 ): ThreadRuntimeStub => {
@@ -19,7 +39,7 @@ const makeRuntimeStub = (
       subscribers.add(cb);
       return () => subscribers.delete(cb);
     },
-    capabilities: { cancel: true },
+    capabilities: DEFAULT_CAPABILITIES,
     messages: [],
     isDisabled: false,
     isSendDisabled: false,
@@ -32,11 +52,20 @@ const makeRuntimeStub = (
   } as unknown as ThreadRuntimeStub;
 };
 
-const runningAssistant = {
+const runningAssistant: ThreadAssistantMessage = {
   id: "a1",
   role: "assistant",
   status: { type: "running" },
-} as ThreadMessage;
+  content: [],
+  createdAt: new Date(0),
+  metadata: {
+    unstable_state: null,
+    unstable_annotations: [],
+    unstable_data: [],
+    steps: [],
+    custom: {},
+  },
+};
 
 describe("DefaultThreadComposerRuntimeCore.canCancel", () => {
   it("is false when the runtime is idle even if cancel is supported", () => {
@@ -47,7 +76,7 @@ describe("DefaultThreadComposerRuntimeCore.canCancel", () => {
   it("is false when cancel is not a capability", () => {
     const composer = new DefaultThreadComposerRuntimeCore(
       makeRuntimeStub({
-        capabilities: { cancel: false },
+        capabilities: { ...DEFAULT_CAPABILITIES, cancel: false },
         isRunning: true,
       }),
     );

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

@@ -1,7 +1,12 @@
 import { describe, expect, it, vi } from "vitest";
 import { DefaultThreadComposerRuntimeCore } from "../runtime/base/default-thread-composer-runtime-core";
 import { DefaultEditComposerRuntimeCore } from "../runtime/base/default-edit-composer-runtime-core";
-import type { ThreadRuntimeCore } from "../runtime/interfaces/thread-runtime-core";
+import type {
+  ThreadRuntimeCore,
+  VoiceSessionState,
+} from "../runtime/interfaces/thread-runtime-core";
+import type { AttachmentAdapter } from "../adapters/attachment";
+import type { PendingAttachment } from "../types/attachment";
 import type { ThreadMessage } from "../types/message";
 
 type ThreadRuntimeStub = Omit<ThreadRuntimeCore, "composer"> & {
@@ -76,6 +81,120 @@ describe("DefaultThreadComposerRuntimeCore.canSend", () => {
     expect(onChange).toHaveBeenCalled();
     expect(composer.canSend).toBe(false);
   });
+
+  it("is false while a voice session is connected and true after disconnect", () => {
+    const stub = makeRuntimeStub({
+      voice: {
+        status: { type: "running" },
+        isMuted: false,
+        mode: "listening",
+        canSendText: false,
+      },
+    });
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    composer.setText("hi");
+    const onChange = vi.fn();
+    composer.subscribe(onChange);
+
+    expect(composer.canSend).toBe(false);
+
+    (stub as { voice: undefined }).voice = undefined;
+    stub.notify();
+
+    expect(onChange).toHaveBeenCalled();
+    expect(composer.canSend).toBe(true);
+  });
+
+  it("is true once the connected session takes typed text and notifies on the flip", () => {
+    const stub = makeRuntimeStub({
+      voice: {
+        status: { type: "starting" },
+        isMuted: false,
+        mode: "listening",
+        canSendText: false,
+      },
+    });
+    const composer = new DefaultThreadComposerRuntimeCore(stub);
+    composer.setText("hi");
+    const onChange = vi.fn();
+    composer.subscribe(onChange);
+
+    expect(composer.canSend).toBe(false);
+
+    (stub as { voice: VoiceSessionState }).voice = {
+      status: { type: "running" },
+      isMuted: false,
+      mode: "listening",
+      canSendText: true,
+    };
+    stub.notify();
+
+    expect(onChange).toHaveBeenCalledOnce();
+    expect(composer.canSend).toBe(true);
+  });
+
+  it("is false while the draft role is not user during a session", () => {
+    const composer = new DefaultThreadComposerRuntimeCore(
+      makeRuntimeStub({
+        voice: {
+          status: { type: "running" },
+          isMuted: false,
+          mode: "listening",
+          canSendText: true,
+        },
+      }),
+    );
+    composer.setText("hi");
+    composer.setRole("assistant");
+
+    expect(composer.canSend).toBe(false);
+
+    composer.setRole("user");
+
+    expect(composer.canSend).toBe(true);
+  });
+
+  it("is false while a typed send into a session carries an attachment", async () => {
+    const attachments: AttachmentAdapter = {
+      accept: "*",
+      add: async ({ file }): Promise<PendingAttachment> => ({
+        id: "att-1",
+        type: "document",
+        name: file.name,
+        contentType: file.type,
+        file,
+        status: { type: "requires-action", reason: "composer-send" },
+      }),
+      remove: async () => {},
+      send: async (attachment) => ({
+        ...attachment,
+        status: { type: "complete" },
+        content: [],
+      }),
+    };
+    const stub = makeRuntimeStub({
+      voice: {
+        status: { type: "running" },
+        isMuted: false,
+        mode: "listening",
+        canSendText: true,
+      },
+    });
+    const composer = new DefaultThreadComposerRuntimeCore({
+      ...stub,
+      adapters: { attachments },
+    });
+    composer.setText("hi");
+    await composer.addAttachment(
+      new File(["content"], "f.txt", { type: "text/plain" }),
+    );
+
+    expect(composer.canSend).toBe(false);
+
+    await composer.removeAttachment("att-1");
+
+    expect(composer.canSend).toBe(true);
+  });
 });
 
 describe("BaseComposerRuntimeCore.send", () => {