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

package/src/runtime/useChatRuntime.local-storage.test.tsx

@@ -0,0 +1,114 @@
+// @vitest-environment jsdom
+
+import { act, render, waitFor } from "./__tests__/vue";
+import {
+  AssistantRuntimeProvider,
+  createLocalStorageAdapter,
+  useRemoteThreadListRuntime,
+  type AsyncStorageLike,
+} from "@ulearning/ai-core/vue";
+import type { ChatTransport, UIMessage } from "ai";
+import { defineComponent, h, type VNodeChild } from "vue";
+import { describe, expect, it } from "vitest";
+import {
+  createControlledTransport,
+  createStreamHarness,
+} from "./__tests__/controlled-transport";
+import { useChatRuntime } from "./useChatRuntime";
+
+const createStorage = (): AsyncStorageLike => {
+  const values = new Map<string, string>();
+  return {
+    getItem: async (key) => values.get(key) ?? null,
+    setItem: async (key, value) => {
+      values.set(key, value);
+    },
+    removeItem: async (key) => {
+      values.delete(key);
+    },
+  };
+};
+
+const LocalStorageApp = defineComponent<{
+  storage: AsyncStorageLike;
+  transport: ChatTransport<UIMessage>;
+  threadId?: string;
+  probe: VNodeChild;
+}>(
+  (props) => {
+    const adapter = createLocalStorageAdapter({ storage: props.storage });
+    const runtime = useRemoteThreadListRuntime(() => ({
+      runtimeHook: function RuntimeHook() {
+        return useChatRuntime({ transport: props.transport });
+      },
+      adapter,
+      ...(props.threadId !== undefined ? { threadId: props.threadId } : {}),
+    }));
+    return () =>
+      h(AssistantRuntimeProvider, { runtime }, { default: () => props.probe });
+  },
+  { props: ["storage", "transport", "threadId", "probe"] },
+);
+
+const threadText = (
+  harness: ReturnType<typeof createStreamHarness>,
+): string[] =>
+  harness
+    .client()
+    .thread.getState()
+    .messages.map((message) =>
+      message.content
+        .map((part) => (part.type === "text" ? part.text : ""))
+        .join(""),
+    );
+
+describe("useChatRuntime with createLocalStorageAdapter", () => {
+  it("persists AI SDK messages and restores them after a remount", async () => {
+    const storage = createStorage();
+    const { transport, emit, close } = createControlledTransport();
+    const harness = createStreamHarness();
+
+    const first = render(
+      h(LocalStorageApp, { storage, transport, probe: h(harness.Probe) }),
+    );
+
+    await act(async () => harness.send());
+    await waitFor(() => expect(harness.isRunning()).toBe(true));
+    await act(async () => {
+      emit(
+        { type: "start" },
+        { type: "text-start", id: "t1" },
+        { type: "text-delta", id: "t1", delta: "stored answer" },
+        { type: "text-end", id: "t1" },
+        { type: "finish" },
+      );
+      close();
+    });
+    await waitFor(() => expect(harness.isRunning()).toBe(false));
+
+    const remoteId = harness.client().threadListItem.getState().remoteId;
+    expect(remoteId).toBeDefined();
+    await waitFor(async () =>
+      expect(
+        await storage.getItem(
+          `@assistant-ui:formatted-messages:${JSON.stringify([remoteId, "ai-sdk/v6"])}`,
+        ),
+      ).toContain("stored answer"),
+    );
+    first.unmount();
+
+    const restored = createStreamHarness();
+    render(
+      h(LocalStorageApp, {
+        storage,
+        transport: createControlledTransport().transport,
+        threadId: remoteId!,
+        probe: h(restored.Probe),
+      }),
+    );
+
+    await waitFor(() =>
+      expect(threadText(restored)).toEqual(["keep streaming", "stored answer"]),
+    );
+  });
+});

package/src/runtime/useChatRuntime.native.test.ts

@@ -0,0 +1,147 @@
+// @vitest-environment jsdom
+import { defineComponent, h, KeepAlive, nextTick, shallowRef } from "vue";
+import { expect, it, vi } from "vitest";
+import { flushTapSync } from "@ulearning/ai-tap";
+import { useAui, useAuiState } from "@ulearning/ai-store";
+import { AssistantRuntimeProvider } from "@ulearning/ai-core/vue";
+import type { UIMessage } from "ai";
+import { useChatRuntime } from "./useChatRuntime";
+import { render } from "./__tests__/vue";
+import { createCancellableTransport } from "./__tests__/controlled-transport";
+
+function mountChat() {
+  const source = createCancellableTransport();
+  const transport = shallowRef(source.transport);
+  const active = shallowRef(true);
+  const onFinish = shallowRef(vi.fn());
+  const seeded: UIMessage = {
+    id: "seed",
+    role: "user",
+    parts: [{ type: "text", text: "Seeded" }],
+  };
+  let aui!: ReturnType<typeof useAui>;
+  const Probe = defineComponent({
+    setup() {
+      aui = useAui();
+      const running = useAuiState((state) => state.thread.isRunning);
+      const count = useAuiState((state) => state.thread.messages.length);
+      return () => h("output", `${count.value}:${running.value}`);
+    },
+  });
+  const Host = defineComponent({
+    setup() {
+      const runtime = useChatRuntime(() => ({
+        messages: [seeded],
+        transport: transport.value,
+        onFinish: onFinish.value,
+      }));
+      return () =>
+        h(AssistantRuntimeProvider, { runtime }, { default: () => h(Probe) });
+    },
+  });
+  const view = render(
+    h(
+      defineComponent({
+        setup: () => () =>
+          h(KeepAlive, null, {
+            default: () => (active.value ? h(Host) : null),
+          }),
+      }),
+    ),
+  );
+  return {
+    ...view,
+    source,
+    transport,
+    active,
+    onFinish,
+    get aui() {
+      return aui;
+    },
+    send() {
+      flushTapSync(() => {
+        aui.composer.setText("Hello");
+        aui.composer.send();
+      });
+    },
+  };
+}
+
+it("exposes seeded messages through the mounted Vue Provider and aborts on permanent unmount", async () => {
+  const view = mountChat();
+  await vi.waitFor(() => expect(view.container.textContent).toBe("1:false"));
+  expect(view.aui.thread.getState().messages[0]?.id).toBe("seed");
+  view.send();
+  await vi.waitFor(() => expect(view.container.textContent).toBe("3:true"));
+  expect(view.source.getCancelCount()).toBe(0);
+  view.unmount();
+  await vi.waitFor(() => expect(view.source.getCancelCount()).toBe(1));
+});
+
+it("keeps the same chat streaming through KeepAlive deactivation and stops when its hidden scope is destroyed", async () => {
+  const view = mountChat();
+  view.send();
+  await vi.waitFor(() =>
+    expect(view.aui.thread.getState().isRunning).toBe(true),
+  );
+  const id = view.aui.threadListItem.getState().id;
+  view.active.value = false;
+  await nextTick();
+  // Wait for a real stream update while hidden, rather than assuming a timer is a cleanup barrier.
+  view.source.emit(
+    { type: "start", messageId: "answer" },
+    { type: "text-start", id: "text" },
+    { type: "text-delta", id: "text", delta: "Hidden" },
+  );
+  await vi.waitFor(() => expect(view.source.getCancelCount()).toBe(0));
+  view.active.value = true;
+  await nextTick();
+  await vi.waitFor(() =>
+    expect(view.aui.thread.getState().messages.at(-1)?.content).toContainEqual(
+      expect.objectContaining({ type: "text", text: "Hidden" }),
+    ),
+  );
+  expect(view.aui.threadListItem.getState().id).toBe(id);
+  expect(view.aui.thread.getState().isRunning).toBe(true);
+  view.active.value = false;
+  await nextTick();
+  view.unmount();
+  await vi.waitFor(() => expect(view.source.getCancelCount()).toBe(1));
+});
+
+it("uses a replacement transport and the latest finish callback without rebuilding thread history", async () => {
+  const view = mountChat();
+  const replacement = createCancellableTransport();
+  const original = view.onFinish.value;
+  const latest = vi.fn();
+  const sendReplacement = vi.spyOn(replacement.transport, "sendMessages");
+  const sendOriginal = vi.spyOn(view.source.transport, "sendMessages");
+  const id = view.aui.threadListItem.getState().id;
+  flushTapSync(() => {
+    view.transport.value = replacement.transport;
+    view.onFinish.value = latest;
+  });
+  await nextTick();
+  view.send();
+  await vi.waitFor(() =>
+    expect(view.aui.thread.getState().isRunning).toBe(true),
+  );
+  await vi.waitFor(() => expect(sendReplacement).toHaveBeenCalledTimes(1));
+  expect(sendOriginal).not.toHaveBeenCalled();
+  replacement.emit(
+    { type: "start", messageId: "answer" },
+    { type: "text-start", id: "text" },
+    { type: "text-delta", id: "text", delta: "Replacement" },
+    { type: "text-end", id: "text" },
+    { type: "finish" },
+  );
+  replacement.close();
+  await vi.waitFor(() =>
+    expect(view.aui.thread.getState().isRunning).toBe(false),
+  );
+  expect(view.aui.threadListItem.getState().id).toBe(id);
+  expect(view.aui.thread.getState().messages[0]?.id).toBe("seed");
+  expect(latest).toHaveBeenCalledTimes(1);
+  expect(original).not.toHaveBeenCalled();
+  expect(view.source.getCancelCount()).toBe(0);
+});

package/src/runtime/useChatRuntime.run-telemetry.test.tsx

@@ -0,0 +1,226 @@
+// @vitest-environment jsdom
+
+import { render, waitFor } from "./__tests__/vue";
+import { defineComponent, h } from "vue";
+import { AssistantRuntimeProvider } from "@ulearning/ai-core/vue";
+import type { ThreadHistoryAdapter, ThreadMessage } from "@ulearning/ai-core";
+import { flushTapSync } from "@ulearning/ai-tap";
+import { DefaultChatTransport, type ChatTransport, type UIMessage } from "ai";
+import { describe, expect, it, vi } from "vitest";
+import {
+  createControlledTransport,
+  createStreamHarness,
+} from "./__tests__/controlled-transport";
+import { useChatRuntime } from "./useChatRuntime";
+
+const mountWithHistory = (transport: ChatTransport<UIMessage>) => {
+  const reportTelemetry = vi.fn();
+  const append = vi.fn(async () => {});
+  const deleteItems = vi.fn(async () => {});
+  const history: ThreadHistoryAdapter = {
+    load: async () => ({ messages: [] }),
+    append: async () => {},
+    withFormat: () =>
+      ({
+        load: async () => ({ messages: [] }),
+        append,
+        delete: deleteItems,
+        reportTelemetry,
+      }) as never,
+  };
+  const harness = createStreamHarness();
+  const App = defineComponent({
+    setup() {
+      const runtime = useChatRuntime({ transport, adapters: { history } });
+      return () =>
+        h(
+          AssistantRuntimeProvider,
+          { runtime },
+          { default: () => h(harness.Probe) },
+        );
+    },
+  });
+  render(h(App));
+  const assistantReports = () =>
+    reportTelemetry.mock.calls
+      .map(([, options]) => options?.message as ThreadMessage | undefined)
+      .filter((message) => message?.role === "assistant")
+      .map((message) => message!.status);
+  return { harness, assistantReports, reportTelemetry, append, deleteItems };
+};
+
+describe("useChatRuntime run telemetry", () => {
+  it.each([
+    ["an empty composer", undefined, 0],
+    ["a follow-up already typed", "follow-up", 1],
+  ])(
+    "reports a run stopped before its first token with %s",
+    async (_, draft, threadLength) => {
+      const {
+        harness,
+        assistantReports,
+        reportTelemetry,
+        append,
+        deleteItems,
+      } = mountWithHistory(createControlledTransport().transport);
+      await waitFor(() => expect(harness.client()).toBeDefined());
+      harness.send();
+      await waitFor(() => expect(harness.isRunning()).toBe(true));
+      await waitFor(() => expect(append).toHaveBeenCalledOnce());
+      const promptId = harness.client().thread.getState().messages[0]!.id;
+      if (draft !== undefined)
+        flushTapSync(() => harness.client().composer.setText(draft));
+
+      await harness.client().thread.cancelRun();
+
+      await waitFor(() =>
+        expect(assistantReports()).toEqual([
+          { type: "incomplete", reason: "cancelled" },
+        ]),
+      );
+      expect(harness.client().thread.getState().messages).toHaveLength(
+        threadLength,
+      );
+      if (draft === undefined) {
+        expect(reportTelemetry.mock.calls[0]![1]).not.toHaveProperty(
+          "userMessageId",
+        );
+        await waitFor(() => expect(deleteItems).toHaveBeenCalledOnce());
+        expect(deleteItems).toHaveBeenCalledWith([
+          expect.objectContaining({
+            message: expect.objectContaining({
+              role: "user",
+              parts: [{ type: "text", text: "keep streaming" }],
+            }),
+          }),
+        ]);
+      } else {
+        expect(reportTelemetry.mock.calls[0]![1]).toHaveProperty(
+          "userMessageId",
+          promptId,
+        );
+        expect(deleteItems).not.toHaveBeenCalled();
+      }
+    },
+  );
+
+  it("keeps an answered prompt stored when its reload stops before the first token", async () => {
+    const stream = createControlledTransport();
+    const { harness, assistantReports, reportTelemetry, append, deleteItems } =
+      mountWithHistory(stream.transport);
+    await waitFor(() => expect(harness.client()).toBeDefined());
+    harness.send();
+    await waitFor(() => expect(harness.isRunning()).toBe(true));
+    stream.emit(
+      { type: "start" },
+      { type: "text-start", id: "t" },
+      { type: "text-delta", id: "t", delta: "answer" },
+      { type: "text-end", id: "t" },
+      { type: "finish" },
+    );
+    stream.close();
+    await waitFor(() => expect(harness.isRunning()).toBe(false));
+    await waitFor(() => expect(append).toHaveBeenCalledTimes(2));
+    const promptId = harness.client().thread.getState().messages[0]!.id;
+    await waitFor(() => expect(assistantReports()).toHaveLength(1));
+    expect(
+      reportTelemetry.mock.calls.find(
+        ([, options]) => options?.message?.role === "assistant",
+      )![1],
+    ).toEqual(
+      expect.objectContaining({
+        userMessageId: promptId,
+        message: expect.objectContaining({
+          role: "assistant",
+          status: expect.objectContaining({ type: "complete" }),
+        }),
+      }),
+    );
+
+    harness.client().thread.message({ index: 1 }).reload();
+    await waitFor(() => expect(harness.isRunning()).toBe(true));
+    await harness.client().thread.cancelRun();
+    await waitFor(() =>
+      expect(assistantReports().at(-1)).toEqual({
+        type: "incomplete",
+        reason: "cancelled",
+      }),
+    );
+
+    expect(
+      harness
+        .client()
+        .thread.getState()
+        .messages.map((message) => message.role),
+    ).toEqual(["user"]);
+    expect(harness.client().composer.getState().text).toBe("");
+    expect(deleteItems).not.toHaveBeenCalled();
+    expect(reportTelemetry.mock.calls.at(-1)![1]).toHaveProperty(
+      "userMessageId",
+      promptId,
+    );
+  });
+
+  it("reports the HTTP status of a request that failed before streaming", async () => {
+    const { harness, assistantReports, reportTelemetry } = mountWithHistory(
+      new DefaultChatTransport({
+        api: "http://localhost/api/chat",
+        fetch: async () => new Response("rate limited", { status: 429 }),
+      }),
+    );
+    await waitFor(() => expect(harness.client()).toBeDefined());
+
+    harness.send();
+
+    await waitFor(() =>
+      expect(assistantReports()).toEqual([
+        {
+          type: "incomplete",
+          reason: "error",
+          error: expect.objectContaining({
+            message: "rate limited",
+            statusCode: 429,
+          }),
+        },
+      ]),
+    );
+    expect(reportTelemetry.mock.calls[0]![1]).toHaveProperty(
+      "userMessageId",
+      harness.client().thread.getState().messages[0]!.id,
+    );
+  });
+
+  it("reports a run that ends without output as incomplete", async () => {
+    let respond!: () => void;
+    const responded = new Promise<void>((resolve) => {
+      respond = resolve;
+    });
+    const { harness, assistantReports, reportTelemetry } = mountWithHistory(
+      new DefaultChatTransport({
+        api: "http://localhost/api/chat",
+        fetch: async () => {
+          await responded;
+          return new Response("", {
+            status: 200,
+            headers: { "content-type": "text/event-stream" },
+          });
+        },
+      }),
+    );
+    await waitFor(() => expect(harness.client()).toBeDefined());
+    harness.send();
+    await waitFor(() => expect(harness.isRunning()).toBe(true));
+
+    respond();
+
+    await waitFor(() =>
+      expect(assistantReports()).toEqual([
+        { type: "incomplete", reason: "other" },
+      ]),
+    );
+    expect(reportTelemetry.mock.calls.at(-1)![1]).toHaveProperty(
+      "userMessageId",
+      harness.client().thread.getState().messages[0]!.id,
+    );
+  });
+});