@assistant-ui/core 0.3.20 → 0.3.21

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

@@ -3,6 +3,7 @@ import {
   ExternalStoreThreadRuntimeCore,
   hasUpcomingMessage,
 } from "../runtimes/external-store/external-store-thread-runtime-core";
+import { ExternalStoreRuntimeCore } from "../runtimes/external-store/external-store-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";
@@ -14,6 +15,7 @@ import type {
 import { createMessageQueue } from "../runtime/queue/message-queue";
 import { getThreadMessageText } from "../utils/text";
 import { invalidateThreadRuntime } from "../runtime/utils/thread-runtime-lifecycle";
+import { MessageRepository } from "../runtime/utils/message-repository";
 
 const createContextProvider = (): ModelContextProvider => ({
   getModelContext: () => ({}),
@@ -937,6 +939,63 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
       expect(onUpdate).toHaveBeenCalled();
     });
 
+    it("stops running once a human-input request from streamCall is resumed", async () => {
+      const setToolStatuses = vi.fn();
+      const adapter = (messages: ThreadMessage[]) =>
+        createBaseAdapter({
+          unstable_enableToolInvocations: true,
+          isRunning: false,
+          setToolStatuses,
+          messages,
+        });
+      const core = new ExternalStoreThreadRuntimeCore(
+        {
+          getModelContext: () => ({
+            tools: {
+              confirm: {
+                parameters: { type: "object", properties: {} },
+                streamCall: async (_reader, { human }) => {
+                  await human({ request: "confirm" });
+                },
+              },
+            },
+          }),
+        },
+        adapter([]),
+      );
+
+      core.__internal_setAdapter(
+        adapter([
+          {
+            ...createAssistantMessage("a1"),
+            status: { type: "requires-action", reason: "tool-calls" },
+            content: [
+              {
+                type: "tool-call",
+                toolCallId: "tc1",
+                toolName: "confirm",
+                args: {},
+                argsText: "{}",
+              },
+            ],
+          },
+        ]),
+      );
+      await vi.waitFor(() =>
+        expect(setToolStatuses).toHaveBeenLastCalledWith({
+          tc1: {
+            type: "interrupt",
+            payload: { type: "human", payload: { request: "confirm" } },
+          },
+        }),
+      );
+
+      core.resumeToolCall({ toolCallId: "tc1", payload: true });
+
+      expect(setToolStatuses).toHaveBeenLastCalledWith({});
+      expect(core.isRunning).toBe(false);
+    });
+
     it("mirrors the adapter running value when tool invocations are disabled", () => {
       const core = new ExternalStoreThreadRuntimeCore(
         contextProvider,
@@ -1366,7 +1425,9 @@ describe("ExternalStoreThreadRuntimeCore adapter contract", () => {
 });
 
 describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
-  const createVoiceAdapter = () => {
+  const createVoiceAdapter = ({
+    sendText,
+  }: { sendText?: RealtimeVoiceAdapter.Session["sendText"] } = {}) => {
     let statusCallback:
       | ((status: RealtimeVoiceAdapter.Status) => void)
       | undefined;
@@ -1379,6 +1440,7 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
       disconnect: vi.fn(),
       mute: vi.fn(),
       unmute: vi.fn(),
+      ...(sendText && { sendText }),
       onStatusChange: (callback) => {
         statusCallback = callback;
         return () => {
@@ -1452,6 +1514,423 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
     };
   };
 
+  it("waits for a host import already in progress before committing a final transcript", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const adapters = { voice: voiceAdapter.adapter };
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        isLoading: true,
+        onVoiceTranscript,
+        adapters,
+      }),
+    );
+
+    core.connectVoice();
+    expect(core.voice).toBeDefined();
+
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+    await Promise.resolve();
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+
+    core.__internal_setAdapter(
+      createBaseAdapter({
+        isLoading: false,
+        onVoiceTranscript,
+        adapters,
+      }),
+    );
+    await vi.waitFor(() => {
+      expect(onVoiceTranscript).toHaveBeenCalledOnce();
+    });
+
+    core.disconnectVoice();
+  });
+
+  it("keeps holding a final transcript when one load ends and the next begins in the same tick", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const render = (isLoading: boolean) =>
+      createBaseAdapter({
+        isLoading,
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      });
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      render(true),
+    );
+    core.connectVoice();
+
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+    core.__internal_setAdapter(render(false));
+    core.__internal_setAdapter(render(true));
+    await Promise.resolve();
+    await Promise.resolve();
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+
+    core.__internal_setAdapter(render(false));
+    await vi.waitFor(() => {
+      expect(onVoiceTranscript).toHaveBeenCalledOnce();
+    });
+
+    core.disconnectVoice();
+  });
+
+  it("waits for a host import started after connection before committing a final transcript", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const historyMessage = createUserMessage("history");
+    const voiceAdapterOptions = {
+      onVoiceTranscript,
+      adapters: { voice: voiceAdapter.adapter },
+    };
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter(voiceAdapterOptions),
+    );
+    core.connectVoice();
+
+    core.__internal_setAdapter(
+      createBaseAdapter({
+        ...voiceAdapterOptions,
+        isLoading: true,
+        messages: [historyMessage],
+      }),
+    );
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+    await Promise.resolve();
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+
+    core.__internal_setAdapter(
+      createBaseAdapter({
+        ...voiceAdapterOptions,
+        isLoading: false,
+        messages: [historyMessage],
+      }),
+    );
+    await vi.waitFor(() => {
+      expect(onVoiceTranscript).toHaveBeenCalledOnce();
+    });
+
+    core.disconnectVoice();
+  });
+
+  it("waits for a host import started after connection before committing a typed turn", async () => {
+    const sendText = vi.fn(async () => {});
+    const voiceAdapter = createVoiceAdapter({ sendText });
+    const onVoiceTranscript = vi.fn();
+    const voiceAdapterOptions = {
+      onVoiceTranscript,
+      adapters: { voice: voiceAdapter.adapter },
+    };
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter(voiceAdapterOptions),
+    );
+    core.connectVoice();
+    core.__internal_setAdapter(
+      createBaseAdapter({
+        ...voiceAdapterOptions,
+        isLoading: true,
+      }),
+    );
+
+    let settled = false;
+    const append = core.append({
+      parentId: null,
+      sourceId: null,
+      role: "user",
+      content: [{ type: "text", text: "Typed" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(),
+      runConfig: {},
+    });
+    void append.finally(() => {
+      settled = true;
+    });
+    await vi.waitFor(() => {
+      expect(sendText).toHaveBeenCalledExactlyOnceWith("Typed");
+    });
+    expect(settled).toBe(false);
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+
+    core.__internal_setAdapter(
+      createBaseAdapter({
+        ...voiceAdapterOptions,
+        isLoading: false,
+      }),
+    );
+    await append;
+
+    expect(onVoiceTranscript).toHaveBeenCalledWith(
+      expect.objectContaining({ role: "user" }),
+    );
+
+    core.disconnectVoice();
+  });
+
+  it("delivers a deferred transcript to the callback the host renders once loading ends", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const loadingVoiceTranscript = vi.fn();
+    const loadedVoiceTranscript = vi.fn();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        isLoading: true,
+        onVoiceTranscript: loadingVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+    core.__internal_setAdapter(
+      createBaseAdapter({
+        isLoading: false,
+        onVoiceTranscript: loadedVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    await vi.waitFor(() => {
+      expect(loadedVoiceTranscript).toHaveBeenCalledOnce();
+    });
+    expect(loadedVoiceTranscript).toHaveBeenCalledWith(
+      expect.objectContaining({
+        role: "user",
+        content: [{ type: "text", text: "Hello" }],
+      }),
+    );
+    expect(loadingVoiceTranscript).not.toHaveBeenCalled();
+
+    core.disconnectVoice();
+  });
+
+  it("drops a deferred transcript when the host routes another conversation through one runtime", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        isLoading: true,
+        onVoiceTranscript,
+        unstable_messageRepositoryInstance: new MessageRepository(),
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+    core.__internal_setAdapter(
+      createBaseAdapter({
+        isLoading: false,
+        onVoiceTranscript,
+        unstable_messageRepositoryInstance: new MessageRepository(),
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    await Promise.resolve();
+    await Promise.resolve();
+
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+    expect(core.messages).toHaveLength(0);
+
+    core.disconnectVoice();
+  });
+
+  it("drops a deferred transcript on the runtime the host switched away from", async () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const render = (threadId: string, isLoading: boolean) =>
+      createBaseAdapter({
+        isLoading,
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter, threadList: { threadId } },
+      });
+    const runtime = new ExternalStoreRuntimeCore(render("thread-1", true));
+    const thread = runtime.threads.getMainThreadRuntimeCore();
+    thread.connectVoice();
+
+    voiceAdapter.emitTranscript({
+      role: "user",
+      text: "Hello",
+      isFinal: true,
+    });
+    runtime.setAdapter(render("thread-2", false));
+
+    await vi.waitFor(() => {
+      expect(thread.messages).toEqual([]);
+    });
+    expect(runtime.threads.getMainThreadRuntimeCore()).not.toBe(thread);
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+    expect(runtime.threads.getMainThreadRuntimeCore().messages).toHaveLength(0);
+    // Loading never ends on the superseded runtime, so the invalidation alone
+    // ended the wait.
+    expect(thread.isLoading).toBe(true);
+
+    thread.disconnectVoice();
+  });
+
+  it("resolves a typed turn deferred on the runtime the host switched away from", async () => {
+    const sendText = vi.fn(async (_text: string) => {});
+    const voiceAdapter = createVoiceAdapter({ sendText });
+    const onVoiceTranscript = vi.fn();
+    const render = (threadId: string, isLoading: boolean) =>
+      createBaseAdapter({
+        isLoading,
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter, threadList: { threadId } },
+      });
+    const runtime = new ExternalStoreRuntimeCore(render("thread-1", true));
+    const thread = runtime.threads.getMainThreadRuntimeCore();
+    thread.connectVoice();
+
+    const append = thread.append({
+      parentId: null,
+      sourceId: null,
+      role: "user",
+      content: [{ type: "text", text: "Typed" }],
+      attachments: [],
+      metadata: { custom: {} },
+      createdAt: new Date(),
+      runConfig: {},
+    });
+    await vi.waitFor(() => {
+      expect(thread.messages).toHaveLength(1);
+    });
+    runtime.setAdapter(render("thread-2", false));
+
+    await expect(append).resolves.toBeUndefined();
+    expect(sendText).toHaveBeenCalledExactlyOnceWith("Typed");
+    expect(onVoiceTranscript).not.toHaveBeenCalled();
+    expect(thread.messages).toEqual([]);
+
+    thread.disconnectVoice();
+  });
+
+  it.each([
+    { isLoading: true, state: "loading" },
+    { isLoading: false, state: "loaded" },
+  ])(
+    "drops a typed turn still sending when the host switches away from a $state thread",
+    async ({ isLoading }) => {
+      let finishSend!: () => void;
+      const sendText = vi.fn(
+        (_text: string) =>
+          new Promise<void>((resolve) => {
+            finishSend = resolve;
+          }),
+      );
+      const voiceAdapter = createVoiceAdapter({ sendText });
+      const onVoiceTranscript = vi.fn();
+      const render = (threadId: string, loading: boolean) =>
+        createBaseAdapter({
+          isLoading: loading,
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter, threadList: { threadId } },
+        });
+      const runtime = new ExternalStoreRuntimeCore(
+        render("thread-1", isLoading),
+      );
+      const thread = runtime.threads.getMainThreadRuntimeCore();
+      thread.connectVoice();
+
+      const append = thread.append({
+        parentId: null,
+        sourceId: null,
+        role: "user",
+        content: [{ type: "text", text: "Typed" }],
+        attachments: [],
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        runConfig: {},
+      });
+      expect(sendText).toHaveBeenCalledExactlyOnceWith("Typed");
+      runtime.setAdapter(render("thread-2", false));
+      finishSend();
+
+      await expect(append).resolves.toBeUndefined();
+      expect(onVoiceTranscript).not.toHaveBeenCalled();
+      expect(thread.messages).toEqual([]);
+
+      thread.disconnectVoice();
+    },
+  );
+
+  it.each([
+    { failure: "the session ends", rejects: false },
+    { failure: "sendText rejects", rejects: true },
+  ])(
+    "resolves a typed turn on the runtime the host switched away from when $failure",
+    async ({ rejects }) => {
+      let finishSend!: () => void;
+      let failSend!: (error: Error) => void;
+      const sendText = vi.fn(
+        (_text: string) =>
+          new Promise<void>((resolve, reject) => {
+            finishSend = resolve;
+            failSend = reject;
+          }),
+      );
+      const voiceAdapter = createVoiceAdapter({ sendText });
+      const onVoiceTranscript = vi.fn();
+      const render = (threadId: string) =>
+        createBaseAdapter({
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter, threadList: { threadId } },
+        });
+      const runtime = new ExternalStoreRuntimeCore(render("thread-1"));
+      const thread = runtime.threads.getMainThreadRuntimeCore();
+      thread.connectVoice();
+
+      const append = thread.append({
+        parentId: null,
+        sourceId: null,
+        role: "user",
+        content: [{ type: "text", text: "Typed" }],
+        attachments: [],
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        runConfig: {},
+      });
+      runtime.setAdapter(render("thread-2"));
+      if (rejects) {
+        failSend(new Error("offline"));
+      } else {
+        thread.disconnectVoice();
+        finishSend();
+      }
+
+      await expect(append).resolves.toBeUndefined();
+      expect(onVoiceTranscript).not.toHaveBeenCalled();
+      expect(thread.messages).toEqual([]);
+
+      thread.disconnectVoice();
+    },
+  );
+
   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();
@@ -1494,6 +1973,107 @@ describe("ExternalStoreThreadRuntimeCore voice transcripts", () => {
     }
   });
 
+  it("takes back a spoken user turn that the host echoes through convertMessage", () => {
+    const voiceAdapter = createVoiceAdapter();
+    const onVoiceTranscript = vi.fn();
+    const convertMessage = (message: ThreadMessage) => message;
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        convertMessage,
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    try {
+      voiceAdapter.emitTranscript({
+        role: "user",
+        text: "Hello",
+        isFinal: true,
+      });
+      const message = core.messages[0]!;
+      expect(onVoiceTranscript).toHaveBeenCalledExactlyOnceWith(message);
+      expect(message).not.toHaveProperty("status");
+
+      core.__internal_setAdapter(
+        createBaseAdapter({
+          messages: [message],
+          convertMessage,
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter },
+        }),
+      );
+
+      expect(core.messages.map(({ id }) => id)).toEqual([message.id]);
+      expect(core.messages[0]!.metadata.modality).toBe("voice");
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
+  it("hands a typed message to onVoiceTranscript as a typed turn without reaching onNew", async () => {
+    const sendText = vi.fn(async (_text: string) => {});
+    const voiceAdapter = createVoiceAdapter({ sendText });
+    const onNew = vi.fn(async () => {});
+    const onVoiceTranscript = vi.fn();
+    const core = new ExternalStoreThreadRuntimeCore(
+      createContextProvider(),
+      createBaseAdapter({
+        onNew,
+        onVoiceTranscript,
+        adapters: { voice: voiceAdapter.adapter },
+      }),
+    );
+    core.connectVoice();
+
+    try {
+      voiceAdapter.emitTranscript({
+        role: "user",
+        text: "Hello",
+        isFinal: true,
+      });
+      const transcript = core.messages[0]!;
+      expect(core.voice?.canSendText).toBe(true);
+
+      await core.append({
+        parentId: transcript.id,
+        sourceId: null,
+        role: "user",
+        content: [{ type: "text", text: "Typed" }],
+        attachments: [],
+        metadata: { custom: {} },
+        createdAt: new Date(),
+        runConfig: {},
+      });
+
+      expect(sendText).toHaveBeenCalledExactlyOnceWith("Typed");
+      expect(onNew).not.toHaveBeenCalled();
+      const typed = core.messages[1]!;
+      expect(typed.role).toBe("user");
+      expect(getThreadMessageText(typed)).toBe("Typed");
+      expect(typed.metadata.modality).toBeUndefined();
+      expect(onVoiceTranscript).toHaveBeenLastCalledWith(typed);
+
+      core.__internal_setAdapter(
+        createBaseAdapter({
+          messages: [transcript, typed],
+          onNew,
+          onVoiceTranscript,
+          adapters: { voice: voiceAdapter.adapter },
+        }),
+      );
+
+      expect(core.messages.map(({ id }) => id)).toEqual([
+        transcript.id,
+        typed.id,
+      ]);
+    } finally {
+      core.disconnectVoice();
+    }
+  });
+
   it("keeps transcripts for the session when the host has no onVoiceTranscript", () => {
     const voiceAdapter = createVoiceAdapter();
     const core = new ExternalStoreThreadRuntimeCore(