@assistant-ui/ai-sdk 0.0.6 → 0.0.8

package/src/converters/convertMessage.ts

@@ -12,6 +12,7 @@ import {
 import {
   isMcpAppUri,
   type ReasoningMessagePart,
+  type ToolApprovalOption,
   type ToolCallMessagePart,
   type TextMessagePart,
   type DataMessagePart,
@@ -22,6 +23,8 @@ import {
   type ThreadMessageLike,
   type McpAppMetadata,
   type MessagePartStreamStatus,
+  type RespondToToolApprovalOptions,
+  type Unstable_ToolInteractionLog,
 } from "@assistant-ui/core";
 import { stableStringifyToolArgs } from "@assistant-ui/core/internal";
 import {
@@ -47,7 +50,7 @@ const THREAD_METADATA_KEYS = new Set([
 const toThreadMetadata = (metadata: unknown): MessageMetadata => {
   if (!metadata || typeof metadata !== "object") return undefined;
   const result: Record<string, unknown> = {};
-  const extra: Record<string, unknown> = {};
+  const extra = Object.create(null) as Record<string, unknown>;
   for (const [key, value] of Object.entries(metadata)) {
     (THREAD_METADATA_KEYS.has(key) ? result : extra)[key] = value;
   }
@@ -59,8 +62,20 @@ const toThreadMetadata = (metadata: unknown): MessageMetadata => {
 export type AISDKMessageConverterMetadata =
   useExternalMessageConverter.Metadata & {
     toolArgsKeyOrderCache?: Map<string, Map<string, string[]>>;
+    /**
+     * Frozen `argsText` keyed weakly by a settled tool call's input object, then
+     * by call, since the text carries the call's streamed key order. A known
+     * call/input pair skips serialization; the entries become collectible once
+     * the input is unreachable. A fresh input object re-serializes in its own
+     * deterministic key order.
+     */
+    toolArgsTextCache?: WeakMap<ReadonlyJSONObject, Map<string, string>>;
     toolLastInputCache?: Map<string, ReadonlyJSONObject>;
     mcpAppMetadataCache?: Map<string, McpAppMetadata>;
+    toolArtifacts?: ReadonlyMap<string, unknown>;
+    toolInteractions?: ReadonlyMap<string, Unstable_ToolInteractionLog>;
+    supportsRichToolApprovalResponses?: boolean;
+    toolApprovalResponses?: ReadonlyMap<string, RespondToToolApprovalOptions>;
     /** Id of the currently-streaming message, flagged optimistic (#4037). */
     optimisticMessageId?: string | undefined;
   };
@@ -153,19 +168,115 @@ function extractMcpAppMetadata(
   return out;
 }
 
+const normalizeToolApprovalOptions = (
+  options: unknown,
+): readonly ToolApprovalOption[] | undefined => {
+  if (!Array.isArray(options)) return undefined;
+
+  return options.flatMap<ToolApprovalOption>((value) => {
+    if (!value || typeof value !== "object" || Array.isArray(value)) return [];
+    const option = value as Record<string, unknown>;
+    if (typeof option.id !== "string" || typeof option.kind !== "string")
+      return [];
+
+    const confirm = option.confirm;
+    const confirmDetails =
+      confirm && typeof confirm === "object" && !Array.isArray(confirm)
+        ? (confirm as Record<string, unknown>)
+        : undefined;
+
+    return [
+      {
+        id: option.id,
+        kind: option.kind,
+        ...(typeof option.label === "string" && { label: option.label }),
+        ...(typeof option.description === "string" && {
+          description: option.description,
+        }),
+        ...(Array.isArray(option.grants) && {
+          grants: option.grants.filter(
+            (grant): grant is string => typeof grant === "string",
+          ),
+        }),
+        ...(typeof confirm === "boolean"
+          ? { confirm }
+          : confirmDetails
+            ? {
+                confirm: {
+                  ...(typeof confirmDetails.title === "string" && {
+                    title: confirmDetails.title,
+                  }),
+                  ...(typeof confirmDetails.description === "string" && {
+                    description: confirmDetails.description,
+                  }),
+                },
+              }
+            : {}),
+      },
+    ];
+  });
+};
+
+const APPROVAL_DESCRIPTOR_FIELDS = [
+  "prompt",
+  "display",
+  "allowFreeform",
+  "dismissible",
+  "options",
+  "optionId",
+  "text",
+  "resolution",
+] as const;
+
+// The AI SDK's approval object declares none of the core request and answer
+// fields and `validateUIMessages` strips unknown ones, so a host streams or
+// persists them inside the opaque `approvalDescriptor`. Only those fields are
+// read from it: a descriptor cannot approve its own request.
+const readApprovalDescriptor = (
+  descriptor: unknown,
+): Record<string, unknown> => {
+  if (
+    !descriptor ||
+    typeof descriptor !== "object" ||
+    Array.isArray(descriptor)
+  )
+    return {};
+  const fields: Record<string, unknown> = {};
+  for (const key of APPROVAL_DESCRIPTOR_FIELDS) {
+    if (Object.hasOwn(descriptor, key))
+      fields[key] = (descriptor as Record<string, unknown>)[key];
+  }
+  return fields;
+};
+
 function getToolApprovalAndInterrupt(
   part: {
     approval?: Record<string, unknown> | undefined;
   },
   toolStatus: { type: string; payload?: unknown } | undefined,
+  supportsRichToolApprovalResponses: boolean,
+  toolApprovalResponses:
+    | ReadonlyMap<string, RespondToToolApprovalOptions>
+    | undefined,
 ): {
   approval?: NonNullable<ToolCallMessagePart["approval"]>;
   interrupt?: NonNullable<ToolCallMessagePart["interrupt"]>;
 } {
   if (part.approval) {
-    // The AI SDK sends only id, approved and reason back to the server, so a
-    // request shape promising any other answer would render controls whose
-    // response cannot travel.
+    const approval = {
+      ...readApprovalDescriptor(part.approval.descriptor),
+      ...part.approval,
+    };
+    const response =
+      typeof approval.id === "string" &&
+      approval.approved === undefined &&
+      approval.resolution !== "cancelled" &&
+      approval.resolution !== "expired"
+        ? toolApprovalResponses?.get(approval.id)
+        : undefined;
+    // The built-in AI SDK channel sends only id, approved and reason back to
+    // the server, so a request shape promising any other answer would render
+    // controls whose response cannot travel.
     const {
       id,
       prompt,
@@ -175,11 +286,23 @@ function getToolApprovalAndInterrupt(
       resolution,
       display,
       allowFreeform,
+      dismissible,
       options,
       optionId,
       text,
       ...additionalApprovalFields
-    } = part.approval;
+    } = response
+      ? {
+          ...approval,
+          approved: response.approved,
+          ...(response.reason != null && { reason: response.reason }),
+          ...(response.optionId != null && { optionId: response.optionId }),
+          ...(response.text != null && { text: response.text }),
+        }
+      : approval;
+    const normalizedOptions = supportsRichToolApprovalResponses
+      ? normalizeToolApprovalOptions(options)
+      : undefined;
     const requestReason = additionalApprovalFields.requestReason;
     if (typeof id === "string")
       return {
@@ -194,6 +317,16 @@ function getToolApprovalAndInterrupt(
           ...(typeof approved === "boolean" && { approved }),
           ...(typeof reason === "string" && { reason }),
           ...(isAutomatic === true && { isAutomatic: true }),
+          ...(supportsRichToolApprovalResponses && {
+            ...((display === "decision" ||
+              display === "select" ||
+              display === "text") && { display }),
+            ...(typeof allowFreeform === "boolean" && { allowFreeform }),
+            ...(typeof dismissible === "boolean" && { dismissible }),
+            ...(normalizedOptions && { options: normalizedOptions }),
+            ...(typeof optionId === "string" && { optionId }),
+            ...(typeof text === "string" && { text }),
+          }),
           ...((resolution === "cancelled" || resolution === "expired") && {
             resolution,
           }),
@@ -270,7 +403,14 @@ function convertParts(
         const toolCallId = part.toolCallId;
         const argsKeyOrderCacheKey = `${message.id}:${toolCallId}`;
 
-        const rawInput = part.input as ReadonlyJSONObject | null | undefined;
+        // A tool call that streamed complete arguments then failed schema
+        // validation keeps them in `rawInput`, not `input`; reading `input`
+        // alone would convert the error snapshot to `{}` and hide the input.
+        const rawInput = (part.input ??
+          ("rawInput" in part ? part.rawInput : undefined)) as
+          | ReadonlyJSONObject
+          | null
+          | undefined;
         let args: ReadonlyJSONObject;
         if (
           rawInput != null &&
@@ -303,12 +443,13 @@ function convertParts(
           };
         }
 
-        let argsText = stableStringifyToolArgs(
-          metadata.toolArgsKeyOrderCache,
-          argsKeyOrderCacheKey,
-          args,
-        );
+        let argsText: string;
         if (part.state === "input-streaming") {
+          argsText = stableStringifyToolArgs(
+            metadata.toolArgsKeyOrderCache,
+            argsKeyOrderCacheKey,
+            args,
+          );
           // strip closing delimiters added by the AI SDK's fix-json
           argsText = stripClosingDelimiters(argsText);
           // Re-parse so args carries the partial-JSON meta that marks which
@@ -317,6 +458,27 @@ function convertParts(
           // of the stripped text is the streaming frontier.
           args = parsePartialJsonObject(argsText) ?? args;
         } else {
+          // A settled part is re-converted whenever its message or the converter
+          // metadata changes; the text frozen on its input object skips
+          // re-serializing large args while the call keeps that input. Arrival
+          // order only matters while args stream, so the key-order entry is
+          // released.
+          const frozen =
+            metadata.toolArgsTextCache?.get(args) ?? new Map<string, string>();
+          const frozenText = frozen.get(argsKeyOrderCacheKey);
+          if (frozenText !== undefined) {
+            argsText = frozenText;
+          } else {
+            argsText = stableStringifyToolArgs(
+              metadata.toolArgsKeyOrderCache,
+              argsKeyOrderCacheKey,
+              args,
+            );
+            metadata.toolArgsTextCache?.set(
+              args,
+              frozen.set(argsKeyOrderCacheKey, argsText),
+            );
+          }
           metadata.toolArgsKeyOrderCache?.delete(argsKeyOrderCacheKey);
           if (
             part.state === "output-available" ||
@@ -332,6 +494,8 @@ function convertParts(
           part,
           metadata.mcpAppMetadataCache,
         );
+        const artifact = metadata.toolArtifacts?.get(toolCallId);
+        const interactions = metadata.toolInteractions?.get(toolCallId);
         return {
           type: "tool-call",
           toolName,
@@ -340,6 +504,12 @@ function convertParts(
           args,
           result,
           isError,
+          ...(artifact !== undefined && { artifact }),
+          ...(interactions !== undefined && {
+            unstable_interactions: interactions,
+          }),
+          ...(part.state === "output-available" &&
+            part.preliminary === true && { isPreliminary: true }),
           ...(modelContent !== undefined && { modelContent }),
           ...(mcpApp && { mcp: { app: mcpApp } }),
           ...(part.callProviderMetadata != null
@@ -348,7 +518,12 @@ function convertParts(
                   part.callProviderMetadata as PartProviderMetadata,
               }
             : undefined),
-          ...getToolApprovalAndInterrupt(part, toolStatus),
+          ...getToolApprovalAndInterrupt(
+            part,
+            toolStatus,
+            metadata.supportsRichToolApprovalResponses === true,
+            metadata.toolApprovalResponses,
+          ),
         } satisfies ToolCallMessagePart;
       }
 

package/src/index.native.ts

@@ -1,4 +1,4 @@
-/// <reference types="@assistant-ui/core/react" />
+/// <reference types="@assistant-ui/core/react" preserve="true" />
 
 export { useAISDKRuntime } from "./runtime/useAISDKRuntime";
 export { useChatRuntime } from "./runtime/useChatRuntime";

package/src/index.ts

@@ -1,4 +1,4 @@
-/// <reference types="@assistant-ui/core/react" />
+/// <reference types="@assistant-ui/core/react" preserve="true" />
 
 export { useAISDKRuntime } from "./runtime/useAISDKRuntime";
 export { useChatRuntime } from "./runtime/useChatRuntime";

package/src/runtime/AISDKChat.test.ts

@@ -153,7 +153,9 @@ describe("AISDKChat as a standalone client config entry", () => {
     ]
       .map((chunk) => `data: ${JSON.stringify(chunk)}\n\n`)
       .join("");
-    const fetchMock = vi.fn(
+    const fetchMock = vi.fn<
+      (input: RequestInfo | URL, init: RequestInit) => Promise<Response>
+    >(
       async () =>
         new Response(sse, {
           headers: { "content-type": "text/event-stream" },
@@ -178,10 +180,7 @@ describe("AISDKChat as a standalone client config entry", () => {
         expect(state.messages).toHaveLength(2);
       });
 
-      const [url, init] = fetchMock.mock.calls[0]! as [
-        RequestInfo,
-        RequestInit,
-      ];
+      const [url, init] = fetchMock.mock.calls[0]!;
       expect(String(url)).toContain("/api/chat");
       const body = JSON.parse(init.body as string);
       expect(body.id).toBe("test-thread-1");

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

@@ -1,8 +1,15 @@
 // @vitest-environment jsdom
 
+import { getEventListeners } from "node:events";
 import { describe, expect, it, vi } from "vitest";
-import { flushTapSync } from "@assistant-ui/tap";
-import { AuiConfig, createAssistantClient } from "@assistant-ui/store/client";
+import { flushTapSync, resource, useResource } from "@assistant-ui/tap";
+import {
+  attachTransformScopes,
+  AuiConfig,
+  createAssistantClient,
+} from "@assistant-ui/store/client";
+import { useAssistantClientDestroySignal } from "@assistant-ui/store/internal";
+import { inMemoryThreadListTransformScopes } from "@assistant-ui/core/store";
 import type { AssistantCloud } from "assistant-cloud";
 import type { RemoteThreadListAdapter } from "@assistant-ui/core";
 import type { ThreadHistoryAdapter } from "@assistant-ui/core";
@@ -152,4 +159,55 @@ describe("AISDKThreads cloud", () => {
       handle.destroy();
     }
   });
+
+  it("keeps cloud threads off the client destroy signal and stops them on destroy", async () => {
+    const chat = createCancellableTransport();
+    let destroySignal: AbortSignal | undefined;
+    function useThreads() {
+      destroySignal = useAssistantClientDestroySignal();
+      return useResource(
+        AISDKThreads({
+          cloud: {} as AssistantCloud,
+          threadId: "t1",
+          transport: () => chat.transport,
+        }),
+      );
+    }
+    attachTransformScopes(useThreads, inMemoryThreadListTransformScopes);
+    const handle = createAssistantClient(
+      AuiConfig({ threads: resource(useThreads)() }),
+    );
+    handle.subscribe(() => {});
+    const listeners = () => getEventListeners(destroySignal!, "abort").length;
+    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);
+      });
+      const withFirstThread = listeners();
+
+      flushTapSync(() => handle.getClient().threads.switchToThread("t2"));
+      await vi.waitFor(() => {
+        expect(handle.getClient().threads.getState().mainThreadId).toBe("t2");
+      });
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isLoading).toBe(false);
+      });
+      expect(listeners()).toBe(withFirstThread);
+
+      flushTapSync(() => handle.getClient().composer.setText("stream me"));
+      flushTapSync(() => handle.getClient().composer.send());
+      await vi.waitFor(() => {
+        expect(handle.getClient().thread.getState().isRunning).toBe(true);
+      });
+    } finally {
+      handle.destroy();
+    }
+    await vi.waitFor(() => {
+      expect(chat.getCancelCount()).toBe(1);
+    });
+  });
 });

package/src/runtime/AISDKThreads.test.ts

@@ -28,6 +28,33 @@ const threadText = (aui: ReturnType<typeof createAssistantClient>) =>
       m.content.map((part) => (part.type === "text" ? part.text : "")).join(""),
     );
 
+const createLiveHandle = (
+  getOptions: () => Parameters<typeof AISDKThreads>[0],
+) => {
+  const listeners = new Set<() => void>();
+  const handle = createAssistantClient({
+    getConfig: () => AuiConfig({ threads: AISDKThreads(getOptions()) }),
+    subscribe: (listener) => {
+      listeners.add(listener);
+      return () => listeners.delete(listener);
+    },
+  });
+  handle.subscribe(() => {});
+  return {
+    handle,
+    rerender: () =>
+      flushTapSync(() => listeners.forEach((listener) => listener())),
+  };
+};
+
+const chatCallbacks = () => ({
+  onToolCall: vi.fn(),
+  onData: vi.fn(),
+  onFinish: vi.fn(),
+  onError: vi.fn(),
+  sendAutomaticallyWhen: vi.fn(() => false),
+});
+
 describe("AISDKThreads", () => {
   it("runs one chat per thread and keeps histories isolated across switches", async () => {
     const { transport, emit, close } = createControlledTransport();
@@ -253,25 +280,19 @@ describe("AISDKThreads", () => {
 
   it("forwards ChatInit callbacks to each thread's chat from the latest render", 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 sendMessages = vi.spyOn(transport, "sendMessages");
+    const mounted = chatCallbacks();
+    const latest = chatCallbacks();
+    latest.sendAutomaticallyWhen.mockReturnValueOnce(true);
+    let callbacks = mounted;
+    const { handle, rerender } = createLiveHandle(() => ({
+      transport: () => transport,
+      ...callbacks,
+    }));
     const aui = handle.getClient();
 
-    onFinish = onFinishB;
-    flushTapSync(() => listeners.forEach((listener) => listener()));
+    callbacks = latest;
+    rerender();
 
     flushTapSync(() => aui.composer.setText("hi"));
     flushTapSync(() => aui.composer.send());
@@ -280,10 +301,36 @@ describe("AISDKThreads", () => {
         handle.getClient().thread.getState().messages.length,
       ).toBeGreaterThan(0);
     });
-    emit(...textReply("done"));
+    emit(
+      { type: "start" },
+      {
+        type: "tool-input-available",
+        toolCallId: "call-1",
+        toolName: "lookup",
+        input: {},
+      },
+      { type: "data-note", data: "note" },
+      { type: "finish" },
+    );
     close();
-    await vi.waitFor(() => expect(onFinishB).toHaveBeenCalledTimes(1));
-    expect(onFinishA).not.toHaveBeenCalled();
+    await vi.waitFor(() => expect(sendMessages).toHaveBeenCalledTimes(2));
+    emit({ type: "start" }, { type: "error", errorText: "boom" });
+    close();
+    await vi.waitFor(() => expect(latest.onFinish).toHaveBeenCalledTimes(2));
+
+    expect(latest.onToolCall).toHaveBeenCalledExactlyOnceWith({
+      toolCall: expect.objectContaining({ toolCallId: "call-1" }),
+    });
+    expect(latest.onData).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({ type: "data-note", data: "note" }),
+    );
+    expect(latest.onError).toHaveBeenCalledExactlyOnceWith(
+      expect.objectContaining({ message: "boom" }),
+    );
+    expect(latest.sendAutomaticallyWhen).toHaveBeenCalledOnce();
+    for (const callback of Object.values(mounted)) {
+      expect(callback).not.toHaveBeenCalled();
+    }
 
     handle.destroy();
   });
@@ -293,18 +340,10 @@ describe("AISDKThreads", () => {
     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 { handle, rerender } = createLiveHandle(() => ({
+      transport: () => transport,
+      onFinish,
+    }));
     const aui = handle.getClient();
 
     flushTapSync(() => aui.composer.setText("stream me"));
@@ -322,7 +361,7 @@ describe("AISDKThreads", () => {
 
     flushTapSync(() => aui.threads.switchToNewThread());
     onFinish = onFinishB;
-    flushTapSync(() => listeners.forEach((listener) => listener()));
+    rerender();
 
     emit({ type: "text-end", id: "t1" }, { type: "finish" });
     close();
@@ -361,18 +400,12 @@ describe("AISDKThreads", () => {
     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(() => {});
+    const { handle, rerender } = createLiveHandle(() => ({
+      cloud,
+      threadId: "t1",
+      transport,
+      onFinish,
+    }));
     try {
       await handle.getClient().threads.getLoadThreadsPromise();
       await vi.waitFor(() => {
@@ -383,7 +416,7 @@ describe("AISDKThreads", () => {
       });
 
       onFinish = onFinishB;
-      flushTapSync(() => listeners.forEach((listener) => listener()));
+      rerender();
 
       flushTapSync(() => handle.getClient().composer.setText("hi"));
       flushTapSync(() => handle.getClient().composer.send());
@@ -455,7 +488,9 @@ describe("AISDKThreads", () => {
     const list = vi.fn(async () => ({
       threads: [cloudThread("cloud-1"), cloudThread("cloud-2")],
     }));
-    const create = vi.fn(async () => ({ thread_id: "cloud-created" }));
+    const create = vi.fn<AssistantCloud["threads"]["create"]>(async () => ({
+      thread_id: "cloud-created",
+    }));
     const deleteThread = vi.fn(async () => {});
     const cloud = {
       threads: {
@@ -521,7 +556,9 @@ describe("AISDKThreads", () => {
       external_id: null,
       metadata: null,
     });
-    const create = vi.fn(async () => ({ message_id: "remote-message-1" }));
+    const create = vi.fn<AssistantCloud["threads"]["messages"]["create"]>(
+      async () => ({ message_id: "remote-message-1" }),
+    );
     const cloud = {
       threads: {
         list: vi.fn(async () => ({
@@ -602,9 +639,9 @@ describe("AISDKThreads", () => {
       external_id: null,
       metadata: null,
     });
-    const createMessage = vi.fn(async () => ({
-      message_id: "remote-message-1",
-    }));
+    const createMessage = vi.fn<
+      AssistantCloud["threads"]["messages"]["create"]
+    >(async () => ({ message_id: "remote-message-1" }));
     const cloud = {
       threads: {
         list: vi.fn(async () => ({ threads: [cloudThread("t1")] })),

package/src/runtime/AISDKThreads.ts

@@ -2,7 +2,7 @@
 
 import { resource, useResource, withKey } from "@assistant-ui/tap";
 import { useEffect, useMemo, useState } from "react";
-import { Chat, type UIMessage } from "@ai-sdk/react";
+import type { Chat, UIMessage } from "@ai-sdk/react";
 import type { ChatTransport } from "ai";
 import type { AssistantCloud } from "assistant-cloud";
 import {
@@ -20,6 +20,7 @@ import {
 import { useAui } from "@assistant-ui/store";
 import { AssistantChatTransport } from "../transport/AssistantChatTransport";
 import {
+  createChat,
   splitChatThreadOptions,
   useChatThread,
   type ChatThreadOptions,
@@ -91,17 +92,7 @@ const createChatEntry = <UI_MESSAGE extends UIMessage>(
           ? options.transport.__internal_clone()
           : options.transport;
   return {
-    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,
-    }),
+    chat: createChat({ ...chatInit, id: threadId, transport }, optionsRef),
     transport,
     repository: new MessageRepository(),
     optionsRef,
@@ -171,7 +162,7 @@ const useAISDKChatThread = <UI_MESSAGE extends UIMessage = UIMessage>({
           : fallbackItem,
       chat,
       messageRepositoryInstance: repository,
-      stopOnClientDestroy: cloud,
+      stopOnClientDestroy: false,
     },
   );