@assistant-ui/ai-sdk 0.0.4 → 0.0.6

package/src/runtime/AISDKThreads.cloud.test.ts

@@ -54,23 +54,28 @@ const mocks = vi.hoisted(() => {
       return { history };
     },
   };
-  return { adapter };
+  return {
+    adapter,
+    useCloudThreadListAdapter: vi.fn(() => adapter),
+  };
 });
 
 vi.mock("@assistant-ui/core/react", async (importOriginal) => ({
   ...(await importOriginal<typeof import("@assistant-ui/core/react")>()),
-  useCloudThreadListAdapter: () => mocks.adapter,
+  useCloudThreadListAdapter: mocks.useCloudThreadListAdapter,
 }));
 
 import { AISDKThreads } from "./AISDKThreads";
 import { createCancellableTransport } from "./__tests__/controlled-transport";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 describe("AISDKThreads cloud", () => {
   it("reloads history when switching a keyed cloud thread", async () => {
+    const cloud = {} as AssistantCloud;
     const handle = createAssistantClient(
       AuiConfig({
         threads: AISDKThreads({
-          cloud: {} as AssistantCloud,
+          cloud,
           threadId: "t1",
         }),
       }),
@@ -84,6 +89,10 @@ describe("AISDKThreads cloud", () => {
     await vi.waitFor(() => {
       expect(load).toHaveBeenCalled();
     });
+    expect(mocks.useCloudThreadListAdapter).toHaveBeenCalledWith({
+      cloud,
+      sdk: AI_SDK_SDK,
+    });
     const afterFirst = load.mock.calls.length;
     flushTapSync(() => aui.threads.switchToThread("t2"));
     await vi.waitFor(() => {

package/src/runtime/AISDKThreads.test.ts

@@ -251,17 +251,28 @@ describe("AISDKThreads", () => {
     }
   });
 
-  it("forwards ChatInit callbacks to each thread's chat", async () => {
+  it("forwards ChatInit callbacks to each thread's chat from the latest render", async () => {
     const { transport, emit, close } = createControlledTransport();
-    const onFinish = vi.fn();
-    const handle = createAssistantClient(
-      AuiConfig({
-        threads: AISDKThreads({ transport: () => transport, onFinish }),
-      }),
-    );
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ transport: () => transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
     handle.subscribe(() => {});
     const aui = handle.getClient();
 
+    onFinish = onFinishB;
+    flushTapSync(() => listeners.forEach((listener) => listener()));
+
     flushTapSync(() => aui.composer.setText("hi"));
     flushTapSync(() => aui.composer.send());
     await vi.waitFor(() => {
@@ -271,11 +282,123 @@ describe("AISDKThreads", () => {
     });
     emit(...textReply("done"));
     close();
-    await vi.waitFor(() => expect(onFinish).toHaveBeenCalledTimes(1));
+    await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+    expect(onFinishA).not.toHaveBeenCalled();
 
     handle.destroy();
   });
 
+  it("forwards the latest callbacks to a switched-away thread still streaming in the background", async () => {
+    const { transport, emit, close } = createControlledTransport();
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ transport: () => transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
+    handle.subscribe(() => {});
+    const aui = handle.getClient();
+
+    flushTapSync(() => aui.composer.setText("stream me"));
+    flushTapSync(() => aui.composer.send());
+    await vi.waitFor(() => {
+      expect(
+        handle.getClient().thread.getState().messages.length,
+      ).toBeGreaterThan(0);
+    });
+    emit(
+      { type: "start" },
+      { type: "text-start", id: "t1" },
+      { type: "text-delta", id: "t1", delta: "partial" },
+    );
+
+    flushTapSync(() => aui.threads.switchToNewThread());
+    onFinish = onFinishB;
+    flushTapSync(() => listeners.forEach((listener) => listener()));
+
+    emit({ type: "text-end", id: "t1" }, { type: "finish" });
+    close();
+    await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+    expect(onFinishA).not.toHaveBeenCalled();
+
+    handle.destroy();
+  });
+
+  it("forwards the latest callbacks to a cloud thread's chat", async () => {
+    const cloudThread = (id: string) => ({
+      id,
+      title: id,
+      is_archived: false,
+      last_message_at: null,
+      external_id: null,
+      metadata: null,
+    });
+    const cloud = {
+      threads: {
+        list: vi.fn(async () => ({ threads: [cloudThread("t1")] })),
+        create: vi.fn(),
+        update: vi.fn(),
+        delete: vi.fn(),
+        get: vi.fn(async (id: string) => cloudThread(id)),
+        messages: {
+          list: vi.fn(async () => ({ messages: [] })),
+          create: vi.fn(async () => ({ message_id: "remote-message-1" })),
+          update: vi.fn(),
+        },
+      },
+      runs: { stream: vi.fn(), report: vi.fn() },
+      telemetry: { enabled: false },
+    } as unknown as AssistantCloud;
+    const { transport, emit, close } = createControlledTransport();
+    const onFinishA = vi.fn();
+    const onFinishB = vi.fn();
+    let onFinish = onFinishA;
+    const listeners = new Set<() => void>();
+    const handle = createAssistantClient({
+      getConfig: () =>
+        AuiConfig({
+          threads: AISDKThreads({ cloud, threadId: "t1", transport, onFinish }),
+        }),
+      subscribe: (listener) => {
+        listeners.add(listener);
+        return () => listeners.delete(listener);
+      },
+    });
+    handle.subscribe(() => {});
+    try {
+      await handle.getClient().threads.getLoadThreadsPromise();
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().mainThreadId).toBe("t1");
+      });
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isLoading).toBe(false);
+      });
+
+      onFinish = onFinishB;
+      flushTapSync(() => listeners.forEach((listener) => listener()));
+
+      flushTapSync(() => handle.getClient().composer.setText("hi"));
+      flushTapSync(() => handle.getClient().composer.send());
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isRunning).toBe(true);
+      });
+      emit(...textReply("done"));
+      close();
+      await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
+      expect(onFinishA).not.toHaveBeenCalled();
+    } finally {
+      handle.destroy();
+    }
+  });
+
   it("posts each thread's own id as the chat id", async () => {
     const bodies: unknown[] = [];
     const fetchStub = vi.fn(async (_url: unknown, init?: RequestInit) => {

package/src/runtime/AISDKThreads.ts

@@ -26,6 +26,7 @@ import {
 } from "./useChatThread";
 import { MessageRepository } from "@assistant-ui/core/internal";
 import { useResourceCleanup } from "./useResourceCleanup";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 export type AISDKThreadsOptions<UI_MESSAGE extends UIMessage = UIMessage> =
   Omit<ChatThreadOptions<UI_MESSAGE>, "id" | "transport" | "messages"> & {
@@ -62,16 +63,22 @@ type AISDKThreadChatOptions<UI_MESSAGE extends UIMessage = UIMessage> = Omit<
   "cloud" | "threadId" | "onThreadIdChange"
 >;
 
+type ChatOptionsRef<UI_MESSAGE extends UIMessage> = {
+  current: AISDKThreadChatOptions<UI_MESSAGE> | undefined;
+};
+
 type ChatEntry<UI_MESSAGE extends UIMessage> = {
   chat: Chat<UI_MESSAGE>;
   transport: ChatTransport<UI_MESSAGE>;
   repository: MessageRepository;
+  optionsRef: ChatOptionsRef<UI_MESSAGE>;
 };
 
 const createChatEntry = <UI_MESSAGE extends UIMessage>(
   threadId: string,
   options: AISDKThreadChatOptions<UI_MESSAGE> | undefined,
 ): ChatEntry<UI_MESSAGE> => {
+  const optionsRef: ChatOptionsRef<UI_MESSAGE> = { current: options };
   const { chatInit } = splitChatThreadOptions(
     options as ChatThreadOptions<UI_MESSAGE> | undefined,
   );
@@ -84,9 +91,20 @@ const createChatEntry = <UI_MESSAGE extends UIMessage>(
           ? options.transport.__internal_clone()
           : options.transport;
   return {
-    chat: new Chat<UI_MESSAGE>({ ...chatInit, id: threadId, transport }),
+    chat: new Chat<UI_MESSAGE>({
+      ...chatInit,
+      id: threadId,
+      transport,
+      onToolCall: (arg) => optionsRef.current?.onToolCall?.(arg),
+      onData: (arg) => optionsRef.current?.onData?.(arg),
+      onFinish: (arg) => optionsRef.current?.onFinish?.(arg),
+      onError: (arg) => optionsRef.current?.onError?.(arg),
+      sendAutomaticallyWhen: (arg) =>
+        optionsRef.current?.sendAutomaticallyWhen?.(arg) ?? false,
+    }),
     transport,
     repository: new MessageRepository(),
+    optionsRef,
   };
 };
 
@@ -116,9 +134,13 @@ const useAISDKChatThread = <UI_MESSAGE extends UIMessage = UIMessage>({
   const [owned] = useState(() =>
     cloud ? createChatEntry(threadId, options) : undefined,
   );
-  const { chat, transport, repository } =
+  const { chat, transport, repository, optionsRef } =
     owned ?? getOrCreateChatEntry(threadId, options, chats);
 
+  useEffect(() => {
+    if (cloud) optionsRef.current = options;
+  });
+
   useEffect(() => {
     if (!cloud) return undefined;
     return () => {
@@ -173,13 +195,19 @@ const useAISDKThreads = <UI_MESSAGE extends UIMessage = UIMessage>(
   const [chats] = useState(() => new Map<string, ChatEntry<UI_MESSAGE>>());
   const bindCloud = cloud !== undefined;
 
+  useEffect(() => {
+    for (const { optionsRef } of chats.values()) {
+      optionsRef.current = threadOptions;
+    }
+  });
+
   useResourceCleanup(true, () => {
     for (const { chat } of chats.values()) {
       void chat.stop().catch(() => {});
     }
   });
 
-  const cloudAdapter = useCloudThreadListAdapter({ cloud });
+  const cloudAdapter = useCloudThreadListAdapter({ cloud, sdk: AI_SDK_SDK });
   const thread = (id: string) => {
     const element = AISDKChatThread({
       threadId: id,

package/src/runtime/__tests__/controlled-transport.ts

@@ -1,4 +1,6 @@
 import type { ChatTransport, UIMessage, UIMessageChunk } from "ai";
+import { useAui, type AssistantClient } from "@assistant-ui/store";
+import { flushTapSync } from "@assistant-ui/tap";
 
 export const createControlledTransport = () => {
   let controller!: ReadableStreamDefaultController<UIMessageChunk>;
@@ -41,3 +43,22 @@ export const createCancellableTransport = () => {
     close: () => controller.close(),
   };
 };
+
+export const nextTask = () => new Promise((resolve) => setTimeout(resolve, 0));
+
+export const createStreamHarness = () => {
+  let aui: AssistantClient | undefined;
+  const Probe = () => {
+    aui = useAui();
+    return null;
+  };
+  return {
+    Probe,
+    send: () => {
+      flushTapSync(() => aui!.composer.setText("keep streaming"));
+      flushTapSync(() => aui!.composer.send());
+    },
+    isRunning: () => aui?.thread.getState().isRunning === true,
+    client: () => aui!,
+  };
+};

package/src/runtime/sdkIdentity.ts

@@ -0,0 +1,9 @@
+import type { SdkIdentity } from "assistant-cloud";
+
+export const AI_SDK_SDK: SdkIdentity = {
+  name: "@assistant-ui/ai-sdk",
+  version:
+    typeof __AUI_PACKAGE_VERSION__ === "string"
+      ? __AUI_PACKAGE_VERSION__
+      : "0.0.0",
+};

package/src/runtime/useAISDKRuntime.test.ts

@@ -77,7 +77,6 @@ const textOf = (message: any): string =>
 
 describe("useAISDKRuntime", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
     vi.mocked(useExternalHistory).mockReturnValue({
       isLoading: false,
       deleteMessage: vi.fn().mockResolvedValue(undefined),
@@ -1487,4 +1486,43 @@ describe("useAISDKRuntime", () => {
       error: chat.error,
     });
   });
+
+  it("keeps the error name and code on the failed message status", () => {
+    const chat = createChatHelpers([
+      { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+      { id: "a1", role: "assistant", parts: [{ type: "text", text: "" }] },
+    ]);
+    chat.error = Object.assign(new Error("rate limited"), {
+      name: "AI_APICallError",
+      code: "rate_limited",
+    });
+
+    const { result } = renderHook(() => useAISDKRuntime(chat));
+
+    expect(
+      result.current.thread.getState().messages.at(-1)?.status,
+    ).toMatchObject({
+      type: "incomplete",
+      reason: "error",
+      error: { code: "rate_limited", message: "rate limited" },
+    });
+  });
+
+  it("uses the error name as the code when the error carries none", () => {
+    const chat = createChatHelpers([
+      { id: "u1", role: "user", parts: [{ type: "text", text: "hi" }] },
+      { id: "a1", role: "assistant", parts: [{ type: "text", text: "" }] },
+    ]);
+    chat.error = Object.assign(new Error("upstream failed"), {
+      name: "AI_APICallError",
+    });
+
+    const { result } = renderHook(() => useAISDKRuntime(chat));
+
+    expect(
+      result.current.thread.getState().messages.at(-1)?.status,
+    ).toMatchObject({
+      error: { code: "AI_APICallError", message: "upstream failed" },
+    });
+  });
 });

package/src/runtime/useAISDKRuntime.ts

@@ -47,6 +47,7 @@ import {
   MessageRepository,
 } from "@assistant-ui/core/internal";
 import type { ReadonlyJSONObject } from "assistant-stream/utils";
+import type { AssistantError } from "@assistant-ui/core";
 import { sliceMessagesUntil } from "../utils/sliceMessagesUntil";
 import { toCreateMessage } from "../converters/toCreateMessage";
 import { vercelAttachmentAdapter } from "../adapters/vercelAttachmentAdapter";
@@ -219,6 +220,19 @@ const useGeneratedSuggestions = (
 
 const NO_CANCELLED_MESSAGE_IDS: ReadonlySet<string> = new Set();
 
+const toChatError = (error: Error): AssistantError => {
+  const code = (error as { code?: unknown }).code;
+  return {
+    code:
+      typeof code === "string"
+        ? code
+        : error.name !== "Error"
+          ? error.name
+          : "unknown",
+    message: error.message,
+  };
+};
+
 export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
   chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>,
   adapter: AISDKRuntimeAdapter<UI_MESSAGE> = {},
@@ -315,7 +329,9 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
         toolLastInputCache: toolLastInputCacheRef.current,
         mcpAppMetadataCache: mcpAppMetadataCacheRef.current,
         ...(optimisticMessageId && { optimisticMessageId }),
-        ...(chatHelpers.error && { error: chatHelpers.error.message }),
+        ...(chatHelpers.error && {
+          error: toChatError(chatHelpers.error),
+        }),
         ...(cancelledMessageIds.size > 0 && { cancelledMessageIds }),
       }),
       [

package/src/runtime/useChatRuntime.integration.test.tsx

@@ -1,12 +1,19 @@
 // @vitest-environment jsdom
 
-import { render, screen, waitFor } from "@testing-library/react";
+import { act, render, screen, waitFor } from "@testing-library/react";
 import { AssistantRuntimeProvider } from "@assistant-ui/core/react";
-import { useAuiState } from "@assistant-ui/store";
-import type { UIMessage } from "ai";
-import { StrictMode, useState } from "react";
+import { AuiConfig, AuiProvider, useAuiState } from "@assistant-ui/store";
+import type { AssistantRuntime } from "@assistant-ui/core";
+import { AISDKChat } from "./AISDKChat";
+import type { ChatTransport, UIMessage } from "ai";
+import { Activity, StrictMode, useState, type ReactNode } from "react";
 import { describe, expect, it } from "vitest";
 import { AssistantChatTransport } from "../transport/AssistantChatTransport";
+import {
+  createCancellableTransport,
+  createStreamHarness,
+  nextTask,
+} from "./__tests__/controlled-transport";
 import { useChatRuntime } from "./useChatRuntime";
 import { useThreadTokenUsage } from "../usage";
 
@@ -65,8 +72,134 @@ describe("useChatRuntime integration", () => {
       );
     });
   });
+
+  it("aborts a deleted thread's stream while the host stays mounted", async () => {
+    const { transport, getCancelCount } = createCancellableTransport();
+    const { Probe, send, isRunning, client } = createStreamHarness();
+
+    const view = render(
+      <StrictMode>
+        <StreamingApp transport={transport} probe={<Probe />} />
+      </StrictMode>,
+    );
+
+    await act(async () => send());
+    await waitFor(() => expect(isRunning()).toBe(true));
+
+    await act(async () => client().threadListItem.delete());
+
+    await waitFor(() => expect(getCancelCount()).toBe(1));
+    view.unmount();
+  });
+
+  it("aborts the in-flight transport after a real unmount", async () => {
+    const { transport, getCancelCount } = createCancellableTransport();
+    const { Probe, send, isRunning } = createStreamHarness();
+
+    const view = render(
+      <StrictMode>
+        <StreamingApp transport={transport} probe={<Probe />} />
+      </StrictMode>,
+    );
+
+    await act(async () => send());
+    await waitFor(() => expect(isRunning()).toBe(true));
+    // the Strict Mode double mount already ran a host cleanup by now
+    expect(getCancelCount()).toBe(0);
+
+    view.unmount();
+    await waitFor(() => expect(getCancelCount()).toBe(1));
+  });
+
+  it("keeps streaming while hidden and aborts when the hidden host unmounts", async () => {
+    const { transport, getCancelCount } = createCancellableTransport();
+    const { Probe, send, isRunning } = createStreamHarness();
+
+    let setMode: ((mode: "visible" | "hidden") => void) | undefined;
+    const Shell = () => {
+      const [mode, set] = useState<"visible" | "hidden">("visible");
+      setMode = set;
+      return (
+        <Activity mode={mode}>
+          <StreamingApp transport={transport} probe={<Probe />} />
+        </Activity>
+      );
+    };
+
+    const view = render(
+      <StrictMode>
+        <Shell />
+      </StrictMode>,
+    );
+
+    await act(async () => send());
+    await waitFor(() => expect(isRunning()).toBe(true));
+
+    await act(async () => setMode?.("hidden"));
+    await act(nextTask);
+    expect(getCancelCount()).toBe(0);
+    expect(isRunning()).toBe(true);
+
+    await act(async () => setMode?.("visible"));
+    await act(nextTask);
+    expect(getCancelCount()).toBe(0);
+    expect(isRunning()).toBe(true);
+
+    await act(async () => setMode?.("hidden"));
+    view.unmount();
+    await waitFor(() => expect(getCancelCount()).toBe(1));
+  });
+
+  it("aborts a nested runtime's stream when the provider above it unmounts", async () => {
+    const outer = createCancellableTransport();
+    const { transport, getCancelCount } = createCancellableTransport();
+    let nested: AssistantRuntime | undefined;
+
+    // allowNesting: the inner useChatRuntime runs its thread hook directly, as
+    // a plain React hook under the provider rather than inside a tap resource.
+    const NestedChat = () => {
+      nested = useChatRuntime({ transport });
+      return null;
+    };
+
+    const view = render(
+      <StrictMode>
+        <AuiProvider
+          config={AuiConfig({
+            threads: AISDKChat({ transport: outer.transport }),
+          })}
+        >
+          <NestedChat />
+        </AuiProvider>
+      </StrictMode>,
+    );
+
+    await waitFor(() => expect(nested).toBeDefined());
+    await act(async () => {
+      await nested!.thread.append("keep streaming");
+    });
+    await waitFor(() => expect(nested!.thread.getState().isRunning).toBe(true));
+
+    view.unmount();
+    await waitFor(() => expect(getCancelCount()).toBe(1));
+  });
 });
 
+const StreamingApp = ({
+  transport,
+  probe,
+}: {
+  transport: ChatTransport<UIMessage>;
+  probe: ReactNode;
+}) => {
+  const runtime = useChatRuntime({ transport });
+  return (
+    <AssistantRuntimeProvider runtime={runtime}>
+      {probe}
+    </AssistantRuntimeProvider>
+  );
+};
+
 const UsageProbe = () => {
   const usage = useThreadTokenUsage();
   return (

package/src/runtime/useChatRuntime.test.ts

@@ -88,7 +88,6 @@ const sendMessagesOptions = {
 
 describe("useChatRuntime", () => {
   beforeEach(() => {
-    vi.clearAllMocks();
     mocks.state.isLoadingHistory = false;
     mocks.state.threadId = "thread-id";
     mocks.state.mainThreadId = "thread-id";

package/src/runtime/useChatRuntime.ts

@@ -9,6 +9,7 @@ import {
 } from "@assistant-ui/core/react";
 import { useAui, useAuiState } from "@assistant-ui/store";
 import { useChatThread, type ChatThreadOptions } from "./useChatThread";
+import { AI_SDK_SDK } from "./sdkIdentity";
 
 export type UseChatRuntimeOptions<UI_MESSAGE extends UIMessage = UIMessage> =
   ChatThreadOptions<UI_MESSAGE> & {
@@ -29,6 +30,7 @@ const useChatThreadRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     isMainThread,
     getThreadListItem: () =>
       aui.threadListItem.source ? aui.threadListItem : undefined,
+    stopOnClientDestroy: true,
   });
 };
 
@@ -37,7 +39,7 @@ export const useChatRuntime = <UI_MESSAGE extends UIMessage = UIMessage>({
   onThreadIdChange,
   ...options
 }: UseChatRuntimeOptions<UI_MESSAGE> = {}): AssistantRuntime => {
-  const cloudAdapter = useCloudThreadListAdapter({ cloud });
+  const cloudAdapter = useCloudThreadListAdapter({ cloud, sdk: AI_SDK_SDK });
   return useRemoteThreadListRuntime({
     runtimeHook: function RuntimeHook() {
       return useChatThreadRuntime(options);

package/src/runtime/useChatThread.test.ts

@@ -0,0 +1,74 @@
+// @vitest-environment jsdom
+
+import { describe, expect, it, vi } from "vitest";
+import { resource, useResource, flushTapSync } from "@assistant-ui/tap";
+import { useState } from "react";
+import {
+  RuntimeAdapter,
+  runtimeAdapterTransformScopes,
+} from "@assistant-ui/core/store";
+import {
+  attachTransformScopes,
+  AuiConfig,
+  createAssistantClient,
+} from "@assistant-ui/store/client";
+import { useChatThread, type ChatThreadEnvironment } from "./useChatThread";
+import {
+  createCancellableTransport,
+  nextTask,
+} from "./__tests__/controlled-transport";
+
+const createHost = (
+  env: Pick<ChatThreadEnvironment, "stopOnClientDestroy">,
+) => {
+  const useHost = (options: Parameters<typeof useChatThread>[0]) => {
+    const [threadListItem] = useState(() => ({
+      initialize: async () => ({ remoteId: "main", externalId: undefined }),
+    }));
+    const runtime = useChatThread(options, {
+      id: "main",
+      isMainThread: true,
+      getThreadListItem: () => threadListItem,
+      ...env,
+    });
+    return useResource(RuntimeAdapter(runtime));
+  };
+  attachTransformScopes(useHost, runtimeAdapterTransformScopes);
+  return resource(useHost);
+};
+
+const streamThenDestroy = async (
+  env: Pick<ChatThreadEnvironment, "stopOnClientDestroy">,
+) => {
+  const { transport, getCancelCount, close } = createCancellableTransport();
+  const Host = createHost(env);
+  const handle = createAssistantClient(
+    AuiConfig({ threads: Host({ transport }) }),
+  );
+  handle.subscribe(() => {});
+  const aui = handle.getClient();
+
+  try {
+    flushTapSync(() => aui.composer.setText("stop me"));
+    flushTapSync(() => aui.composer.send());
+    await vi.waitFor(() => {
+      expect(aui.thread.getState().isRunning).toBe(true);
+    });
+  } finally {
+    handle.destroy();
+  }
+  await nextTask();
+  const cancelCount = getCancelCount();
+  if (cancelCount === 0) close();
+  return cancelCount;
+};
+
+describe("useChatThread", () => {
+  it("stops an in-flight chat on client destroy when stopOnClientDestroy is omitted", async () => {
+    expect(await streamThenDestroy({})).toBe(1);
+  });
+
+  it("leaves an in-flight chat running on client destroy when stopOnClientDestroy is false", async () => {
+    expect(await streamThenDestroy({ stopOnClientDestroy: false })).toBe(0);
+  });
+});