@assistant-ui/ai-sdk 0.0.7 → 0.0.8

package/src/runtime/useAISDKRuntime.ts

@@ -38,12 +38,14 @@ import type {
   RunConfig,
   McpAppMetadata,
   RespondToToolApprovalOptions,
+  Unstable_ToolInteractionLog,
 } from "@assistant-ui/core";
 import {
   getExternalStoreMessages,
   pickExternalStoreSharedOptions,
 } from "@assistant-ui/core";
 import {
+  appendToolInteraction,
   consumeSuggestionResult,
   MessageRepository,
 } from "@assistant-ui/core/internal";
@@ -95,7 +97,7 @@ const toVoiceTranscriptUIMessage = <UI_MESSAGE extends UIMessage>(
       .filter((part) => part.type === "text")
       .map((part) => ({ type: "text", text: part.text })),
     metadata: {
-      modality: "voice",
+      ...(message.metadata.modality && { modality: message.metadata.modality }),
       ...(Object.keys(message.metadata.custom).length > 0 && {
         custom: message.metadata.custom,
       }),
@@ -139,9 +141,9 @@ export type AISDKRuntimeAdapter<UI_MESSAGE extends UIMessage = UIMessage> =
     /**
      * Answers tool approval requests through a host-owned channel instead of the AI SDK's `addToolApprovalResponse`.
      *
-     * Called for every approval request in the thread with the complete response, including option and free-form answers. Hand requests the host does not own to `respondViaAISDK`, which is what runs when this option is omitted. The answer applies to the approval when the handler starts and is removed if it throws. It is never written into the `useChat` messages, so `sendAutomaticallyWhen` cannot forward it, and it lasts as long as this runtime: until then a second response to the same request rejects, and a runtime mounted again over the same chat shows the request open until the resumed run records its resolution in the chat.
+     * Called for every approval request in the thread with the complete response, including option and free-form answers. Hand requests the host does not own to `respondViaAISDK`, which is what runs when this option is omitted. The answer applies to the approval when the handler starts and is removed if it throws. It is never written into the `useChat` messages, so `sendAutomaticallyWhen` cannot forward it. With a history adapter, the answer is stored with its message once the handler resolves and returns on reload, and a second response to the same request rejects; without one it lasts as long as this runtime, and a runtime mounted again over the same chat shows the request open until the resumed run records its resolution in the chat.
      *
-     * While a handler is set, an approval's `display`, `allowFreeform` and `options` reach the renderer, because the handler can receive answers the AI SDK cannot carry.
+     * While a handler is set, an approval's `display`, `allowFreeform`, `dismissible` and `options` reach the renderer, because the handler can receive answers the AI SDK cannot carry. A stream declares them through the `approvalDescriptor` of its `tool-approval-request` chunk, the one approval field the AI SDK keeps opaque; the converter reads the request and answer fields from that descriptor when the approval itself lacks them.
      */
     onRespondToToolApproval?:
       | ((
@@ -304,15 +306,33 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
   const [toolApprovalResponses, setToolApprovalResponses] = useState<
     ReadonlyMap<string, RespondToToolApprovalOptions>
   >(NO_TOOL_APPROVAL_RESPONSES);
+  const [toolArtifactEpoch, setToolArtifactEpoch] = useState(0);
+  const [toolInteractionEpoch, setToolInteractionEpoch] = useState(0);
   const hostApprovalIdsRef = useRef(new Set<string>());
+  const toolApprovalResponsesRef = useRef<
+    Map<string, RespondToToolApprovalOptions>
+  >(new Map());
   const toolArgsKeyOrderCacheRef = useRef<Map<string, Map<string, string[]>>>(
     new Map(),
   );
   const toolLastInputCacheRef = useRef<Map<string, ReadonlyJSONObject>>(
     new Map(),
   );
+  const toolArgsTextCacheRef = useRef<
+    WeakMap<ReadonlyJSONObject, Map<string, string>>
+  >(new WeakMap());
   const mcpAppMetadataCacheRef = useRef<Map<string, McpAppMetadata>>(new Map());
+  const toolArtifactsRef = useRef<Map<string, unknown>>(new Map());
+  const toolInteractionsRef = useRef<Map<string, Unstable_ToolInteractionLog>>(
+    new Map(),
+  );
   const lastRunConfigRef = useRef<RunConfig | undefined>(undefined);
+  const markToolArtifactsChanged = useCallback(() => {
+    setToolArtifactEpoch((epoch) => epoch + 1);
+  }, []);
+  const markToolInteractionsChanged = useCallback(() => {
+    setToolInteractionEpoch((epoch) => epoch + 1);
+  }, []);
 
   const hasExecutingTools = Object.values(toolStatuses).some(
     (s) => s?.type === "executing",
@@ -341,6 +361,9 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     (sourceMessages: UI_MESSAGE[]) => {
       const metadata: AISDKMessageConverterMetadata = {
         supportsRichToolApprovalResponses,
+        toolArtifacts: toolArtifactsRef.current,
+        toolInteractions: toolInteractionsRef.current,
+        toolApprovalResponses: toolApprovalResponsesRef.current,
       };
       return AISDKMessageConverter.toThreadMessages(
         sourceMessages,
@@ -391,8 +414,11 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
         toolStatuses,
         messageTiming,
         toolArgsKeyOrderCache: toolArgsKeyOrderCacheRef.current,
+        toolArgsTextCache: toolArgsTextCacheRef.current,
         toolLastInputCache: toolLastInputCacheRef.current,
         mcpAppMetadataCache: mcpAppMetadataCacheRef.current,
+        toolArtifacts: toolArtifactsRef.current,
+        toolInteractions: toolInteractionsRef.current,
         supportsRichToolApprovalResponses,
         ...(optimisticMessageId && { optimisticMessageId }),
         ...(chatHelpers.error && {
@@ -409,6 +435,8 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
         cancelledMessageIds,
         toolApprovalResponses,
         supportsRichToolApprovalResponses,
+        toolArtifactEpoch,
+        toolInteractionEpoch,
       ],
     ),
   });
@@ -434,7 +462,12 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     },
   }));
 
-  const { isLoading, deleteMessage: deleteHistoryMessage } = useExternalHistory(
+  const {
+    isLoading,
+    deleteMessage: deleteHistoryMessage,
+    persistToolInteractions,
+    persistToolApprovalResponses,
+  } = useExternalHistory(
     runtimeRef,
     adapters?.history ?? contextAdapters?.history,
     toThreadMessages,
@@ -445,6 +478,17 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     (messages) => {
       chatHelpers.setMessages(messages);
     },
+    toolArtifactsRef.current,
+    markToolArtifactsChanged,
+    toolInteractionsRef.current,
+    markToolInteractionsChanged,
+    toolApprovalResponsesRef.current,
+    () => {
+      hostApprovalIdsRef.current = new Set(
+        toolApprovalResponsesRef.current.keys(),
+      );
+      setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
+    },
   );
 
   const {
@@ -467,35 +511,43 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     if (!cancelPendingToolCallsOnSend) return;
 
     // The runtime auto-aborts in-flight tool invocations when a new run
-    // is dispatched (append() / startRun()). All we need to do here is
-    // mark any tool without a result as cancelled in the UI message list.
-
-    // Mark any tool without a result as cancelled (uses setMessages to avoid triggering sendAutomaticallyWhen)
+    // is dispatched (append() / startRun()), so this only has to mark the
+    // abandoned tools cancelled in the UI message list. Every non-terminal
+    // tool call qualifies wherever it sits: the run that produced it is over,
+    // and a staged `startRun: false` message can sit between it and the tail.
+    // Uses setMessages to avoid triggering sendAutomaticallyWhen.
     chatHelpers.setMessages((messages) => {
-      const lastMessage = messages.at(-1);
-      if (lastMessage?.role !== "assistant") return messages;
-
       let hasChanges = false;
-      const parts = lastMessage.parts?.map((part) => {
-        if (!isToolUIPart(part)) return part;
-        if (
-          part.state === "output-available" ||
-          part.state === "output-error" ||
-          part.state === "output-denied"
-        )
-          return part;
 
+      const next = messages.map((message) => {
+        if (message.role !== "assistant") return message;
+
+        let messageChanged = false;
+        const parts = message.parts?.map((part) => {
+          if (!isToolUIPart(part)) return part;
+          if (
+            part.state === "output-available" ||
+            part.state === "output-error" ||
+            part.state === "output-denied"
+          )
+            return part;
+
+          messageChanged = true;
+          const { approval: _approval, ...rest } = part;
+          return {
+            ...rest,
+            state: "output-error" as const,
+            errorText: "User cancelled tool call by sending a new message.",
+          };
+        });
+
+        if (!messageChanged) return message;
         hasChanges = true;
-        const { approval: _approval, ...rest } = part;
-        return {
-          ...rest,
-          state: "output-error" as const,
-          errorText: "User cancelled tool call by sending a new message.",
-        };
+        return { ...message, parts };
       });
 
       if (!hasChanges) return messages;
-      return [...messages.slice(0, -1), { ...lastMessage, parts }];
+      return next;
     });
   };
 
@@ -519,10 +571,13 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
   ) => {
     const { approvalId } = response;
     const requested = chatHelpers.messages
-      .flatMap((message) => message.parts)
-      .filter(isToolUIPart)
+      .flatMap((message) =>
+        message.parts.flatMap((part) =>
+          isToolUIPart(part) ? [{ messageId: message.id, part }] : [],
+        ),
+      )
       .find(
-        (part) =>
+        ({ part }) =>
           part.state === "approval-requested" &&
           part.approval.id === approvalId,
       );
@@ -535,19 +590,16 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     const applyResponse = (applied: boolean) => {
       if (applied) hostApprovalIdsRef.current.add(approvalId);
       else hostApprovalIdsRef.current.delete(approvalId);
-      setToolApprovalResponses((prev) => {
-        const responses = new Map(prev);
-        if (applied) responses.set(approvalId, response);
-        else responses.delete(approvalId);
-        return responses;
-      });
+      if (applied) toolApprovalResponsesRef.current.set(approvalId, response);
+      else toolApprovalResponsesRef.current.delete(approvalId);
+      setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
     };
 
     applyResponse(true);
     try {
       await onRespond(response, {
-        toolCallId: requested.toolCallId,
-        toolName: getToolName(requested),
+        toolCallId: requested.part.toolCallId,
+        toolName: getToolName(requested.part),
         respondViaAISDK: async () => {
           try {
             await respondViaAISDK(response);
@@ -560,6 +612,9 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
       if (hostApprovalIdsRef.current.has(approvalId)) applyResponse(false);
       throw error;
     }
+    if (hostApprovalIdsRef.current.has(approvalId)) {
+      await persistToolApprovalResponses(requested.messageId);
+    }
   };
 
   const hasSeededRepositoryRef = useRef(false);
@@ -569,6 +624,7 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     messages.length === 0;
 
   const runtime = useExternalStoreRuntime({
+    unstable_persistsHistory: true,
     isRunning: providerIsRunning,
     ...(shouldFeedRepository
       ? { messageRepository: exportedMessageRepository }
@@ -714,6 +770,34 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
 
       await deleteHistoryMessage(messageId);
 
+      let removedToolArtifact = false;
+      let removedToolInteractions = false;
+      let removedToolApprovalResponse = false;
+      let removedHostApprovalId = false;
+      for (const part of threadMessages[messageIndex]!.content) {
+        if (part.type === "tool-call") {
+          removedToolArtifact =
+            toolArtifactsRef.current.delete(part.toolCallId) ||
+            removedToolArtifact;
+          removedToolInteractions =
+            toolInteractionsRef.current.delete(part.toolCallId) ||
+            removedToolInteractions;
+          if (part.approval) {
+            removedToolApprovalResponse =
+              toolApprovalResponsesRef.current.delete(part.approval.id) ||
+              removedToolApprovalResponse;
+            removedHostApprovalId =
+              hostApprovalIdsRef.current.delete(part.approval.id) ||
+              removedHostApprovalId;
+          }
+        }
+      }
+      if (removedToolArtifact) markToolArtifactsChanged();
+      if (removedToolInteractions) markToolInteractionsChanged();
+      if (removedToolApprovalResponse || removedHostApprovalId) {
+        setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
+      }
+
       const deleteIds = new Set(
         getExternalStoreMessages<UI_MESSAGE>(threadMessages[messageIndex]!).map(
           (message) => message.id,
@@ -735,8 +819,13 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
       toolName,
       result,
       isError,
+      artifact,
       modelContent,
     }) => {
+      if (artifact !== undefined) {
+        toolArtifactsRef.current.set(toolCallId, artifact);
+        markToolArtifactsChanged();
+      }
       const options = { metadata: lastRunConfigRef.current };
       if (isError) {
         return Promise.resolve(
@@ -767,6 +856,21 @@ export const useAISDKRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     onRespondToToolApproval: customOnRespondToToolApproval
       ? (response) => respondViaHost(customOnRespondToToolApproval, response)
       : respondViaAISDK,
+    unstable_onRecordToolInteraction: ({
+      messageId,
+      toolCallId,
+      interaction,
+    }) => {
+      toolInteractionsRef.current.set(
+        toolCallId,
+        appendToolInteraction(
+          toolInteractionsRef.current.get(toolCallId),
+          interaction,
+        ),
+      );
+      markToolInteractionsChanged();
+      return persistToolInteractions(messageId);
+    },
     ...pickExternalStoreSharedOptions(adapter),
     ...(adapter.unstable_messageRepositoryInstance && {
       unstable_messageRepositoryInstance:

package/src/runtime/useAISDKRuntime.voice.test.tsx

@@ -36,7 +36,9 @@ const createChatHelpers = (initialMessages: UIMessage[] = []) => {
   return chatHelpers;
 };
 
-const createVoiceAdapter = () => {
+const createVoiceAdapter = ({
+  sendText,
+}: { sendText?: RealtimeVoiceAdapter.Session["sendText"] } = {}) => {
   let transcriptCallback:
     | ((transcript: RealtimeVoiceAdapter.TranscriptItem) => void)
     | undefined;
@@ -46,6 +48,7 @@ const createVoiceAdapter = () => {
     disconnect: vi.fn(),
     mute: vi.fn(),
     unmute: vi.fn(),
+    ...(sendText && { sendText }),
     onStatusChange: () => () => {},
     onTranscript: (callback) => {
       transcriptCallback = callback;
@@ -267,4 +270,50 @@ describe("useAISDKRuntime voice transcripts", () => {
       message: transcript,
     });
   });
+
+  it("persists a message typed into the session as a typed turn", async () => {
+    const chat = createChatHelpers();
+    const sendText = vi.fn(async (_text: string) => {});
+    const voice = createVoiceAdapter({ sendText });
+    const history = createHistoryAdapter();
+    const { result, rerender } = await renderVoiceRuntime(chat, {
+      voice: voice.adapter,
+      history: history.adapter,
+    });
+
+    act(() => {
+      result.current.thread.connectVoice();
+    });
+    await act(async () => {
+      await result.current.thread.append({
+        role: "user",
+        content: [{ type: "text", text: "Typed" }],
+      });
+    });
+
+    expect(sendText).toHaveBeenCalledExactlyOnceWith("Typed");
+    expect(chat.sendMessage).not.toHaveBeenCalled();
+    const typed = chat.messages[0];
+    expect(typed).toEqual({
+      id: expect.any(String),
+      role: "user",
+      parts: [{ type: "text", text: "Typed" }],
+      metadata: {},
+    });
+    rerender();
+
+    await waitFor(() => {
+      const messages = result.current.thread
+        .getState()
+        .messages.filter((message) => message.id === typed.id);
+      expect(messages).toHaveLength(1);
+      expect(messages[0]?.metadata.modality).toBeUndefined();
+      expect(textOf(messages[0]!)).toBe("Typed");
+    });
+    await waitFor(() => expect(history.append).toHaveBeenCalledTimes(1));
+    expect(history.append).toHaveBeenCalledWith({
+      parentId: null,
+      message: typed,
+    });
+  });
 });

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

@@ -1,8 +1,10 @@
 // @vitest-environment jsdom
 
+import { getEventListeners } from "node:events";
 import { act, render, screen, waitFor } from "@testing-library/react";
 import { AssistantRuntimeProvider } from "@assistant-ui/core/react";
 import { AuiConfig, AuiProvider, useAuiState } from "@assistant-ui/store";
+import { useAssistantClientDestroySignal } from "@assistant-ui/store/internal";
 import type { AssistantRuntime } from "@assistant-ui/core";
 import { AISDKChat } from "./AISDKChat";
 import type { ChatTransport, UIMessage } from "ai";
@@ -183,6 +185,60 @@ describe("useChatRuntime integration", () => {
     view.unmount();
     await waitFor(() => expect(getCancelCount()).toBe(1));
   });
+
+  it("aborts a nested runtime when only its own component unmounts", async () => {
+    const outer = createCancellableTransport();
+    const { transport, getCancelCount } = createCancellableTransport();
+    let nested: AssistantRuntime | undefined;
+    let providerSignal: AbortSignal | undefined;
+    let setVisible: ((visible: boolean) => void) | undefined;
+
+    const NestedChat = () => {
+      providerSignal = useAssistantClientDestroySignal();
+      nested = useChatRuntime({ transport });
+      return null;
+    };
+    const Shell = () => {
+      const [visible, set] = useState(true);
+      setVisible = set;
+      return (
+        <AuiProvider
+          config={AuiConfig({
+            threads: AISDKChat({ transport: outer.transport }),
+          })}
+        >
+          {visible && <NestedChat />}
+        </AuiProvider>
+      );
+    };
+    const listeners = () => getEventListeners(providerSignal!, "abort").length;
+
+    const view = render(<Shell />);
+    await waitFor(() => expect(nested).toBeDefined());
+    const mounted = listeners();
+
+    for (const cycle of [1, 2]) {
+      await act(async () => {
+        await nested!.thread.append(`stream ${cycle}`);
+      });
+      await waitFor(() =>
+        expect(nested!.thread.getState().isRunning).toBe(true),
+      );
+
+      await act(async () => setVisible?.(false));
+      await waitFor(() => expect(getCancelCount()).toBe(cycle));
+      expect(listeners()).toBe(mounted - 1);
+
+      nested = undefined;
+      await act(async () => setVisible?.(true));
+      await waitFor(() => expect(nested).toBeDefined());
+      expect(listeners()).toBe(mounted);
+    }
+
+    view.unmount();
+    await act(nextTask);
+    expect(getCancelCount()).toBe(2);
+  });
 });
 
 const StreamingApp = ({

package/src/runtime/useChatRuntime.test.ts

@@ -52,7 +52,11 @@ const mocks = vi.hoisted(() => {
 });
 
 vi.mock("@ai-sdk/react", () => ({
-  useChat: mocks.useChat,
+  useChat: (...args: unknown[]) => {
+    const chat = mocks.useChat(...args);
+    if (chat) chat.stop ??= vi.fn(async () => {});
+    return chat;
+  },
   Chat: class MockChat {
     constructor(config: unknown) {
       Object.assign(this, config);

package/src/runtime/useChatRuntime.ts

@@ -8,6 +8,7 @@ import {
   useRemoteThreadListRuntime,
 } from "@assistant-ui/core/react";
 import { useAui, useAuiState } from "@assistant-ui/store";
+import { useHostDestroySignal } from "@assistant-ui/store/internal";
 import { useChatThread, type ChatThreadOptions } from "./useChatThread";
 import { AI_SDK_SDK } from "./sdkIdentity";
 
@@ -18,7 +19,8 @@ export type UseChatRuntimeOptions<UI_MESSAGE extends UIMessage = UIMessage> =
   };
 
 const useChatThreadRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
-  options?: ChatThreadOptions<UI_MESSAGE>,
+  options: ChatThreadOptions<UI_MESSAGE> | undefined,
+  hostDestroySignal: AbortSignal,
 ): AssistantRuntime => {
   const id = useAuiState((s) => s.threadListItem.id);
   const isMainThread = useAuiState(
@@ -31,6 +33,7 @@ const useChatThreadRuntime = <UI_MESSAGE extends UIMessage = UIMessage>(
     getThreadListItem: () =>
       aui.threadListItem.source ? aui.threadListItem : undefined,
     stopOnClientDestroy: true,
+    hostDestroySignal,
   });
 };
 
@@ -39,10 +42,11 @@ export const useChatRuntime = <UI_MESSAGE extends UIMessage = UIMessage>({
   onThreadIdChange,
   ...options
 }: UseChatRuntimeOptions<UI_MESSAGE> = {}): AssistantRuntime => {
+  const hostDestroySignal = useHostDestroySignal();
   const cloudAdapter = useCloudThreadListAdapter({ cloud, sdk: AI_SDK_SDK });
   return useRemoteThreadListRuntime({
     runtimeHook: function RuntimeHook() {
-      return useChatThreadRuntime(options);
+      return useChatThreadRuntime(options, hostDestroySignal);
     },
     adapter: cloudAdapter,
     allowNesting: true,

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

@@ -0,0 +1,149 @@
+// @vitest-environment jsdom
+
+import { act, renderHook, waitFor } from "@testing-library/react";
+import { useEffect } from "react";
+import { describe, expect, it, vi } from "vitest";
+import { Chat } from "@ai-sdk/react";
+import {
+  AssistantChatTransport,
+  type InitializableThreadListItem,
+} from "../transport/AssistantChatTransport";
+import { useChatThread } from "./useChatThread";
+
+const itemFor = (remoteId: string) => ({
+  initialize: async () => ({ remoteId, externalId: undefined }),
+});
+
+const finishedStream = () =>
+  new Response(
+    new ReadableStream<Uint8Array>({
+      start(controller) {
+        controller.enqueue(
+          new TextEncoder().encode(
+            'data: {"type":"start"}\n\ndata: {"type":"finish"}\n\ndata: [DONE]\n\n',
+          ),
+        );
+        controller.close();
+      },
+    }),
+    { headers: { "content-type": "text/event-stream" } },
+  );
+
+describe("useChatThread shared transport isolation", () => {
+  it("gives each thread its own clone wired to its own thread-list item", async () => {
+    const transport = new AssistantChatTransport({ api: "/api/chat" });
+    const setRuntime = vi.spyOn(transport, "setRuntime");
+    const setGetItem = vi.spyOn(transport, "__internal_setGetThreadListItem");
+    const clones: AssistantChatTransport<never>[] = [];
+    const getters: (() => InitializableThreadListItem | undefined)[] = [];
+    const realClone = transport.__internal_clone.bind(transport);
+    vi.spyOn(transport, "__internal_clone").mockImplementation(() => {
+      const clone = realClone();
+      const index = clones.push(clone as AssistantChatTransport<never>) - 1;
+      vi.spyOn(clone, "__internal_setGetThreadListItem").mockImplementation(
+        (getter) => {
+          getters[index] = getter;
+        },
+      );
+      return clone;
+    });
+
+    renderHook(() =>
+      useChatThread(
+        { transport },
+        {
+          id: "thread-a",
+          isMainThread: true,
+          getThreadListItem: () => itemFor("remote-a"),
+        },
+      ),
+    );
+    renderHook(() =>
+      useChatThread(
+        { transport },
+        {
+          id: "thread-b",
+          isMainThread: false,
+          getThreadListItem: () => itemFor("remote-b"),
+        },
+      ),
+    );
+
+    expect(setRuntime).not.toHaveBeenCalled();
+    expect(setGetItem).not.toHaveBeenCalled();
+    expect(clones).toHaveLength(2);
+    expect(clones[0]).not.toBe(clones[1]);
+
+    const remoteIdOf = async (
+      getter?: () => InitializableThreadListItem | undefined,
+    ) => (await getter?.()?.initialize())?.remoteId;
+    expect(await remoteIdOf(getters[0])).toBe("remote-a");
+    expect(await remoteIdOf(getters[1])).toBe("remote-b");
+  });
+
+  it("sends each thread's request with that thread's remoteId and model context", async () => {
+    const sent: { id: unknown; system: unknown }[] = [];
+    const transport = new AssistantChatTransport({
+      api: "/api/chat",
+      fetch: async (_input, init) => {
+        const body = JSON.parse(String(init?.body)) as Record<string, unknown>;
+        sent.push({ id: body["id"], system: body["system"] });
+        return finishedStream();
+      },
+    });
+
+    const mount = (id: string, remoteId: string, system: string) =>
+      renderHook(() => {
+        const runtime = useChatThread(
+          { transport },
+          {
+            id,
+            isMainThread: id === "thread-a",
+            getThreadListItem: () => itemFor(remoteId),
+          },
+        );
+        useEffect(
+          () =>
+            runtime.registerModelContextProvider({
+              getModelContext: () => ({ system }),
+            }),
+          [runtime],
+        );
+        return runtime;
+      });
+
+    const threadA = mount("thread-a", "remote-a", "system-a");
+    const threadB = mount("thread-b", "remote-b", "system-b");
+
+    threadA.rerender();
+
+    await act(async () => {
+      threadB.result.current.thread.append("hello");
+    });
+
+    await waitFor(() => expect(sent).toHaveLength(1));
+    expect(sent[0]).toEqual({ id: "remote-b", system: "system-b" });
+  });
+
+  it("uses the supplied instance when the caller owns the chat", () => {
+    const transport = new AssistantChatTransport({ api: "/api/chat" });
+    const clone = vi.spyOn(transport, "__internal_clone");
+    const chat = new Chat({ id: "thread-a", transport });
+
+    renderHook(() =>
+      useChatThread(
+        { transport },
+        {
+          id: "thread-a",
+          isMainThread: true,
+          getThreadListItem: () => itemFor("remote-a"),
+          chat,
+        },
+      ),
+    );
+
+    // A caller-owned chat is already bound to its transport, so cloning again
+    // would wire an instance the chat never sends through.
+    expect(clone).not.toHaveBeenCalled();
+  });
+});