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

package/src/runtime/useChatSnapshot.test.ts

@@ -0,0 +1,60 @@
+import { expect, it, vi } from "vitest";
+import { createTapRoot } from "@ulearning/ai-tap";
+import { Chat } from "@ai-sdk/vue";
+import type { UIMessage } from "ai";
+import { useChatSnapshot } from "./useChatSnapshot";
+
+it("preserves raw message identity and publishes a replaced array even with the same messages", async () => {
+  const first: UIMessage = {
+    id: "first",
+    role: "user",
+    parts: [{ type: "text", text: "First" }],
+  };
+  const second: UIMessage = {
+    id: "second",
+    role: "assistant",
+    parts: [{ type: "text", text: "Second" }],
+  };
+  const chat = new Chat({ messages: [first, second] });
+  const root = createTapRoot(function useSnapshotReader() {
+    return useChatSnapshot(chat, undefined);
+  });
+  try {
+    const before = root.getValue();
+    expect(before.messages[0]).toBe(first);
+    expect(before.messages[1]).toBe(second);
+    before.setMessages([...before.messages]);
+    await vi.waitFor(() =>
+      expect(root.getValue().messages).not.toBe(before.messages),
+    );
+    expect(root.getValue().messages[0]).toBe(first);
+    expect(root.getValue().messages[1]).toBe(second);
+    const replacement = root.getValue();
+    replacement.setMessages((messages) => messages);
+    // Re-reading an unchanged native state must return the same snapshot.
+    expect(root.getValue()).toBe(replacement);
+  } finally {
+    root.unmount();
+  }
+});
+
+it("releases native watches and pending throttled publications when its resource unmounts", async () => {
+  vi.useFakeTimers();
+  const chat = new Chat<UIMessage>({ messages: [] });
+  const root = createTapRoot(function useSnapshotReader() {
+    return useChatSnapshot(chat, 50);
+  });
+  const listener = vi.fn();
+  root.subscribe(listener);
+  const last = root.getValue();
+  root.unmount();
+  try {
+    chat.messages = [{ id: "late", role: "user", parts: [] }];
+    await vi.advanceTimersByTimeAsync(100);
+    expect(listener).not.toHaveBeenCalled();
+    expect(root.getValue()).toBe(last);
+    expect(vi.getTimerCount()).toBe(0);
+  } finally {
+    vi.useRealTimers();
+  }
+});

package/src/runtime/useChatSnapshot.ts

@@ -0,0 +1,86 @@
+import { effectScope, toRaw, watch } from "vue";
+import { useMemo, useSyncExternalStore } from "@ulearning/ai-tap";
+import type { Chat } from "@ai-sdk/vue";
+import type { UIMessage } from "ai";
+import type { AISDKChatHelpers } from "../aiSDKExtras";
+
+/** One cached immutable snapshot per resource, without proxying message identities. */
+export const useChatSnapshot = <UI_MESSAGE extends UIMessage>(
+  chat: Chat<UI_MESSAGE>,
+  throttle: number | undefined,
+): AISDKChatHelpers<UI_MESSAGE> => {
+  const store = useMemo(() => {
+    let snapshot: AISDKChatHelpers<UI_MESSAGE> | undefined;
+    let source: UI_MESSAGE[] | undefined;
+    const setMessages: AISDKChatHelpers<UI_MESSAGE>["setMessages"] = (next) => {
+      chat.messages =
+        typeof next === "function" ? next(toRaw(chat.messages)) : next;
+    };
+    const read = () => {
+      const messages = chat.messages.map(toRaw);
+      const currentSource = toRaw(chat.messages);
+      const status = chat.status;
+      const error = chat.error === undefined ? undefined : toRaw(chat.error);
+      if (
+        snapshot &&
+        source === currentSource &&
+        snapshot.status === status &&
+        snapshot.error === error &&
+        snapshot.messages.length === messages.length &&
+        snapshot.messages.every((message, index) => message === messages[index])
+      )
+        return snapshot;
+      source = currentSource;
+      snapshot = {
+        id: chat.id,
+        messages,
+        status,
+        error,
+        setMessages,
+        sendMessage: chat.sendMessage,
+        regenerate: chat.regenerate,
+        stop: chat.stop,
+        resumeStream: chat.resumeStream,
+        clearError: chat.clearError,
+        addToolOutput: chat.addToolOutput,
+        addToolResult: chat.addToolResult,
+        addToolApprovalResponse: chat.addToolApprovalResponse,
+      };
+      return snapshot;
+    };
+    return {
+      read,
+      subscribe(listener: () => void) {
+        const scope = effectScope(true);
+        let timer: ReturnType<typeof setTimeout> | undefined;
+        scope.run(() =>
+          watch(
+            read,
+            () => {
+              if (
+                !throttle ||
+                chat.status === "ready" ||
+                chat.status === "error"
+              ) {
+                if (timer !== undefined) clearTimeout(timer);
+                timer = undefined;
+                listener();
+              } else if (timer === undefined) {
+                timer = setTimeout(() => {
+                  timer = undefined;
+                  listener();
+                }, throttle);
+              }
+            },
+            { flush: "sync" },
+          ),
+        );
+        return () => {
+          scope.stop();
+          if (timer !== undefined) clearTimeout(timer);
+        };
+      },
+    };
+  }, [chat, throttle]);
+  return useSyncExternalStore(store.subscribe, store.read, store.read);
+};

package/src/runtime/useChatThread.binding.test.tsx

@@ -0,0 +1,140 @@
+// @vitest-environment jsdom
+
+import { defineComponent, h, onMounted, Suspense } from "vue";
+import { render } from "./__tests__/vue";
+import { useTapRoot } from "@ulearning/ai-tap";
+import type { AssistantRuntime } from "@ulearning/ai-core";
+import type { ChatInit, ChatTransport, UIMessage } from "ai";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+import { AssistantChatTransport } from "../transport/AssistantChatTransport";
+import { DynamicChatTransport } from "./DynamicChatTransport";
+
+const mocks = vi.hoisted(() => ({
+  system: "",
+  useAISDKRuntime: vi.fn(),
+  transport: undefined as ChatTransport<UIMessage> | undefined,
+}));
+
+vi.mock("@ai-sdk/vue", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@ai-sdk/vue")>();
+  return {
+    ...actual,
+    Chat: class extends actual.Chat<UIMessage> {
+      constructor(config: ChatInit<UIMessage>) {
+        super(config);
+        mocks.transport = config.transport;
+      }
+    },
+  };
+});
+
+vi.mock("./useAISDKRuntime", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./useAISDKRuntime")>()),
+  useAISDKRuntime: mocks.useAISDKRuntime,
+}));
+
+import { useChatThread } from "./useChatThread";
+
+const createRuntime = (system: string) =>
+  ({
+    thread: {
+      getModelContext: () => ({ system }),
+      getState: () => ({ isLoading: false }),
+      subscribe: () => () => {},
+    },
+  }) as unknown as AssistantRuntime;
+
+describe("useChatThread transport binding", () => {
+  beforeEach(() => {
+    mocks.system = "";
+    mocks.useAISDKRuntime.mockReset();
+    mocks.transport = undefined;
+    mocks.useAISDKRuntime.mockImplementation(() => createRuntime(mocks.system));
+  });
+
+  it("keeps fallback wiring on committed values after an abandoned render", async () => {
+    const bodies: Array<{ id: string; system: string }> = [];
+    const sourceTransport = new AssistantChatTransport<UIMessage>({
+      fetch: vi.fn(async (_input, init) => {
+        bodies.push(JSON.parse(String(init?.body)));
+        return new Response(
+          new ReadableStream({ start: (controller) => controller.close() }),
+          { headers: { "content-type": "text/event-stream" } },
+        );
+      }),
+    });
+    const transport = new DynamicChatTransport(sourceTransport);
+    const pending = new Promise<never>(() => {});
+    let committedProxy: ChatTransport<UIMessage> | undefined;
+
+    const Blocker = defineComponent({
+      async setup() {
+        await pending;
+        return () => null;
+      },
+    });
+    const App = defineComponent(
+      (props: { system: string; remoteId: string; suspend: boolean }) => {
+        const root = useTapRoot(function ChatThreadBinding() {
+          mocks.system = props.system;
+          return useChatThread(
+            { transport },
+            {
+              id: "thread-id",
+              isMainThread: true,
+              getThreadListItem: () => ({
+                initialize: async () => ({
+                  remoteId: props.remoteId,
+                  externalId: undefined,
+                }),
+              }),
+            },
+          );
+        });
+        root.getValue();
+        const proxy = mocks.transport;
+        onMounted(() => {
+          committedProxy = proxy;
+        });
+        return () => (props.suspend ? h(Blocker) : null);
+      },
+      { props: ["system", "remoteId", "suspend"] },
+    );
+    const scene = (suspend: boolean) =>
+      h(Suspense, null, {
+        default: () =>
+          h(App, {
+            key: suspend ? "discarded" : "committed",
+            suspend,
+            system: suspend ? "discarded-system" : "committed-system",
+            remoteId: suspend ? "discarded-remote" : "committed-remote",
+          }),
+        fallback: () => null,
+      });
+    const view = render(scene(false));
+
+    transport.registerThread("thread-id", {});
+    await view.rerender(scene(true));
+
+    await committedProxy!.sendMessages({
+      trigger: "submit-message",
+      chatId: "thread-id",
+      messageId: undefined,
+      messages: [
+        {
+          id: "message-id",
+          role: "user",
+          parts: [{ type: "text", text: "hello" }],
+        },
+      ],
+      abortSignal: undefined,
+    });
+
+    expect(bodies).toEqual([
+      expect.objectContaining({
+        id: "committed-remote",
+        system: "committed-system",
+      }),
+    ]);
+  });
+});