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

package/src/tests/MessageParts.rendererOptions.test.tsx

@@ -0,0 +1,125 @@
+// @vitest-environment jsdom
+
+import { defineComponent, nextTick } from "vue";
+import { flushTapSync } from "@ulearning/ai-tap";
+import { createTestRoot } from "./vue";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import {
+  AssistantRuntimeProvider,
+  MessageByIndexProvider,
+  useExternalStoreRuntime,
+} from "@ulearning/ai-core/vue";
+import type { ThreadMessageLike } from "@ulearning/ai-core";
+import { MessagePrimitiveParts } from "../primitives/message/MessageParts";
+
+async function act<T>(action: () => T): Promise<Awaited<T>> {
+  const result = await flushTapSync(action);
+  await nextTick();
+  return result;
+}
+
+const messages: ThreadMessageLike[] = [
+  {
+    role: "assistant",
+    content: [
+      { type: "text", text: "Answer" },
+      { type: "reasoning", text: "Thinking" },
+      {
+        type: "generative-ui",
+        spec: {
+          root: [
+            { component: "Card", props: { title: "Result" } },
+            { component: "Unknown" },
+          ],
+        },
+      },
+      { type: "data", name: "chart", data: 42 },
+      { type: "data", name: "other", data: 7 },
+    ],
+  },
+];
+
+const components = {
+  generativeUI: {
+    components: {
+      Card: ({ title }: { title: string }) => <span>{title}</span>,
+    },
+    Fallback: ({ component }: { component: string }) => (
+      <span>Unavailable: {component}</span>
+    ),
+  },
+  data: {
+    by_name: {
+      chart: ({ data }: { data: unknown }) => (
+        <span>Chart: {String(data)}</span>
+      ),
+    },
+    Fallback: ({ data }: { data: unknown }) => (
+      <span>Data: {String(data)}</span>
+    ),
+  },
+};
+
+const App = defineComponent(
+  (props: MessagePrimitiveParts.Props) => {
+    const runtime = useExternalStoreRuntime({
+      messages,
+      convertMessage: (message) => message,
+      onNew: async () => {
+        throw new Error("This thread is read-only");
+      },
+    });
+    return () => (
+      <AssistantRuntimeProvider runtime={runtime}>
+        <MessageByIndexProvider index={0}>
+          <MessagePrimitiveParts {...props} />
+        </MessageByIndexProvider>
+      </AssistantRuntimeProvider>
+    );
+  },
+  { props: ["components", "children", "unstable_showEmptyOnNonTextEnd"] },
+);
+
+const ChainOfThought = () => <span>Thought group</span>;
+
+describe("MessagePrimitiveParts", () => {
+  let container: HTMLDivElement;
+  let root: ReturnType<typeof createTestRoot>;
+
+  beforeEach(() => {
+    container = document.createElement("div");
+    document.body.appendChild(container);
+    root = createTestRoot(container);
+  });
+
+  afterEach(async () => {
+    await act(async () => root.unmount());
+    container.remove();
+  });
+
+  it("renders generative UI and its fallback beside web text", async () => {
+    await act(async () => root.render(<App components={components} />));
+    expect(container.textContent).toBe(
+      "AnswerResultUnavailable: UnknownChart: 42Data: 7",
+    );
+  });
+
+  it("keeps data and generative UI when chain-of-thought grouping changes", async () => {
+    await act(async () => root.render(<App components={components} />));
+    expect(container.textContent).toBe(
+      "AnswerResultUnavailable: UnknownChart: 42Data: 7",
+    );
+
+    await act(async () =>
+      root.render(<App components={{ ...components, ChainOfThought }} />),
+    );
+    expect(container.textContent).toBe(
+      "AnswerThought groupResultUnavailable: UnknownChart: 42Data: 7",
+    );
+
+    await act(async () => root.render(<App components={components} />));
+    expect(container.textContent).toBe(
+      "AnswerResultUnavailable: UnknownChart: 42Data: 7",
+    );
+  });
+});

package/src/tests/RemoteThreadListRuntime.adapterProvider.test.tsx

@@ -0,0 +1,187 @@
+// @vitest-environment jsdom
+
+import { actAsync as act, cleanup, render } from "./vue";
+import { waitFor } from "@testing-library/dom";
+import { computed, defineComponent } from "vue";
+import { useState } from "@ulearning/ai-tap";
+import { afterEach, describe, expect, it } from "vitest";
+import {
+  RuntimeAdapterProvider,
+  useRemoteThreadListRuntime,
+  type RuntimeAdapters as RuntimeAdaptersShape,
+  useLocalRuntime,
+} from "@ulearning/ai-core/vue";
+import { useRuntimeAdaptersValue } from "@ulearning/ai-core/vue/internal";
+import { makeAdapter } from "./remote-thread-list-test-helpers";
+import { AssistantRuntimeProvider } from "../context";
+import type { ChatModelAdapter, RemoteThreadListAdapter } from "../index";
+import type { ThreadHistoryAdapter } from "@ulearning/ai-core";
+
+type CapturedAdapters = RuntimeAdaptersShape | null;
+
+afterEach(cleanup);
+
+const noOpAdapter: ChatModelAdapter = {
+  async *run() {},
+};
+
+const dummyHistory: ThreadHistoryAdapter = {
+  load: async () => ({ messages: [] }),
+  append: async () => {},
+};
+
+const makeRuntimeHook = (capture: {
+  adapters: CapturedAdapters;
+  calls?: CapturedAdapters[];
+}) =>
+  function useTestRuntimeHook() {
+    const adapters = useRuntimeAdaptersValue();
+    capture.calls?.push(adapters);
+    capture.adapters = adapters;
+    return useLocalRuntime(noOpAdapter);
+  };
+
+async function renderAndWaitForBinder(
+  adapter: RemoteThreadListAdapter,
+  capture: { adapters: CapturedAdapters },
+) {
+  const Inner = defineComponent(() => {
+    const runtime = useRemoteThreadListRuntime({
+      runtimeHook: makeRuntimeHook(capture),
+      adapter,
+    });
+    return () => (
+      <AssistantRuntimeProvider runtime={runtime}>
+        {null}
+      </AssistantRuntimeProvider>
+    );
+  });
+
+  // first thread instance arrives asynchronously via switchToNewThread.
+  await act(async () => {
+    render(<Inner />);
+  });
+  await waitFor(() => expect(capture.adapters).not.toBeNull());
+}
+
+const wrapInRuntimeAdapterProvider = (
+  history: ThreadHistoryAdapter,
+): NonNullable<RemoteThreadListAdapter["unstable_Provider"]> =>
+  defineComponent(function Provider(_props, { slots }) {
+    return () => (
+      <RuntimeAdapterProvider adapters={{ history }}>
+        {slots.default?.()}
+      </RuntimeAdapterProvider>
+    );
+  });
+
+describe("RemoteThreadListAdapter.unstable_Provider", () => {
+  it("makes Provider context visible to the runtime hook while preserving outer modelContext", async () => {
+    const capture: { adapters: CapturedAdapters; calls: CapturedAdapters[] } = {
+      adapters: null,
+      calls: [],
+    };
+    const adapter = makeAdapter({
+      unstable_Provider: wrapInRuntimeAdapterProvider(dummyHistory),
+    });
+    await renderAndWaitForBinder(adapter, capture);
+
+    expect(capture.calls[0]?.history).toBe(dummyHistory);
+    expect(capture.adapters?.history).toBe(dummyHistory);
+    expect(capture.adapters?.modelContext).toBeDefined();
+  });
+
+  it("returns no history when no Provider is supplied", async () => {
+    const capture: { adapters: CapturedAdapters } = { adapters: null };
+    const adapter = makeAdapter();
+    await renderAndWaitForBinder(adapter, capture);
+
+    expect(capture.adapters?.history).toBeUndefined();
+  });
+
+  it("makes useAdapters context visible when no Provider is supplied", async () => {
+    const capture: { adapters: CapturedAdapters } = { adapters: null };
+    const adapter = makeAdapter({
+      unstable_useAdapters: function useTestAdapters() {
+        return { history: dummyHistory };
+      },
+    });
+    await renderAndWaitForBinder(adapter, capture);
+
+    expect(capture.adapters?.history).toBe(dummyHistory);
+  });
+
+  it("picks up a post-mount useAdapters bag", async () => {
+    const capture: { adapters: CapturedAdapters } = { adapters: null };
+    const firstHistory: ThreadHistoryAdapter = {
+      load: async () => ({ messages: [] }),
+      append: async () => {},
+    };
+    const secondHistory: ThreadHistoryAdapter = {
+      load: async () => ({ messages: [] }),
+      append: async () => {},
+    };
+
+    let bump: (() => void) | undefined;
+    const adapter = makeAdapter({
+      unstable_useAdapters: function useTestAdapters() {
+        const [swapped, setSwapped] = useState(false);
+        bump = () => setSwapped(true);
+        return { history: swapped ? secondHistory : firstHistory };
+      },
+    });
+
+    await renderAndWaitForBinder(adapter, capture);
+    expect(capture.adapters?.history).toBe(firstHistory);
+
+    await act(async () => {
+      bump!();
+    });
+
+    expect(capture.adapters?.history).toBe(secondHistory);
+  });
+
+  it("picks up a swapped Provider on re-render", async () => {
+    const capture: { adapters: CapturedAdapters } = { adapters: null };
+    const firstHistory: ThreadHistoryAdapter = {
+      load: async () => ({ messages: [] }),
+      append: async () => {},
+    };
+    const secondHistory: ThreadHistoryAdapter = {
+      load: async () => ({ messages: [] }),
+      append: async () => {},
+    };
+
+    const Inner = defineComponent(
+      (props: { history: ThreadHistoryAdapter }) => {
+        const adapter = computed(() =>
+          makeAdapter({
+            unstable_Provider: wrapInRuntimeAdapterProvider(props.history),
+          }),
+        );
+        const runtimeHook = makeRuntimeHook(capture);
+        const runtime = useRemoteThreadListRuntime(() => ({
+          runtimeHook,
+          adapter: adapter.value,
+        }));
+        return () => (
+          <AssistantRuntimeProvider runtime={runtime}>
+            {null}
+          </AssistantRuntimeProvider>
+        );
+      },
+      { props: ["history"] },
+    );
+
+    let result: ReturnType<typeof render>;
+    await act(async () => {
+      result = render(<Inner history={firstHistory} />);
+    });
+    await waitFor(() => expect(capture.adapters?.history).toBe(firstHistory));
+
+    await act(async () => {
+      await result!.rerender(<Inner history={secondHistory} />);
+    });
+    await waitFor(() => expect(capture.adapters?.history).toBe(secondHistory));
+  });
+});

package/src/tests/RemoteThreadListRuntime.deferredProvider.test.tsx

@@ -0,0 +1,99 @@
+// @vitest-environment jsdom
+
+import { act, cleanup, render } from "./vue";
+import { defineComponent, shallowRef } from "vue";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  useRemoteThreadListRuntime,
+  useLocalRuntime,
+} from "@ulearning/ai-core/vue";
+import { makeAdapter } from "./remote-thread-list-test-helpers";
+import type { AssistantRuntime } from "@ulearning/ai-core";
+import { useAui } from "@ulearning/ai-store";
+import { AssistantRuntimeProvider } from "../context";
+import type { ChatModelAdapter, RemoteThreadListAdapter } from "../index";
+
+const noOpAdapter: ChatModelAdapter = {
+  async *run() {},
+};
+
+const useTestRuntimeHook = () => useLocalRuntime(noOpAdapter);
+
+const RuntimeProvider = defineComponent(
+  (props: { adapter: RemoteThreadListAdapter }, { slots }) => {
+    const runtime = useRemoteThreadListRuntime(() => ({
+      runtimeHook: useTestRuntimeHook,
+      adapter: props.adapter,
+    }));
+    return () => (
+      <AssistantRuntimeProvider runtime={runtime}>
+        {slots.default?.()}
+      </AssistantRuntimeProvider>
+    );
+  },
+  { props: ["adapter"] },
+);
+
+const RuntimeCapture = defineComponent(
+  (props: { runtimeRef: { current: AssistantRuntime | null } }) => {
+    const aui = useAui();
+    props.runtimeRef.current =
+      aui.threads.__internal_getAssistantRuntime?.() ?? null;
+    return () => null;
+  },
+  { props: ["runtimeRef"] },
+);
+
+afterEach(() => {
+  cleanup();
+  vi.useRealTimers();
+});
+
+describe("useRemoteThreadListRuntime with unstable_Provider", () => {
+  it("composer.setText works when unstable_Provider renders children unconditionally", () => {
+    const Provider = defineComponent(
+      (_props, { slots }) =>
+        () =>
+          slots.default?.(),
+    );
+    const adapter = makeAdapter({ unstable_Provider: Provider });
+
+    const runtimeRef: { current: AssistantRuntime | null } = { current: null };
+    render(
+      <RuntimeProvider adapter={adapter}>
+        <RuntimeCapture runtimeRef={runtimeRef} />
+      </RuntimeProvider>,
+    );
+
+    const runtime = runtimeRef.current;
+    expect(runtime).toBeTruthy();
+    expect(() => runtime!.thread.composer.setText("hello")).not.toThrow();
+  });
+
+  it("warns in dev when unstable_Provider defers children", () => {
+    vi.useFakeTimers();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+
+    const Provider = defineComponent((_props, { slots }) => {
+      const ready = shallowRef(false);
+      return () => (ready.value ? slots.default?.() : null);
+    });
+    const adapter = makeAdapter({ unstable_Provider: Provider });
+
+    render(
+      <RuntimeProvider adapter={adapter}>
+        <div />
+      </RuntimeProvider>,
+    );
+
+    act(() => {
+      vi.advanceTimersByTime(150);
+    });
+
+    expect(warn).toHaveBeenCalledWith(
+      expect.stringContaining("did not render its default slot synchronously"),
+    );
+
+    warn.mockRestore();
+  });
+});

package/src/tests/RemoteThreadListRuntime.reloadMainThread.test.tsx

@@ -0,0 +1,113 @@
+// @vitest-environment jsdom
+
+import { actAsync as act, cleanup, render } from "./vue";
+import { waitFor } from "@testing-library/dom";
+import { defineComponent } from "vue";
+import { useEffect } from "@ulearning/ai-tap";
+import { afterEach, describe, expect, it } from "vitest";
+import type { AssistantRuntime } from "@ulearning/ai-core";
+import {
+  useRemoteThreadListRuntime,
+  useLocalRuntime,
+} from "@ulearning/ai-core/vue";
+import {
+  makeAdapter,
+  settleOutsideAct,
+} from "./remote-thread-list-test-helpers";
+import { AssistantRuntimeProvider } from "../context";
+import type { ChatModelAdapter } from "../index";
+
+afterEach(cleanup);
+
+const noOpAdapter: ChatModelAdapter = {
+  async *run() {},
+};
+
+const renderThreadList = async (mounts: { count: number }) => {
+  const capture: { runtime: AssistantRuntime | null } = { runtime: null };
+
+  const adapter = makeAdapter({
+    list: async () => ({
+      threads: [
+        {
+          status: "regular" as const,
+          remoteId: "t-1",
+          externalId: "t-1",
+          title: "Open",
+        },
+      ],
+    }),
+  });
+
+  const Inner = defineComponent(() => {
+    const runtime = useRemoteThreadListRuntime({
+      runtimeHook: function useTestRuntimeHook() {
+        useEffect(() => {
+          mounts.count++;
+        }, []);
+        return useLocalRuntime(noOpAdapter);
+      },
+      adapter,
+    });
+    capture.runtime = runtime;
+    return () => (
+      <AssistantRuntimeProvider runtime={runtime}>
+        {null}
+      </AssistantRuntimeProvider>
+    );
+  });
+
+  await act(async () => {
+    render(<Inner />);
+  });
+  await waitFor(() => expect(capture.runtime).not.toBeNull());
+  return capture;
+};
+
+// binders mount asynchronously, so a snapshot taken too early attributes a
+// still-pending mount to whatever ran next
+const settle = async (mounts: { count: number }) => {
+  let previous = -1;
+  await waitFor(() => {
+    const seen = mounts.count;
+    const stable = seen === previous;
+    previous = seen;
+    expect(stable).toBe(true);
+  });
+  return mounts.count;
+};
+
+describe("threads.reloadMainThread", () => {
+  it("remounts the runtime hook of the open thread", async () => {
+    const mounts = { count: 0 };
+    const capture = await renderThreadList(mounts);
+    const runtime = capture.runtime!;
+
+    await settleOutsideAct(() => runtime.threads.switchToThread("t-1"));
+    const beforeReload = await settle(mounts);
+    expect(beforeReload).toBeGreaterThan(0);
+
+    await settleOutsideAct(() => runtime.threads.reloadMainThread());
+
+    await waitFor(() => expect(mounts.count).toBeGreaterThan(beforeReload));
+  });
+
+  it("keeps a thread runtime readable across the remount", async () => {
+    const mounts = { count: 0 };
+    const capture = await renderThreadList(mounts);
+    const runtime = capture.runtime!;
+
+    await settleOutsideAct(() => runtime.threads.switchToThread("t-1"));
+
+    const seen: boolean[] = [];
+    const unsubscribe = runtime.threads.subscribe(() => {
+      seen.push(runtime.threads.getState().mainThreadId === "t-1");
+    });
+
+    await settleOutsideAct(() => runtime.threads.reloadMainThread());
+    unsubscribe();
+
+    expect(seen.length).toBeGreaterThan(0);
+    expect(seen.every(Boolean)).toBe(true);
+  });
+});

package/src/tests/augmentations.test.ts

@@ -0,0 +1,95 @@
+import { describe, expectTypeOf, it } from "vitest";
+import type { UserCommands, UserExternalState } from "../augmentations";
+import type {
+  AssistantTransportCommand,
+  SendCommandsRequestBody,
+  useAssistantTransportRuntime,
+  useAssistantTransportSendCommand,
+  useAssistantTransportState,
+} from "../index";
+
+declare module "../augmentations" {
+  namespace Assistant {
+    interface Commands {
+      reactCommand: { type: "react-command"; data: number };
+    }
+    interface ExternalState {
+      reactState: { fromReact: boolean };
+    }
+  }
+}
+
+declare module "@ulearning/ai-core" {
+  namespace Assistant {
+    interface Commands {
+      coreCommand: { type: "core-command" };
+    }
+    interface ExternalState {
+      coreState: { fromCore: boolean };
+    }
+  }
+}
+
+describe("Assistant augmentations", () => {
+  it("react-side contributions reach UserCommands and UserExternalState", () => {
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<UserCommands>();
+    expectTypeOf<{ fromReact: boolean }>().toExtend<UserExternalState>();
+  });
+
+  it("core-side contributions flow into the react-side unions", () => {
+    expectTypeOf<{ type: "core-command" }>().toExtend<UserCommands>();
+    expectTypeOf<{ fromCore: boolean }>().toExtend<UserExternalState>();
+  });
+
+  it("react-side contributions reach the public transport types", () => {
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<AssistantTransportCommand>();
+    expectTypeOf<{ fromReact: boolean }>().toExtend<
+      ReturnType<typeof useAssistantTransportState>["value"]
+    >();
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<
+      Parameters<ReturnType<typeof useAssistantTransportSendCommand>>[0]
+    >();
+    type RuntimeOptions = Parameters<typeof useAssistantTransportRuntime>[0];
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<
+      Parameters<RuntimeOptions["converter"]>[1]["pendingCommands"][number]
+    >();
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<
+      Parameters<NonNullable<RuntimeOptions["onError"]>>[1]["commands"][number]
+    >();
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<
+      Parameters<NonNullable<RuntimeOptions["onCancel"]>>[0]["commands"][number]
+    >();
+    expectTypeOf<{
+      type: "react-command";
+      data: number;
+    }>().toExtend<
+      Parameters<
+        NonNullable<RuntimeOptions["prepareSendCommandsRequest"]>
+      >[0]["commands"][number]
+    >();
+  });
+
+  it("the react request body keeps the core request fields", () => {
+    expectTypeOf<Pick<SendCommandsRequestBody, "threadId">>().toEqualTypeOf<{
+      threadId?: string;
+    }>();
+  });
+});