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

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

@@ -0,0 +1,302 @@
+// @vitest-environment jsdom
+import {
+  createApp,
+  defineComponent,
+  h,
+  KeepAlive,
+  nextTick,
+  shallowReactive,
+  shallowRef,
+  type Component,
+  type VNode,
+} from "vue";
+import type { SuggestionAdapter } from "@ulearning/ai-core";
+import { afterEach, expect, it, vi } from "vitest";
+import type { AISDKChatHelpers } from "../aiSDKExtras";
+import { useAISDKRuntime } from "./useAISDKRuntime";
+
+const cleanups: (() => void)[] = [];
+afterEach(() => {
+  for (const cleanup of cleanups.splice(0).reverse()) cleanup();
+  vi.useRealTimers();
+});
+
+function invokeNativeHmr(method: "createRecord" | "rerender", args: unknown[]) {
+  const runtime: unknown = Reflect.get(globalThis, "__VUE_HMR_RUNTIME__");
+  if (typeof runtime !== "object" || runtime === null)
+    throw new Error("The real native Vue HMR runtime is required");
+  const call: unknown = Reflect.get(runtime, method);
+  if (typeof call !== "function")
+    throw new Error(`Missing native HMR ${method}`);
+  return Reflect.apply(call, runtime, args);
+}
+
+let hostId = 0;
+function createHost(setup: () => void, phase?: (value: string) => void) {
+  const revision = shallowRef(0);
+  const id = `ai-runtime-native-refresh-${++hostId}`;
+  const Before = Object.assign(
+    defineComponent({
+      setup() {
+        setup();
+        return {};
+      },
+      render() {
+        void revision.value;
+        phase?.("before");
+        return null;
+      },
+    }),
+    { __hmrId: id },
+  );
+  expect(invokeNativeHmr("createRecord", [id, Before])).toBe(true);
+  return {
+    Before,
+    rerender: async () => {
+      revision.value++;
+      await nextTick();
+    },
+    refresh: async () => {
+      invokeNativeHmr("rerender", [
+        id,
+        () => {
+          void revision.value;
+          phase?.("after");
+          return null;
+        },
+      ]);
+      await nextTick();
+      await Promise.resolve();
+    },
+  };
+}
+function render(component: Component) {
+  const container = document.createElement("div");
+  const app = createApp(component);
+  app.mount(container);
+  let active = true;
+  const unmount = () => {
+    if (active) {
+      active = false;
+      app.unmount();
+    }
+  };
+  cleanups.push(unmount);
+  return { unmount };
+}
+async function act(callback: () => void | Promise<void>) {
+  await callback();
+  await nextTick();
+  await Promise.resolve();
+}
+const waitFor = vi.waitFor;
+
+type MutableChatFixture = {
+  -readonly [K in keyof AISDKChatHelpers]: AISDKChatHelpers[K];
+};
+const createChat = (): MutableChatFixture =>
+  shallowReactive<MutableChatFixture>({
+    id: "chat-1",
+    status: "submitted",
+    error: undefined,
+    messages: [
+      { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+    ],
+    setMessages: vi.fn(),
+    sendMessage: vi.fn(async () => {}),
+    regenerate: vi.fn(async () => {}),
+    addToolResult: vi.fn(async () => {}),
+    addToolOutput: vi.fn(async () => {}),
+    addToolApprovalResponse: vi.fn(async () => {}),
+    stop: vi.fn(async () => {}),
+    resumeStream: vi.fn(async () => {}),
+    clearError: vi.fn(),
+  });
+const settleChat = (chat: ReturnType<typeof createChat>) => {
+  chat.status = "ready";
+  chat.messages = [
+    ...chat.messages,
+    { id: "a1", role: "assistant", parts: [{ type: "text", text: "hello" }] },
+  ];
+};
+const makeGeneration = () => {
+  let resolve!: (value: readonly { prompt: string }[]) => void;
+  const generate = vi.fn(
+    (_input: Parameters<SuggestionAdapter["generate"]>[0]) =>
+      new Promise<readonly { prompt: string }[]>((done) => {
+        resolve = done;
+      }),
+  );
+  return {
+    generate,
+    finish: (value: readonly { prompt: string }[]) => resolve(value),
+  };
+};
+
+it("keeps a message createdAt across Fast Refresh", async () => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date("2026-01-01T00:00:00.000Z"));
+  const chat = createChat();
+  let runtime!: ReturnType<typeof useAISDKRuntime>;
+  let rendered = "";
+  const host = createHost(
+    () => {
+      runtime = useAISDKRuntime(() => chat);
+    },
+    (value) => {
+      rendered = value;
+    },
+  );
+  const view = render(host.Before);
+  const createdAt = runtime.thread.getState().messages[0]!.createdAt.getTime();
+  vi.setSystemTime(new Date("2026-01-01T00:01:00.000Z"));
+  await host.refresh();
+  expect(rendered).toBe("after");
+  expect(runtime.thread.getState().messages[0]!.createdAt.getTime()).toBe(
+    createdAt,
+  );
+  view.unmount();
+});
+
+it("keeps earlier createdAt values when streaming timing changes", async () => {
+  vi.useFakeTimers();
+  const firstSeen = new Date("2026-01-01T00:00:00.000Z");
+  const laterSeen = new Date("2026-01-01T00:01:00.000Z");
+  vi.setSystemTime(firstSeen);
+  const chat = createChat();
+  chat.status = "ready";
+  let runtime!: ReturnType<typeof useAISDKRuntime>;
+  const host = createHost(() => {
+    runtime = useAISDKRuntime(() => chat);
+  });
+  const view = render(host.Before);
+  const firstCreatedAt = runtime.thread
+    .getState()
+    .messages[0]!.createdAt.getTime();
+  vi.setSystemTime(laterSeen);
+  chat.status = "streaming";
+  chat.messages = [
+    ...chat.messages,
+    { id: "a1", role: "assistant", parts: [{ type: "text", text: "hello" }] },
+  ];
+  await host.rerender();
+  const laterCreatedAt = runtime.thread
+    .getState()
+    .messages[1]!.createdAt.getTime();
+  vi.setSystemTime(new Date("2026-01-01T00:02:00.000Z"));
+  chat.status = "ready";
+  await host.rerender();
+  expect(firstCreatedAt).toBe(firstSeen.getTime());
+  expect(laterCreatedAt).toBe(laterSeen.getTime());
+  expect(runtime.thread.getState().messages[1]!.metadata.timing).toBeDefined();
+  expect(runtime.thread.getState().messages[0]!.createdAt.getTime()).toBe(
+    firstCreatedAt,
+  );
+  expect(runtime.thread.getState().messages[1]!.createdAt.getTime()).toBe(
+    laterCreatedAt,
+  );
+  view.unmount();
+});
+
+it("stamps a message id afresh when the runtime switches chats", async () => {
+  vi.useFakeTimers();
+  vi.setSystemTime(new Date("2026-01-01T00:00:00.000Z"));
+  const chat = shallowRef(createChat());
+  let runtime!: ReturnType<typeof useAISDKRuntime>;
+  const host = createHost(() => {
+    runtime = useAISDKRuntime(() => chat.value);
+  });
+  const view = render(host.Before);
+  const firstChatCreatedAt = runtime.thread
+    .getState()
+    .messages[0]!.createdAt.getTime();
+  vi.setSystemTime(new Date("2026-01-01T00:01:00.000Z"));
+  chat.value = { ...createChat(), id: "chat-2" };
+  await host.rerender();
+  expect(runtime.thread.getState().messages[0]!.createdAt.getTime()).not.toBe(
+    firstChatCreatedAt,
+  );
+  view.unmount();
+});
+
+it("completes AI SDK suggestion generation after Fast Refresh", async () => {
+  const chat = createChat();
+  const { generate, finish } = makeGeneration();
+  let runtime!: ReturnType<typeof useAISDKRuntime>;
+  let rendered = "";
+  const host = createHost(
+    () => {
+      runtime = useAISDKRuntime(() => chat, {
+        adapters: { suggestion: { generate } },
+      });
+    },
+    (value) => {
+      rendered = value;
+    },
+  );
+  const view = render(host.Before);
+  settleChat(chat);
+  await host.rerender();
+  await waitFor(() => expect(generate).toHaveBeenCalledTimes(1));
+  const signal = generate.mock.calls[0]![0].signal!;
+  await host.refresh();
+  expect(rendered).toBe("after");
+  expect(signal.aborted).toBe(false);
+  await act(async () => finish([{ prompt: "next" }]));
+  await waitFor(() =>
+    expect(runtime.thread.getState().suggestions).toEqual([{ prompt: "next" }]),
+  );
+  view.unmount();
+});
+
+it("aborts pending AI SDK suggestion generation on unmount", async () => {
+  const chat = createChat();
+  const { generate, finish } = makeGeneration();
+  let runtime!: ReturnType<typeof useAISDKRuntime>;
+  const host = createHost(() => {
+    runtime = useAISDKRuntime(() => chat, {
+      adapters: { suggestion: { generate } },
+    });
+  });
+  const view = render(host.Before);
+  settleChat(chat);
+  await host.rerender();
+  await waitFor(() => expect(generate).toHaveBeenCalledTimes(1));
+  const signal = generate.mock.calls[0]![0].signal!;
+  view.unmount();
+  await act(async () => {});
+  expect(signal.aborted).toBe(true);
+  await act(async () => finish([{ prompt: "stale" }]));
+  expect(runtime.thread.getState().suggestions).toEqual([]);
+  expect(generate).toHaveBeenCalledTimes(1);
+});
+
+it("aborts pending AI SDK suggestion generation on native deactivation and drops late results", async () => {
+  const chat = createChat();
+  const { generate, finish } = makeGeneration();
+  let runtime!: ReturnType<typeof useAISDKRuntime>;
+  const host = createHost(() => {
+    runtime = useAISDKRuntime(() => chat, {
+      adapters: { suggestion: { generate } },
+    });
+  });
+  const mode = shallowRef<"visible" | "hidden">("visible");
+  const Parent = defineComponent(
+    () => (): VNode =>
+      h(KeepAlive, null, {
+        default: () => (mode.value === "visible" ? h(host.Before) : null),
+      }),
+  );
+  const view = render(Parent);
+  settleChat(chat);
+  await host.rerender();
+  await waitFor(() => expect(generate).toHaveBeenCalledTimes(1));
+  const signal = generate.mock.calls[0]![0].signal!;
+  mode.value = "hidden";
+  await act(async () => {});
+  expect(signal.aborted).toBe(true);
+  await act(async () => finish([{ prompt: "stale" }]));
+  expect(runtime.thread.getState().suggestions).toEqual([]);
+  expect(generate).toHaveBeenCalledTimes(1);
+  view.unmount();
+});

package/src/runtime/useAISDKRuntime.metadata-cache.test.tsx

@@ -0,0 +1,157 @@
+// @vitest-environment jsdom
+
+import { act, renderHook } from "./__tests__/tap";
+import type { UIMessage } from "ai";
+import type { ExternalStoreAdapter } from "@ulearning/ai-core";
+import { describe, expect, it, vi } from "vitest";
+
+const mocks = vi.hoisted(() => ({
+  adapter: undefined as ExternalStoreAdapter | undefined,
+  conversions: vi.fn<(messageId: string) => void>(),
+}));
+
+vi.mock("@ulearning/ai-core/vue", async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import("@ulearning/ai-core/vue")>();
+  return {
+    ...original,
+    useExternalStoreRuntime: vi.fn((adapter: ExternalStoreAdapter) => {
+      mocks.adapter = adapter;
+      return {};
+    }),
+    useRuntimeAdapters: vi.fn(() => ({})),
+  };
+});
+
+vi.mock("../converters/convertMessage", async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import("../converters/convertMessage")>();
+  return {
+    ...original,
+    convertAISDKMessage: (
+      ...args: Parameters<typeof original.convertAISDKMessage>
+    ) => {
+      mocks.conversions(args[0].id);
+      return original.convertAISDKMessage(...args);
+    },
+  };
+});
+
+import { useAISDKRuntime } from "./useAISDKRuntime";
+
+const MESSAGE_COUNT = 1_000;
+const messages: UIMessage[] = Array.from({ length: MESSAGE_COUNT }, (_, i) =>
+  i % 2 === 0
+    ? { id: `m${i}`, role: "user", parts: [{ type: "text", text: `q${i}` }] }
+    : {
+        id: `m${i}`,
+        role: "assistant",
+        parts: [
+          {
+            type: "tool-search",
+            toolCallId: `call-m${i}`,
+            state:
+              i === MESSAGE_COUNT - 1 ? "input-available" : "output-available",
+            input: { query: `q${i}` },
+            ...(i !== MESSAGE_COUNT - 1 && { output: { hits: i } }),
+          } as UIMessage["parts"][number],
+          { type: "text", text: `a${i}` },
+        ],
+      },
+);
+const LAST_ID = `m${MESSAGE_COUNT - 1}`;
+const MIDDLE_ID = `m${MESSAGE_COUNT / 2 + 1}`;
+
+const createChatHelpers = (status: string, error?: Error) => ({
+  id: "chat-1",
+  status,
+  error,
+  messages,
+  setMessages: vi.fn(),
+  sendMessage: vi.fn(),
+  regenerate: vi.fn(),
+  addToolOutput: vi.fn().mockResolvedValue(undefined),
+  addToolApprovalResponse: vi.fn(),
+  stop: vi.fn(),
+});
+
+type ChatState = { status: string; error?: Error };
+
+const renderRuntime = () => {
+  const initialProps: ChatState = { status: "ready" };
+  const view = renderHook(
+    ({ status, error }: ChatState) =>
+      useAISDKRuntime(createChatHelpers(status, error) as never),
+    { initialProps },
+  );
+  expect(mocks.conversions).toHaveBeenCalledTimes(MESSAGE_COUNT);
+  return view;
+};
+
+type Step = [
+  action: (view: ReturnType<typeof renderRuntime>) => unknown,
+  converts: readonly string[],
+];
+
+const interrupt = {
+  type: "interrupt" as const,
+  payload: { type: "human" as const, payload: { question: "which?" } },
+};
+
+const cases: Record<string, Step[]> = {
+  "a tool status moves between messages": [
+    [
+      () => mocks.adapter!.setToolStatuses!({ [`call-${LAST_ID}`]: interrupt }),
+      [LAST_ID],
+    ],
+    [
+      () =>
+        mocks.adapter!.setToolStatuses!({ [`call-${MIDDLE_ID}`]: interrupt }),
+      [MIDDLE_ID, LAST_ID],
+    ],
+  ],
+  "a tool result records an artifact": [
+    [
+      () =>
+        mocks.adapter!.onAddToolResult!({
+          messageId: MIDDLE_ID,
+          toolCallId: `call-${MIDDLE_ID}`,
+          toolName: "search",
+          result: { hits: 1 },
+          isError: false,
+          artifact: { chart: "bar" },
+        }),
+      [MIDDLE_ID],
+    ],
+  ],
+  "a run starts and ends": [
+    [({ rerender }) => rerender({ status: "streaming" }), [LAST_ID]],
+    // The run end clears the optimistic flag. This run produces no output, so
+    // its timing stays as it was and nothing else re-converts.
+    [({ rerender }) => rerender({ status: "ready" }), [LAST_ID]],
+  ],
+  "the chat errors": [
+    [
+      ({ rerender }) => rerender({ status: "error", error: new Error("boom") }),
+      [],
+    ],
+  ],
+};
+
+describe("useAISDKRuntime metadata cache", () => {
+  it.each(Object.entries(cases))(
+    "re-converts only the affected messages when %s",
+    async (_, steps) => {
+      const view = renderRuntime();
+      for (const [action, converts] of steps) {
+        mocks.conversions.mockClear();
+        await act(async () => {
+          await action(view);
+        });
+        expect(
+          mocks.conversions.mock.calls.map(([messageId]) => messageId),
+        ).toEqual(converts);
+      }
+    },
+  );
+});