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

package/src/runtime/useChatRuntime.test.ts

@@ -0,0 +1,619 @@
+// @vitest-environment jsdom
+
+import type { Chat } from "@ai-sdk/vue";
+import type { ChatInit, ChatTransport, UIMessage, UIMessageChunk } from "ai";
+import { defineComponent, h, shallowRef } from "vue";
+import { useTapRoot } from "@ulearning/ai-tap";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { act, render, waitFor } from "./__tests__/vue";
+import type { UseChatRuntimeOptions } from "./useChatRuntime";
+import type { ResumableClientStorage } from "../transport/resumable";
+
+const mocks = vi.hoisted(() => {
+  const state = {
+    isLoadingHistory: false,
+    threadId: "thread-id",
+    mainThreadId: "thread-id",
+  };
+  const subscribers = new Set<() => void>();
+  const chats: Array<{ chat: Chat<UIMessage>; init: ChatInit<UIMessage> }> = [];
+  const runtime = {
+    thread: {
+      getState: () => ({ isLoading: state.isLoadingHistory }),
+      getModelContext: () => ({}),
+      subscribe: (callback: () => void) => {
+        subscribers.add(callback);
+        return () => {
+          subscribers.delete(callback);
+        };
+      },
+    },
+    threads: { mainItem: undefined },
+  };
+  return {
+    state,
+    subscribers,
+    runtime,
+    chats,
+    snapshot:
+      vi.fn<(chat: Chat<UIMessage>, throttle: number | undefined) => void>(),
+    useAISDKRuntime: vi.fn<
+      (_chat: unknown, _options: unknown) => typeof runtime
+    >(() => runtime),
+  };
+});
+
+// Keep actual Chat requests, callbacks and native subscriptions. Observe only
+// its public construction and resume entry point, without replacing results.
+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(init: ChatInit<UIMessage>) {
+        super(init);
+        const chat: Chat<UIMessage> = this;
+        vi.spyOn(chat, "resumeStream");
+        mocks.chats.push({ chat, init });
+      }
+    },
+  };
+});
+
+vi.mock("./useChatSnapshot", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("./useChatSnapshot")>();
+  return {
+    ...actual,
+    useChatSnapshot(chat: Chat<UIMessage>, throttle: number | undefined) {
+      mocks.snapshot(chat, throttle);
+      return actual.useChatSnapshot(chat, throttle);
+    },
+  };
+});
+
+vi.mock("@ulearning/ai-core/vue", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("@ulearning/ai-core/vue")>()),
+  useRemoteThreadListRuntime: ({
+    runtimeHook,
+  }: {
+    runtimeHook: () => unknown;
+  }) => runtimeHook(),
+}));
+
+vi.mock("@ulearning/ai-store", async (importOriginal) => {
+  const actual = await importOriginal<typeof import("@ulearning/ai-store")>();
+  const { useMemo } = await import("@ulearning/ai-tap");
+  return {
+    ...actual,
+    useAui: () =>
+      useMemo(() => {
+        const id = mocks.state.threadId;
+        const mainThreadId = mocks.state.mainThreadId;
+        return {
+          subscribe: () => () => {},
+          threadListItem: { source: undefined, getState: () => ({ id }) },
+          threads: { getState: () => ({ mainThreadId }) },
+        };
+      }, []),
+  };
+});
+
+vi.mock("./useAISDKRuntime", async (importOriginal) => ({
+  ...(await importOriginal<typeof import("./useAISDKRuntime")>()),
+  useAISDKRuntime: mocks.useAISDKRuntime,
+}));
+
+import { AssistantChatTransport } from "../transport/AssistantChatTransport";
+import {
+  createResumableSessionStorage,
+  RESUMABLE_STREAM_ID_HEADER,
+} from "../transport/resumable";
+import { getResumedStreamIds } from "./DynamicChatTransport";
+import { useChatRuntime } from "./useChatRuntime";
+
+const sendMessagesOptions: Parameters<
+  ChatTransport<UIMessage>["sendMessages"]
+>[0] = {
+  trigger: "submit-message",
+  chatId: "thread-id",
+  messageId: undefined,
+  messages: [{ id: "m1", role: "user", parts: [{ type: "text", text: "hi" }] }],
+  abortSignal: undefined,
+};
+
+function mountRuntime(initial: UseChatRuntimeOptions = {}) {
+  const options = shallowRef(initial);
+  const view = render(
+    h(
+      defineComponent({
+        setup() {
+          const root = useTapRoot(function useRuntimeFixture() {
+            return useChatRuntime(options.value);
+          });
+          root.getValue();
+          return () => null;
+        },
+      }),
+    ),
+  );
+  return {
+    ...view,
+    async rerender(next: UseChatRuntimeOptions = options.value) {
+      await act(() => {
+        options.value = { ...next };
+      });
+    },
+  };
+}
+
+function observedChat(index = 0) {
+  const observed = mocks.chats[index];
+  if (!observed) throw new Error(`Missing actual Chat construction ${index}`);
+  return observed;
+}
+
+function resumableTransport(
+  storage: ResumableClientStorage,
+  reconnectToStream: ChatTransport<UIMessage>["reconnectToStream"] = async () =>
+    null,
+): ChatTransport<UIMessage> & {
+  getResumableAdapter: () => {
+    storage: ResumableClientStorage;
+    resumeApi: string;
+  };
+} {
+  return {
+    sendMessages: async () =>
+      new ReadableStream<UIMessageChunk>({
+        start: (controller) => controller.close(),
+      }),
+    reconnectToStream,
+    getResumableAdapter: () => ({ storage, resumeApi: "/api/chat/resume" }),
+  };
+}
+
+function observableStorage(initial: string | null = null) {
+  let streamId = initial;
+  const subscribers = new Set<() => void>();
+  const storage: ResumableClientStorage = {
+    getStreamId: () => streamId,
+    setStreamId: (id) => {
+      streamId = id;
+      subscribers.forEach((callback) => callback());
+    },
+    clear: vi.fn(() => {
+      streamId = null;
+      subscribers.forEach((callback) => callback());
+    }),
+    subscribe: (callback) => {
+      subscribers.add(callback);
+      return () => {
+        subscribers.delete(callback);
+      };
+    },
+  };
+  return storage;
+}
+
+describe("useChatRuntime", () => {
+  afterEach(() => vi.restoreAllMocks());
+  beforeEach(() => {
+    mocks.snapshot.mockClear();
+    mocks.useAISDKRuntime.mockClear();
+    mocks.useAISDKRuntime.mockImplementation(() => mocks.runtime);
+    mocks.state.isLoadingHistory = false;
+    mocks.state.threadId = "thread-id";
+    mocks.state.mainThreadId = "thread-id";
+    mocks.subscribers.clear();
+    mocks.chats.length = 0;
+    window.sessionStorage.clear();
+  });
+
+  it("refreshes AssistantChatTransport wiring when the runtime changes", async () => {
+    const bodies: Array<{ system: string }> = [];
+    const transport = new AssistantChatTransport({
+      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 createRuntime = (system: string) => ({
+      thread: {
+        getState: () => ({ isLoading: false }),
+        getModelContext: () => ({ system }),
+        subscribe: () => () => {},
+      },
+      threads: { mainItem: undefined },
+    });
+    let currentRuntime = createRuntime("system-a");
+    mocks.useAISDKRuntime.mockImplementation(() => currentRuntime);
+    const view = mountRuntime({ transport });
+    const dynamicTransport = observedChat().init.transport;
+    if (!dynamicTransport) throw new Error("Missing real Chat transport");
+    await dynamicTransport.sendMessages(sendMessagesOptions);
+    currentRuntime = createRuntime("system-b");
+    await view.rerender();
+    await dynamicTransport.sendMessages(sendMessagesOptions);
+    expect(bodies).toEqual([
+      expect.objectContaining({ system: "system-a" }),
+      expect.objectContaining({ system: "system-b" }),
+    ]);
+    expect(mocks.chats).toHaveLength(1);
+  });
+
+  it("forwards a callback through a ref, so a later render's callback fires instead of the mounted one", async () => {
+    const onToolCallA = vi.fn();
+    const onToolCallB = vi.fn();
+    const view = mountRuntime({ onToolCall: onToolCallA });
+    const callback = observedChat().init.onToolCall;
+    if (!callback) throw new Error("Missing forwarded Chat callback");
+    const first: Parameters<typeof callback>[0] = {
+      toolCall: {
+        toolCallId: "first",
+        toolName: "test",
+        input: {},
+        dynamic: true,
+      },
+    };
+    const second: Parameters<typeof callback>[0] = {
+      toolCall: {
+        toolCallId: "second",
+        toolName: "test",
+        input: {},
+        dynamic: true,
+      },
+    };
+    await callback(first);
+    expect(onToolCallA).toHaveBeenCalledExactlyOnceWith(first);
+    await view.rerender({ onToolCall: onToolCallB });
+    await callback(second);
+    expect(onToolCallB).toHaveBeenCalledExactlyOnceWith(second);
+    expect(onToolCallA).toHaveBeenCalledOnce();
+    expect(mocks.chats).toHaveLength(1);
+  });
+
+  it("coerces an unset sendAutomaticallyWhen to false, matching useChat's own default", async () => {
+    mountRuntime();
+    const callback = observedChat().init.sendAutomaticallyWhen;
+    if (!callback) throw new Error("Missing Chat automatic-send callback");
+    expect(await callback({ messages: [] })).toBe(false);
+  });
+
+  it("forwards a defined chat update throttle to useChat", () => {
+    mountRuntime({ throttle: 50 });
+    mountRuntime({ throttle: undefined });
+    expect(mocks.snapshot).toHaveBeenNthCalledWith(1, observedChat(0).chat, 50);
+    expect(mocks.snapshot.mock.calls[1]).toEqual([
+      observedChat(1).chat,
+      undefined,
+    ]);
+  });
+
+  it("forwards a custom approval handler to the runtime only", () => {
+    const onRespondToToolApproval = vi.fn();
+    mountRuntime({ onRespondToToolApproval });
+    expect(mocks.useAISDKRuntime).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ onRespondToToolApproval }),
+    );
+    expect(observedChat().init).not.toHaveProperty("onRespondToToolApproval");
+  });
+
+  it("forwards unstable_enableMessageQueue to the runtime, not the chat", () => {
+    mountRuntime({ unstable_enableMessageQueue: true });
+    expect(mocks.useAISDKRuntime).toHaveBeenCalledWith(
+      expect.anything(),
+      expect.objectContaining({ unstable_enableMessageQueue: true }),
+    );
+    expect(observedChat().init).not.toHaveProperty(
+      "unstable_enableMessageQueue",
+    );
+  });
+
+  it("waits for external history to load before resuming a stream", async () => {
+    mocks.state.isLoadingHistory = true;
+    const transport = resumableTransport(observableStorage("stream-1"));
+    mountRuntime({ transport });
+    const resumeStream = observedChat().chat.resumeStream;
+    expect(resumeStream).not.toHaveBeenCalled();
+    await act(() => {
+      mocks.state.isLoadingHistory = false;
+      mocks.subscribers.forEach((callback) => callback());
+    });
+    await waitFor(() => expect(resumeStream).toHaveBeenCalledTimes(1));
+  });
+
+  it("resumes a stream id discovered after mount", async () => {
+    const storage = observableStorage();
+    const reconnect = vi.fn<ChatTransport<UIMessage>["reconnectToStream"]>(
+      async () => null,
+    );
+    mountRuntime({ transport: resumableTransport(storage, reconnect) });
+    const resumeStream = observedChat().chat.resumeStream;
+    expect(resumeStream).not.toHaveBeenCalled();
+    await act(() => storage.setStreamId("stream-1"));
+    await waitFor(() => expect(resumeStream).toHaveBeenCalledTimes(1));
+    await act(() => storage.setStreamId("stream-1"));
+    expect(resumeStream).toHaveBeenCalledTimes(1);
+    await act(() => storage.setStreamId("stream-2"));
+    await waitFor(() => expect(resumeStream).toHaveBeenCalledTimes(2));
+    await act(() => storage.setStreamId("stream-1"));
+    expect(resumeStream).toHaveBeenCalledTimes(2);
+    expect(reconnect).toHaveBeenCalledTimes(2);
+  });
+
+  it("does not resume the same stored id again after a remount", async () => {
+    const storage = createResumableSessionStorage({ key: "remount-stream-id" });
+    storage.setStreamId("stream-1", "thread-id");
+    const transport = resumableTransport(storage);
+    const first = mountRuntime({ transport });
+    const resumeStream = observedChat().chat.resumeStream;
+    await waitFor(() => expect(resumeStream).toHaveBeenCalledOnce());
+    first.unmount();
+    mountRuntime({ transport });
+    expect(resumeStream).toHaveBeenCalledOnce();
+    expect(observedChat(1).chat.resumeStream).not.toHaveBeenCalled();
+  });
+
+  it("does not resume a stream id written by an active send", async () => {
+    const storage = createResumableSessionStorage({
+      key: "active-send-stream-id",
+    });
+    let streamController:
+      | ReadableStreamDefaultController<Uint8Array>
+      | undefined;
+    const fetchMock = vi.fn(
+      async () =>
+        new Response(
+          new ReadableStream<Uint8Array>({
+            start: (controller) => {
+              streamController = controller;
+            },
+          }),
+          {
+            status: 200,
+            headers: {
+              "content-type": "text/event-stream",
+              [RESUMABLE_STREAM_ID_HEADER]: "stream-1",
+            },
+          },
+        ),
+    );
+    const transport = new AssistantChatTransport({
+      fetch: fetchMock,
+      resumable: { storage, resumeApi: "/api/chat/resume" },
+    });
+    mountRuntime({ transport });
+    const { chat } = observedChat();
+    const send = chat.sendMessage({ text: "hi" });
+    await waitFor(() =>
+      expect(storage.getStreamId("thread-id")).toBe("stream-1"),
+    );
+    if (!streamController) throw new Error("Missing real response stream");
+    streamController.enqueue(
+      new TextEncoder().encode(
+        [
+          'data: {"type":"start","messageId":"active-message"}',
+          "",
+          'data: {"type":"text-start","id":"text"}',
+          "",
+          'data: {"type":"text-delta","id":"text","delta":"hi"}',
+          "",
+          "",
+        ].join("\n"),
+      ),
+    );
+    await waitFor(() => expect(chat.status).toBe("streaming"));
+    streamController.enqueue(
+      new TextEncoder().encode(
+        'data: {"type":"text-end","id":"text"}\n\ndata: {"type":"finish"}\n\ndata: [DONE]\n\n',
+      ),
+    );
+    streamController.close();
+    await send;
+    await waitFor(() => expect(chat.status).toBe("ready"));
+    expect(chat.resumeStream).not.toHaveBeenCalled();
+    expect(fetchMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("does not broadcast a stream id to another mounted thread", async () => {
+    const storage = createResumableSessionStorage({
+      key: "multi-thread-stream-id",
+    });
+    let streamController:
+      | ReadableStreamDefaultController<UIMessageChunk>
+      | undefined;
+    const transport = resumableTransport(storage);
+    transport.sendMessages = async () =>
+      new ReadableStream<UIMessageChunk>({
+        start(controller) {
+          streamController = controller;
+          controller.enqueue({ type: "start", messageId: "thread-b-message" });
+          controller.enqueue({ type: "text-start", id: "text" });
+          controller.enqueue({
+            type: "text-delta",
+            id: "text",
+            delta: "streaming",
+          });
+        },
+      });
+    mocks.state.threadId = "thread-a";
+    mocks.state.mainThreadId = "thread-a";
+    mountRuntime({ transport });
+    const threadA = observedChat().chat;
+    mocks.state.threadId = "thread-b";
+    mocks.state.mainThreadId = "thread-b";
+    mountRuntime({ transport });
+    const threadB = observedChat(1).chat;
+    const send = threadB.sendMessage({ text: "hi" });
+    await waitFor(() => expect(threadB.status).toBe("streaming"));
+    await act(() => storage.setStreamId("stream-b", "thread-b"));
+    if (!streamController) throw new Error("Missing real thread B stream");
+    streamController.enqueue({ type: "text-end", id: "text" });
+    streamController.enqueue({ type: "finish" });
+    streamController.close();
+    await send;
+    await waitFor(() => expect(threadB.status).toBe("ready"));
+    expect(threadA.resumeStream).not.toHaveBeenCalled();
+    expect(threadB.resumeStream).not.toHaveBeenCalled();
+  });
+
+  it("resumes a persisted stream after reload changes the local thread id", async () => {
+    const storageKey = "reload-stream-id";
+    createResumableSessionStorage({ key: storageKey }).setStreamId(
+      "stream-a",
+      "__LOCALID_before_reload",
+    );
+    const storage = createResumableSessionStorage({ key: storageKey });
+    const transport = resumableTransport(storage);
+    mocks.state.threadId = "__LOCALID_background";
+    mocks.state.mainThreadId = "__LOCALID_after_reload";
+    mountRuntime({ transport });
+    const backgroundThread = observedChat().chat;
+    mocks.state.threadId = "__LOCALID_after_reload";
+    mountRuntime({ transport });
+    const mainThread = observedChat(1).chat;
+    expect(backgroundThread.resumeStream).not.toHaveBeenCalled();
+    await waitFor(() => expect(mainThread.resumeStream).toHaveBeenCalledOnce());
+  });
+
+  it("observes resumable storage from a replacement transport", async () => {
+    const storageA = observableStorage();
+    const storageB = observableStorage("stream-b");
+    const transportA = resumableTransport(storageA);
+    const transportB = resumableTransport(storageB);
+    const view = mountRuntime({ transport: transportA });
+    const resumeStream = observedChat().chat.resumeStream;
+    expect(resumeStream).not.toHaveBeenCalled();
+    await view.rerender({ transport: transportB });
+    await waitFor(() => expect(resumeStream).toHaveBeenCalledTimes(1));
+  });
+
+  it("does not resume an unchanged stream id already handled by replacement storage", async () => {
+    mocks.state.isLoadingHistory = true;
+    const storageA = observableStorage("stream-1");
+    const storageB = observableStorage("stream-1");
+    getResumedStreamIds(storageB).add("stream-1");
+    const view = mountRuntime({ transport: resumableTransport(storageA) });
+    const resumeStream = observedChat().chat.resumeStream;
+    mocks.state.isLoadingHistory = false;
+    await view.rerender({ transport: resumableTransport(storageB) });
+    expect(resumeStream).not.toHaveBeenCalled();
+  });
+
+  it("does not clear a newer stream id when an older resume fails", async () => {
+    const storage = observableStorage("stream-1");
+    const error = new Error("resume failed");
+    let rejectFirstResume: ((error: Error) => void) | undefined;
+    const reconnect = vi
+      .fn<ChatTransport<UIMessage>["reconnectToStream"]>()
+      .mockImplementationOnce(
+        () =>
+          new Promise((_resolve, reject) => {
+            rejectFirstResume = reject;
+          }),
+      )
+      .mockResolvedValueOnce(null);
+    const onResumeError = vi.fn();
+    const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+    mountRuntime({
+      transport: resumableTransport(storage, reconnect),
+      onResumeError,
+    });
+    const resumeStream = observedChat().chat.resumeStream;
+    await waitFor(() => expect(resumeStream).toHaveBeenCalledTimes(1));
+    await act(() => storage.setStreamId("stream-2"));
+    await waitFor(() => expect(resumeStream).toHaveBeenCalledTimes(2));
+    const reject = rejectFirstResume;
+    if (!reject)
+      throw new Error("First real reconnect request was not pending");
+    await act(() => reject(error));
+    await waitFor(() => expect(onResumeError).toHaveBeenCalledWith(error));
+    expect(storage.getStreamId()).toBe("stream-2");
+    expect(storage.clear).not.toHaveBeenCalled();
+    warn.mockRestore();
+  });
+
+  it.each([undefined, false, true])(
+    "keeps failed automatic checkpoints only when canResume is %s",
+    async (canResume) => {
+      const error = new Error("resume failed");
+      const clear = vi.fn();
+      const storage: ResumableClientStorage = {
+        getStreamId: () => "stream-1",
+        setStreamId: vi.fn(),
+        clear,
+      };
+      const onResumeError = vi.fn();
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+      mountRuntime({
+        transport: resumableTransport(storage, async () => {
+          throw error;
+        }),
+        onResumeError,
+        canResume,
+      });
+      const resumeStream = observedChat().chat.resumeStream;
+      await waitFor(() => expect(onResumeError).toHaveBeenCalledWith(error));
+      expect(resumeStream).toHaveBeenCalledTimes(1);
+      if (canResume) {
+        expect(clear).not.toHaveBeenCalled();
+      } else {
+        expect(clear).toHaveBeenCalledOnce();
+        expect(onResumeError.mock.invocationCallOrder[0]).toBeLessThan(
+          clear.mock.invocationCallOrder[0]!,
+        );
+      }
+      expect(warn).toHaveBeenCalledWith(
+        "[assistant-ui] resumable: resume failed",
+        error,
+      );
+      warn.mockRestore();
+    },
+  );
+
+  it.each([undefined, false, true])(
+    "applies the canResume=%s checkpoint policy even when onResumeError throws",
+    async (canResume) => {
+      const error = new Error("resume failed");
+      const callbackError = new Error("callback failed");
+      const clear = vi.fn();
+      const storage: ResumableClientStorage = {
+        getStreamId: () => "stream-1",
+        setStreamId: vi.fn(),
+        clear,
+      };
+      const onResumeError = vi.fn(() => {
+        throw callbackError;
+      });
+      const warn = vi.spyOn(console, "warn").mockImplementation(() => {});
+      const consoleError = vi
+        .spyOn(console, "error")
+        .mockImplementation(() => {});
+      mountRuntime({
+        transport: resumableTransport(storage, async () => {
+          throw error;
+        }),
+        onResumeError,
+        canResume,
+      });
+      await waitFor(() => expect(onResumeError).toHaveBeenCalledWith(error));
+      if (canResume) {
+        expect(clear).not.toHaveBeenCalled();
+      } else {
+        expect(clear).toHaveBeenCalledOnce();
+      }
+      expect(consoleError).toHaveBeenCalledWith(
+        "[assistant-ui] resumable: onResumeError callback failed",
+        callbackError,
+      );
+      warn.mockRestore();
+      consoleError.mockRestore();
+    },
+  );
+});

package/src/runtime/useChatRuntime.ts

@@ -0,0 +1,80 @@
+"use client";
+
+import type { UIMessage } from "ai";
+import type { AssistantRuntime } from "@ulearning/ai-core";
+import { useRemoteThreadListRuntime } from "@ulearning/ai-core/vue";
+import { useAui } from "@ulearning/ai-store";
+import type { ChatTransport } from "ai";
+import { useMemo, useState } from "@ulearning/ai-tap";
+import { AssistantChatTransport } from "../transport/AssistantChatTransport";
+import { useChatThread, type ChatThreadOptions } from "./useChatThread";
+import { useDynamicChatTransport } from "./useDynamicChatTransport";
+import { useHostDestroySignal } from "@ulearning/ai-store/internal";
+import { isResourceExecution } from "@ulearning/ai-tap/internal";
+import { toValue, type MaybeRefOrGetter } from "vue";
+import { useRuntimeResource } from "@ulearning/ai-core/vue/internal";
+import { useSyncExternalStore } from "@ulearning/ai-tap";
+import { InMemoryThreadListAdapter } from "@ulearning/ai-core/internal";
+
+export type UseChatRuntimeOptions<UI_MESSAGE extends UIMessage = UIMessage> =
+  Omit<ChatThreadOptions<UI_MESSAGE>, "transport"> & {
+    /**
+     * The transport threads send through. `AssistantChatTransport` instances
+     * are cloned per thread through `__internal_clone()` so their assistant-ui
+     * wiring remains isolated. Other transport instances are shared as-is.
+     */
+    transport?: ChatTransport<UI_MESSAGE> | undefined;
+    onThreadIdChange?: ((threadId: string | undefined) => void) | undefined;
+  };
+
+const useChatThreadRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
+  options: ChatThreadOptions<UI_MESSAGE> | undefined,
+  hostDestroySignal: AbortSignal,
+): AssistantRuntime => {
+  const aui = useAui();
+  const id = useSyncExternalStore(
+    aui.subscribe,
+    () => aui.threadListItem.getState().id,
+  );
+  const isMainThread = useSyncExternalStore(
+    aui.subscribe,
+    () => aui.threads.getState().mainThreadId === id,
+  );
+  return useChatThread(options, {
+    id,
+    isMainThread,
+    getThreadListItem: () =>
+      aui.threadListItem.source ? aui.threadListItem : undefined,
+    stopOnClientDestroy: true,
+    hostDestroySignal,
+  });
+};
+
+const useChatRuntimeResource = <UI_MESSAGE extends UIMessage = UIMessage>(
+  { onThreadIdChange, ...options }: UseChatRuntimeOptions<UI_MESSAGE>,
+  hostDestroySignal: AbortSignal,
+): AssistantRuntime => {
+  const [adapter] = useState(() => new InMemoryThreadListAdapter());
+  const fallback = useMemo(() => new AssistantChatTransport<UI_MESSAGE>(), []);
+  const transport = useDynamicChatTransport(options.transport ?? fallback);
+  return useRemoteThreadListRuntime({
+    runtimeHook: function RuntimeHook() {
+      return useChatThreadRuntime({ ...options, transport }, hostDestroySignal);
+    },
+    adapter,
+    allowNesting: true,
+    onThreadIdChange,
+  });
+};
+
+/** Live Vue options are evaluated inside the owned resource tree. */
+export const useChatRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
+  options: MaybeRefOrGetter<UseChatRuntimeOptions<UI_MESSAGE>> = {},
+): AssistantRuntime => {
+  const hostDestroySignal = useHostDestroySignal();
+  if (isResourceExecution())
+    return useChatRuntimeResource(toValue(options), hostDestroySignal);
+  return useRuntimeResource(() =>
+    useChatRuntimeResource(toValue(options), hostDestroySignal),
+  );
+};