@ulearning/ai-sdk-adapter 0.0.0-stage → 1.0.0-next.0

package/src/runtime/useAISDKRuntime.voice.test.tsx

@@ -0,0 +1,319 @@
+// @vitest-environment jsdom
+
+import { act, renderHook, waitFor } from "./__tests__/tap";
+import {
+  getExternalStoreMessages,
+  type RealtimeVoiceAdapter,
+  type ThreadHistoryAdapter,
+  type ThreadMessage,
+} from "@ulearning/ai-core";
+import type { UIMessage } from "ai";
+import { describe, expect, it, vi } from "vitest";
+
+import { useAISDKRuntime } from "./useAISDKRuntime";
+
+const createChatHelpers = (initialMessages: UIMessage[] = []) => {
+  let currentMessages: UIMessage[] = initialMessages;
+  const chatHelpers: any = {
+    id: "chat-1",
+    status: "ready",
+    error: null,
+    messages: currentMessages,
+    setMessages: vi.fn(
+      (next: UIMessage[] | ((current: UIMessage[]) => UIMessage[])) => {
+        currentMessages =
+          typeof next === "function" ? next(currentMessages) : [...next];
+        chatHelpers.messages = currentMessages;
+        return currentMessages;
+      },
+    ),
+    sendMessage: vi.fn().mockResolvedValue(undefined),
+    regenerate: vi.fn().mockResolvedValue(undefined),
+    addToolResult: vi.fn(),
+    addToolOutput: vi.fn(),
+    stop: vi.fn(),
+  };
+  return chatHelpers;
+};
+
+const createVoiceAdapter = ({
+  sendText,
+}: { sendText?: RealtimeVoiceAdapter.Session["sendText"] } = {}) => {
+  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(),
+    ...(sendText && { sendText }),
+    onStatusChange: () => () => {},
+    onTranscript: (callback) => {
+      transcriptCallback = callback;
+      return () => {
+        transcriptCallback = undefined;
+      };
+    },
+    onModeChange: () => () => {},
+    onVolumeChange: () => () => {},
+  };
+  return {
+    adapter: { connect: () => session } satisfies RealtimeVoiceAdapter,
+    emitTranscript: (transcript: RealtimeVoiceAdapter.TranscriptItem) =>
+      transcriptCallback?.(transcript),
+  };
+};
+
+const createHistoryAdapter = () => {
+  const append = vi.fn(async () => {});
+  const adapter: ThreadHistoryAdapter = {
+    load: vi.fn(),
+    append: vi.fn(),
+    withFormat: vi.fn().mockReturnValue({
+      load: vi.fn().mockResolvedValue({ headId: null, messages: [] }),
+      append,
+    }),
+  };
+  return { adapter, append };
+};
+
+const textOf = (message: ThreadMessage) =>
+  message.content
+    .map((part) => (part.type === "text" ? part.text : ""))
+    .join("");
+
+const renderVoiceRuntime = async (
+  chat: ReturnType<typeof createChatHelpers>,
+  adapters: { voice: RealtimeVoiceAdapter; history?: ThreadHistoryAdapter },
+) => {
+  const rendered = renderHook(() => useAISDKRuntime(chat, { adapters }));
+  await waitFor(() => {
+    expect(rendered.result.current.thread.getState().capabilities.voice).toBe(
+      true,
+    );
+  });
+  return rendered;
+};
+
+describe("useAISDKRuntime voice transcripts", () => {
+  it("persists finalized transcripts through the useChat messages", async () => {
+    const chat = createChatHelpers();
+    const voice = createVoiceAdapter();
+    const { result, rerender } = await renderVoiceRuntime(chat, {
+      voice: voice.adapter,
+    });
+
+    act(() => {
+      result.current.thread.connectVoice();
+      voice.emitTranscript({
+        role: "assistant",
+        text: "Spoken reply",
+        isFinal: true,
+      });
+    });
+
+    const transcript = chat.messages[0];
+    expect(transcript).toEqual({
+      id: expect.any(String),
+      role: "assistant",
+      parts: [{ type: "text", text: "Spoken reply" }],
+      metadata: { modality: "voice" },
+    });
+
+    rerender();
+
+    await waitFor(() => {
+      const messages = result.current.thread
+        .getState()
+        .messages.filter((message) => message.id === transcript.id);
+      expect(messages).toHaveLength(1);
+      expect(messages[0]?.metadata.modality).toBe("voice");
+      expect(getExternalStoreMessages(messages[0]!)).toEqual([transcript]);
+    });
+  });
+
+  it("keeps a transcript spoken after a typed reply as its own message", async () => {
+    const chat = createChatHelpers([
+      {
+        id: "typed-user",
+        role: "user",
+        parts: [{ type: "text", text: "Hi" }],
+      },
+      {
+        id: "typed-assistant",
+        role: "assistant",
+        parts: [{ type: "text", text: "Typed reply" }],
+      },
+    ]);
+    const voice = createVoiceAdapter();
+    const { result, rerender } = await renderVoiceRuntime(chat, {
+      voice: voice.adapter,
+    });
+
+    act(() => {
+      result.current.thread.connectVoice();
+      voice.emitTranscript({
+        role: "assistant",
+        text: "Spoken reply",
+        isFinal: true,
+      });
+    });
+    const transcript = chat.messages[2];
+    rerender();
+
+    await waitFor(() => {
+      const spoken = result.current.thread.getState().messages.at(-1)!;
+      expect(getExternalStoreMessages(spoken)).toEqual([transcript]);
+    });
+    const messages = result.current.thread.getState().messages;
+    expect(messages.map((message) => message.id)).toEqual([
+      "typed-user",
+      "typed-assistant",
+      transcript.id,
+    ]);
+    expect(textOf(messages[1]!)).toBe("Typed reply");
+    expect(messages[1]?.metadata.modality).toBeUndefined();
+    expect(textOf(messages[2]!)).toBe("Spoken reply");
+    expect(messages[2]?.metadata.modality).toBe("voice");
+  });
+
+  it("keeps consecutive assistant transcripts as separate messages", async () => {
+    const chat = createChatHelpers();
+    const voice = createVoiceAdapter();
+    const { result, rerender } = await renderVoiceRuntime(chat, {
+      voice: voice.adapter,
+    });
+
+    act(() => {
+      result.current.thread.connectVoice();
+      voice.emitTranscript({ role: "assistant", text: "First", isFinal: true });
+      voice.emitTranscript({
+        role: "assistant",
+        text: "Second",
+        isFinal: true,
+      });
+    });
+    const [first, second] = chat.messages;
+    rerender();
+
+    await waitFor(() => {
+      const messages = result.current.thread.getState().messages;
+      expect(
+        messages.map((message) => getExternalStoreMessages(message)),
+      ).toEqual([[first], [second]]);
+    });
+    expect(result.current.thread.getState().messages.map(textOf)).toEqual([
+      "First",
+      "Second",
+    ]);
+  });
+
+  it("keeps the transcript in the thread after the session disconnects", async () => {
+    const chat = createChatHelpers();
+    const voice = createVoiceAdapter();
+    const { result, rerender } = await renderVoiceRuntime(chat, {
+      voice: voice.adapter,
+    });
+
+    act(() => {
+      result.current.thread.connectVoice();
+      voice.emitTranscript({
+        role: "assistant",
+        text: "Spoken reply",
+        isFinal: true,
+      });
+    });
+    const transcript = chat.messages[0];
+    rerender();
+    await waitFor(() => {
+      const messages = result.current.thread.getState().messages;
+      expect(getExternalStoreMessages(messages[0]!)).toEqual([transcript]);
+    });
+
+    act(() => {
+      result.current.thread.disconnectVoice();
+    });
+    rerender();
+
+    const messages = result.current.thread.getState().messages;
+    expect(messages).toHaveLength(1);
+    expect(messages[0]?.id).toBe(transcript.id);
+    expect(messages[0]?.metadata.modality).toBe("voice");
+    expect(result.current.thread.getState().voice).toBeUndefined();
+  });
+
+  it("appends a finalized transcript to the history adapter without a text run", async () => {
+    const chat = createChatHelpers();
+    const voice = createVoiceAdapter();
+    const history = createHistoryAdapter();
+    const { result, rerender } = await renderVoiceRuntime(chat, {
+      voice: voice.adapter,
+      history: history.adapter,
+    });
+
+    act(() => {
+      result.current.thread.connectVoice();
+      voice.emitTranscript({
+        role: "assistant",
+        text: "Spoken reply",
+        isFinal: true,
+      });
+    });
+    const transcript = chat.messages[0];
+    rerender();
+
+    await waitFor(() => expect(history.append).toHaveBeenCalledTimes(1));
+    expect(history.append).toHaveBeenCalledWith({
+      parentId: null,
+      message: transcript,
+    });
+  });
+
+  it("persists a message typed into the session as a typed turn", async () => {
+    const chat = createChatHelpers();
+    const sendText = vi.fn(async (_text: string) => {});
+    const voice = createVoiceAdapter({ sendText });
+    const history = createHistoryAdapter();
+    const { result, rerender } = await renderVoiceRuntime(chat, {
+      voice: voice.adapter,
+      history: history.adapter,
+    });
+
+    act(() => {
+      result.current.thread.connectVoice();
+    });
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "Typed" }],
+      });
+    });
+
+    expect(sendText).toHaveBeenCalledExactlyOnceWith("Typed");
+    expect(chat.sendMessage).not.toHaveBeenCalled();
+    const typed = chat.messages[0];
+    expect(typed).toEqual({
+      id: expect.any(String),
+      role: "user",
+      parts: [{ type: "text", text: "Typed" }],
+      metadata: {},
+    });
+    rerender();
+
+    await waitFor(() => {
+      const messages = result.current.thread
+        .getState()
+        .messages.filter((message) => message.id === typed.id);
+      expect(messages).toHaveLength(1);
+      expect(messages[0]?.metadata.modality).toBeUndefined();
+      expect(textOf(messages[0]!)).toBe("Typed");
+    });
+    await waitFor(() => expect(history.append).toHaveBeenCalledTimes(1));
+    expect(history.append).toHaveBeenCalledWith({
+      parentId: null,
+      message: typed,
+    });
+  });
+});

package/src/runtime/useChatOnTap.test.ts

@@ -0,0 +1,60 @@
+import { describe, expect, it, vi } from "vitest";
+import { createTapRoot, useState } from "@ulearning/ai-tap";
+import { Chat } from "@ai-sdk/vue";
+import { useChatSnapshot } from "./useChatSnapshot";
+import { createControlledTransport } from "./__tests__/controlled-transport";
+
+describe("useChat hosted in a tap root", () => {
+  it("streams a full round trip without React", async () => {
+    const { transport, emit, close } = createControlledTransport();
+    const root = createTapRoot(function UseChatOnTap() {
+      const [chat] = useState(() => new Chat({ transport }));
+      return useChatSnapshot(chat, undefined);
+    });
+
+    try {
+      expect(root.getValue().status).toBe("ready");
+      expect(root.getValue().messages).toHaveLength(0);
+
+      const sendPromise = root.getValue().sendMessage({ text: "hi" });
+      await vi.waitFor(() => {
+        expect(root.getValue().status).toBe("submitted");
+        expect(root.getValue().messages).toHaveLength(1);
+      });
+
+      emit(
+        { type: "start" },
+        { type: "text-start", id: "t1" },
+        { type: "text-delta", id: "t1", delta: "hello " },
+      );
+      await vi.waitFor(() => {
+        expect(root.getValue().status).toBe("streaming");
+        const parts = root.getValue().messages.at(-1)?.parts;
+        expect(parts).toContainEqual(
+          expect.objectContaining({ type: "text", text: "hello " }),
+        );
+      });
+
+      emit(
+        { type: "text-delta", id: "t1", delta: "world" },
+        { type: "text-end", id: "t1" },
+        { type: "finish" },
+      );
+      close();
+      await sendPromise;
+
+      await vi.waitFor(() => {
+        expect(root.getValue().status).toBe("ready");
+        const { messages } = root.getValue();
+        expect(messages).toHaveLength(2);
+        expect(messages[0]!.role).toBe("user");
+        expect(messages[1]!.role).toBe("assistant");
+        expect(messages[1]!.parts).toContainEqual(
+          expect.objectContaining({ type: "text", text: "hello world" }),
+        );
+      });
+    } finally {
+      root.unmount();
+    }
+  });
+});

package/src/runtime/useChatRuntime.fast-refresh.test.tsx

@@ -0,0 +1,83 @@
+// @vitest-environment jsdom
+
+import { afterEach, expect, it, vi } from "vitest";
+import { defineComponent, h, type Component, type VNode } from "vue";
+import { AssistantRuntimeProvider } from "@ulearning/ai-core/vue";
+import { useChatRuntime } from "./useChatRuntime";
+import { act, render, waitFor } from "./__tests__/vue";
+import {
+  createCancellableTransport,
+  createStreamHarness,
+} from "./__tests__/controlled-transport";
+
+afterEach(() => vi.restoreAllMocks());
+
+function nativeHmr() {
+  const runtime: unknown = Reflect.get(globalThis, "__VUE_HMR_RUNTIME__");
+  if (typeof runtime !== "object" || runtime === null)
+    throw new Error("The real Vue development HMR runtime is required.");
+  const createRecord: unknown = Reflect.get(runtime, "createRecord");
+  const rerender: unknown = Reflect.get(runtime, "rerender");
+  if (typeof createRecord !== "function" || typeof rerender !== "function")
+    throw new Error(
+      "Vue's real HMR createRecord/rerender operations are required.",
+    );
+  return {
+    createRecord: (id: string, component: Component): unknown =>
+      Reflect.apply(createRecord, runtime, [id, component]),
+    rerender: (id: string, next: () => VNode): void => {
+      Reflect.apply(rerender, runtime, [id, next]);
+    },
+  };
+}
+
+it("keeps a running thread across a Fast Refresh of its host and aborts it on unmount", async () => {
+  const { transport, getCancelCount } = createCancellableTransport();
+  const { Probe, send, isRunning, client } = createStreamHarness();
+  const runtimes: ReturnType<typeof useChatRuntime>[] = [];
+  let rendered: string | undefined;
+  const createRender = (name: string) => () => {
+    rendered = name;
+    const runtime = runtimes.at(-1);
+    if (!runtime) throw new Error("The actual host has not completed setup.");
+    return h(
+      AssistantRuntimeProvider,
+      { runtime },
+      { default: () => h(Probe) },
+    );
+  };
+  const Host = defineComponent({
+    name: "ChatRuntimeRefreshHost",
+    setup() {
+      runtimes.push(useChatRuntime({ transport }));
+    },
+    render: createRender("before"),
+  });
+  const id = "ai-sdk-useChatRuntime-native-render-refresh";
+  // This is the actual compiler-emitted component ID read by Vue's HMR runtime.
+  Reflect.set(Host, "__hmrId", id);
+  const hmr = nativeHmr();
+  expect(hmr.createRecord(id, Host)).toBe(true);
+
+  const view = render(h(Host));
+  await act(async () => send());
+  await waitFor(() => expect(isRunning()).toBe(true));
+  const runtime = runtimes.at(-1);
+  const threadId = client().threads.getState().mainThreadId;
+  const messages = client().thread.getState().messages;
+  const error = vi.spyOn(console, "error");
+
+  await act(() => hmr.rerender(id, createRender("after")));
+
+  expect(rendered).toBe("after");
+  expect(runtimes.at(-1)).toBe(runtime);
+  expect(runtimes).toHaveLength(1);
+  expect(isRunning()).toBe(true);
+  expect(getCancelCount()).toBe(0);
+  expect(client().threads.getState().mainThreadId).toBe(threadId);
+  expect(client().thread.getState().messages).toEqual(messages);
+  expect(error).not.toHaveBeenCalled();
+
+  view.unmount();
+  await waitFor(() => expect(getCancelCount()).toBe(1));
+});