@assistant-ui/ai-sdk 0.0.6 → 0.0.8

package/dist/runtime/useAISDKRuntime.d.ts

@@ -1,64 +1,75 @@
-import { JoinStrategy } from "@assistant-ui/core/react";
-import { AppendMessage, AssistantRuntime, ExternalStoreAdapter, ExternalStoreSharedOptions, MessageFormatRepository, SuggestionAdapter, ThreadHistoryAdapter } from "@assistant-ui/core";
+import type { UIMessage, useChat, CreateUIMessage } from "@ai-sdk/react";
+import { type JoinStrategy } from "@assistant-ui/core/react";
+import type { SuggestionAdapter } from "@assistant-ui/core";
+import type { ExternalStoreAdapter, ExternalStoreSharedOptions, ThreadHistoryAdapter, AssistantRuntime, MessageFormatRepository, AppendMessage, RespondToToolApprovalOptions } from "@assistant-ui/core";
 import { MessageRepository } from "@assistant-ui/core/internal";
-import { CreateUIMessage, UIMessage, useChat } from "@ai-sdk/react";
-//#region src/runtime/useAISDKRuntime.d.ts
-type CustomToCreateMessageFunction = <UI_MESSAGE extends UIMessage = UIMessage>(message: AppendMessage) => CreateUIMessage<UI_MESSAGE>;
-type AISDKRuntimeAdapter<UI_MESSAGE extends UIMessage = UIMessage> = ExternalStoreSharedOptions & {
-  adapters?: (NonNullable<ExternalStoreAdapter["adapters"]> & {
-    history?: ThreadHistoryAdapter | undefined;
-    suggestion?: SuggestionAdapter | undefined;
-  }) | undefined;
-  toCreateMessage?: CustomToCreateMessageFunction;
-  unstable_messageRepositoryInstance?: MessageRepository | undefined;
-  /**
-   * Whether to automatically cancel pending interactive tool calls when the user sends a new message.
-   *
-   * When enabled (default), the pending tool calls will be marked as failed with an error message
-   * indicating the user cancelled the tool call by sending a new message.
-   *
-   * @default true
-   */
-  cancelPendingToolCallsOnSend?: boolean | undefined;
-  /**
-   * Called when `runtime.thread.resumeRun(config)` is invoked.
-   *
-   * When omitted, `resumeRun` throws `"Runtime does not support resuming runs."`.
-   * Provide this to bridge resume invocations into a custom replay channel
-   * (for example, an SSE reconnect endpoint keyed by turn id).
-   */
-  onResume?: ExternalStoreAdapter["onResume"];
-  /**
-   * Called when `runtime.thread.resumeToolCall(options)` is invoked for a tool call the in-process tracker does not own.
-   *
-   * When omitted, `resumeToolCall` throws `"Tool call ${toolCallId} is not waiting for resume."`.
-   * Provide this to bridge resume-tool-call invocations into a custom handler.
-   */
-  onResumeToolCall?: ExternalStoreAdapter["onResumeToolCall"];
-  /**
-   * How consecutive assistant messages are rendered.
-   *
-   * `"concat-content"` (the default) merges them into a single thread message.
-   * `"none"` keeps each assistant message as its own thread message, which is
-   * useful when a backend persists proactive or consecutive assistant messages
-   * as separate entries.
-   */
-  joinStrategy?: JoinStrategy | undefined;
-  /**
-   * A branch-aware AI SDK message tree seeded once when `useChat` is empty.
-   * After that seed, live updates come only from `useChat`. A later empty
-   * chat or a new object identity does not reload the tree.
-   */
-  messageRepository?: MessageFormatRepository<UI_MESSAGE>;
-  /**
-   * Called after an explicit `switchToBranch` (for example a BranchPicker
-   * click). Complements `setMessages` and does not enable switching by itself.
-   *
-   * @deprecated This API is still under active development and might change without notice.
-   */
-  unstable_onBranchChange?: ExternalStoreAdapter["unstable_onBranchChange"];
+export type CustomToCreateMessageFunction = <UI_MESSAGE extends UIMessage = UIMessage>(message: AppendMessage) => CreateUIMessage<UI_MESSAGE>;
+export type AISDKRuntimeAdapter<UI_MESSAGE extends UIMessage = UIMessage> = ExternalStoreSharedOptions & {
+    adapters?: (NonNullable<ExternalStoreAdapter["adapters"]> & {
+        history?: ThreadHistoryAdapter | undefined;
+        suggestion?: SuggestionAdapter | undefined;
+    }) | undefined;
+    toCreateMessage?: CustomToCreateMessageFunction;
+    unstable_messageRepositoryInstance?: MessageRepository | undefined;
+    /**
+     * Whether to automatically cancel pending interactive tool calls when the user sends a new message.
+     *
+     * When enabled (default), the pending tool calls will be marked as failed with an error message
+     * indicating the user cancelled the tool call by sending a new message.
+     *
+     * @default true
+     */
+    cancelPendingToolCallsOnSend?: boolean | undefined;
+    /**
+     * Called when `runtime.thread.resumeRun(config)` is invoked.
+     *
+     * When omitted, `resumeRun` throws `"Runtime does not support resuming runs."`.
+     * Provide this to bridge resume invocations into a custom replay channel
+     * (for example, an SSE reconnect endpoint keyed by turn id).
+     */
+    onResume?: ExternalStoreAdapter["onResume"];
+    /**
+     * Called when `runtime.thread.resumeToolCall(options)` is invoked for a tool call the in-process tracker does not own.
+     *
+     * When omitted, `resumeToolCall` throws `"Tool call ${toolCallId} is not waiting for resume."`.
+     * Provide this to bridge resume-tool-call invocations into a custom handler.
+     */
+    onResumeToolCall?: ExternalStoreAdapter["onResumeToolCall"];
+    /**
+     * 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. 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`, `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?: ((response: RespondToToolApprovalOptions, context: {
+        toolCallId: string;
+        toolName: string;
+        /** Sends this response through the AI SDK's `addToolApprovalResponse`, which carries only `approved` and `reason`. */
+        respondViaAISDK: () => Promise<void>;
+    }) => Promise<void> | void) | undefined;
+    /**
+     * How consecutive assistant messages are rendered.
+     *
+     * `"concat-content"` (the default) merges them into a single thread message.
+     * `"none"` keeps each assistant message as its own thread message, which is
+     * useful when a backend persists proactive or consecutive assistant messages
+     * as separate entries.
+     */
+    joinStrategy?: JoinStrategy | undefined;
+    /**
+     * A branch-aware AI SDK message tree seeded once when `useChat` is empty.
+     * After that seed, live updates come only from `useChat`. A later empty
+     * chat or a new object identity does not reload the tree.
+     */
+    messageRepository?: MessageFormatRepository<UI_MESSAGE>;
+    /**
+     * Called after an explicit `switchToBranch` (for example a BranchPicker
+     * click). Complements `setMessages` and does not enable switching by itself.
+     *
+     * @deprecated This API is still under active development and might change without notice.
+     */
+    unstable_onBranchChange?: ExternalStoreAdapter["unstable_onBranchChange"];
 };
-declare const useAISDKRuntime: <UI_MESSAGE extends UIMessage = UIMessage>(chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>, adapter?: AISDKRuntimeAdapter<UI_MESSAGE>) => AssistantRuntime;
-//#endregion
-export { AISDKRuntimeAdapter, CustomToCreateMessageFunction, useAISDKRuntime };
+export declare const useAISDKRuntime: <UI_MESSAGE extends UIMessage = UIMessage>(chatHelpers: ReturnType<typeof useChat<UI_MESSAGE>>, adapter?: AISDKRuntimeAdapter<UI_MESSAGE>) => AssistantRuntime;
 //# sourceMappingURL=useAISDKRuntime.d.ts.map

package/dist/runtime/useAISDKRuntime.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useAISDKRuntime.d.ts","names":[],"sources":["../../src/runtime/useAISDKRuntime.ts"],"mappings":";;;;;KAmEY,iCACV,mBAAmB,YAAY,WAE/B,SAAS,kBACN,gBAAgB;KAYT,oBAAoB,mBAAmB,YAAY,aAC7D;EACE,YACK,YAAY;IACX,UAAU;IACV,aAAa;;EAGnB,kBAAkB;EAClB,qCAAqC;;;;;;;;;EASrC;;;;;;;;EAQA,WAAW;;;;;;;EAOX,mBAAmB;;;;;;;;;EASnB,eAAe;;;;;;EAMf,oBAAoB,wBAAwB;;;;;;;EAO5C,0BAA0B;;cAiGjB,kBAAmB,mBAAmB,YAAY,WAC7D,aAAa,kBAAkB,QAAQ,cACvC,UAAS,oBAAoB,gBAAgB"}
+{"version":3,"file":"useAISDKRuntime.d.ts","sourceRoot":"","sources":["../../src/runtime/useAISDKRuntime.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EACV,SAAS,EACT,OAAO,EACP,eAAe,EAEhB,MAAM,eAAe,CAAC;AAEvB,OAAO,EAGL,KAAK,YAAY,EAClB,MAAM,0BAA0B,CAAC;AAClC,OAAO,KAAK,EACV,iBAAiB,EAGlB,MAAM,oBAAoB,CAAC;AAC5B,OAAO,KAAK,EACV,oBAAoB,EACpB,0BAA0B,EAC1B,oBAAoB,EACpB,gBAAgB,EAIhB,uBAAuB,EACvB,aAAa,EAGb,4BAA4B,EAE7B,MAAM,oBAAoB,CAAC;AAK5B,OAAO,EAGL,iBAAiB,EAClB,MAAM,6BAA6B,CAAC;AAuBrC,MAAM,MAAM,6BAA6B,GAAG,CAC1C,UAAU,SAAS,SAAS,GAAG,SAAS,EAExC,OAAO,EAAE,aAAa,KACnB,eAAe,CAAC,UAAU,CAAC,CAAC;AA6BjC,MAAM,MAAM,mBAAmB,CAAC,UAAU,SAAS,SAAS,GAAG,SAAS,IACtE,0BAA0B,GAAG;IAC3B,QAAQ,CAAC,EACL,CAAC,WAAW,CAAC,oBAAoB,CAAC,UAAU,CAAC,CAAC,GAAG;QAC/C,OAAO,CAAC,EAAE,oBAAoB,GAAG,SAAS,CAAC;QAC3C,UAAU,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;KAC5C,CAAC,GACF,SAAS,CAAC;IACd,eAAe,CAAC,EAAE,6BAA6B,CAAC;IAChD,kCAAkC,CAAC,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACnE;;;;;;;OAOG;IACH,4BAA4B,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACnD;;;;;;OAMG;IACH,QAAQ,CAAC,EAAE,oBAAoB,CAAC,UAAU,CAAC,CAAC;IAC5C;;;;;OAKG;IACH,gBAAgB,CAAC,EAAE,oBAAoB,CAAC,kBAAkB,CAAC,CAAC;IAC5D;;;;;;OAMG;IACH,uBAAuB,CAAC,EACpB,CAAC,CACC,QAAQ,EAAE,4BAA4B,EACtC,OAAO,EAAE;QACP,UAAU,EAAE,MAAM,CAAC;QACnB,QAAQ,EAAE,MAAM,CAAC;QACjB,sHAAsH;QACtH,eAAe,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;KACtC,KACE,OAAO,CAAC,IAAI,CAAC,GAAG,IAAI,CAAC,GAC1B,SAAS,CAAC;IACd;;;;;;;OAOG;IACH,YAAY,CAAC,EAAE,YAAY,GAAG,SAAS,CAAC;IACxC;;;;OAIG;IACH,iBAAiB,CAAC,EAAE,uBAAuB,CAAC,UAAU,CAAC,CAAC;IACxD;;;;;OAKG;IACH,uBAAuB,CAAC,EAAE,oBAAoB,CAAC,yBAAyB,CAAC,CAAC;CAC3E,CAAC;AAqGJ,eAAO,MAAM,eAAe,GAAI,UAAU,SAAS,SAAS,GAAG,SAAS,EACtE,aAAa,UAAU,CAAC,OAAO,OAAO,CAAC,UAAU,CAAC,CAAC,EACnD,UAAS,mBAAmB,CAAC,UAAU,CAAM,qBAonB9C,CAAC"}

package/dist/runtime/useAISDKRuntime.js

@@ -1,26 +1,38 @@
 "use client";
-import { aiSDKExtras } from "../aiSDKExtras.js";
-import { sliceMessagesUntil } from "../utils/sliceMessagesUntil.js";
-import { toCreateMessage } from "../converters/toCreateMessage.js";
+import { aiSDKV6FormatAdapter } from "../adapters/aiSDKFormatAdapter.js";
 import { vercelAttachmentAdapter } from "../adapters/vercelAttachmentAdapter.js";
-import { getVercelAIMessages } from "../utils/getVercelAIMessages.js";
+import { aiSDKExtras } from "../aiSDKExtras.js";
 import { wrapModelContentEnvelope } from "../converters/modelContentEnvelope.js";
 import { AISDKMessageConverter } from "../converters/convertMessage.js";
-import { aiSDKV6FormatAdapter } from "../adapters/aiSDKFormatAdapter.js";
+import { toCreateMessage } from "../converters/toCreateMessage.js";
+import { sliceMessagesUntil } from "../utils/sliceMessagesUntil.js";
+import { getVercelAIMessages } from "../utils/getVercelAIMessages.js";
 import { toExportedMessageRepository, useExternalHistory } from "./useExternalHistory.js";
 import { useStreamingTiming as useStreamingTiming$1 } from "./useStreamingTiming.js";
+import { MessageRepository, appendToolInteraction, consumeSuggestionResult } from "@assistant-ui/core/internal";
+import { generateId, getToolName, isToolUIPart } from "ai";
 import { useExternalStoreRuntime, useRuntimeAdapters } from "@assistant-ui/core/react";
+import { getExternalStoreMessages, pickExternalStoreSharedOptions } from "@assistant-ui/core";
 import { c } from "@assistant-ui/tap/react-shim/compiler-runtime";
 import { useCallback, useEffect, useInsertionEffect, useMemo, useRef, useState } from "@assistant-ui/tap/react-shim";
-import { generateId, isToolUIPart } from "ai";
-import { getExternalStoreMessages, pickExternalStoreSharedOptions } from "@assistant-ui/core";
-import { MessageRepository, consumeSuggestionResult } from "@assistant-ui/core/internal";
 //#region src/runtime/useAISDKRuntime.ts
 const toUIMessage = (createMessage, fallbackRole) => ({
 	...createMessage,
 	id: createMessage.id ?? generateId(),
 	role: createMessage.role ?? fallbackRole
 });
+const toVoiceTranscriptUIMessage = (message) => ({
+	id: message.id,
+	role: message.role,
+	parts: message.content.filter((part) => part.type === "text").map((part) => ({
+		type: "text",
+		text: part.text
+	})),
+	metadata: {
+		...message.metadata.modality && { modality: message.metadata.modality },
+		...Object.keys(message.metadata.custom).length > 0 && { custom: message.metadata.custom }
+	}
+});
 const EMPTY_SUGGESTIONS = [];
 const useGeneratedSuggestions = (suggestionAdapter, messages, isRunning) => {
 	const $ = c(13);
@@ -129,6 +141,7 @@ const useGeneratedSuggestions = (suggestionAdapter, messages, isRunning) => {
 	return suggestions;
 };
 const NO_CANCELLED_MESSAGE_IDS = /* @__PURE__ */ new Set();
+const NO_TOOL_APPROVAL_RESPONSES = /* @__PURE__ */ new Map();
 const toChatError = (error) => {
 	const code = error.code;
 	return {
@@ -137,15 +150,29 @@ const toChatError = (error) => {
 	};
 };
 const useAISDKRuntime = (chatHelpers, adapter = {}) => {
-	const { adapters, toCreateMessage: customToCreateMessage, cancelPendingToolCallsOnSend = true, onResume, onResumeToolCall, joinStrategy, messageRepository, unstable_onBranchChange } = adapter;
+	const { adapters, toCreateMessage: customToCreateMessage, cancelPendingToolCallsOnSend = true, onResume, onResumeToolCall, onRespondToToolApproval: customOnRespondToToolApproval, joinStrategy, messageRepository, unstable_onBranchChange } = adapter;
 	const suggestionAdapter = adapters?.suggestion;
 	const contextAdapters = useRuntimeAdapters();
 	const [toolStatuses, setToolStatuses] = useState({});
 	const [cancelledMessages, setCancelledMessages] = useState(null);
+	const [toolApprovalResponses, setToolApprovalResponses] = useState(NO_TOOL_APPROVAL_RESPONSES);
+	const [toolArtifactEpoch, setToolArtifactEpoch] = useState(0);
+	const [toolInteractionEpoch, setToolInteractionEpoch] = useState(0);
+	const hostApprovalIdsRef = useRef(/* @__PURE__ */ new Set());
+	const toolApprovalResponsesRef = useRef(/* @__PURE__ */ new Map());
 	const toolArgsKeyOrderCacheRef = useRef(/* @__PURE__ */ new Map());
 	const toolLastInputCacheRef = useRef(/* @__PURE__ */ new Map());
+	const toolArgsTextCacheRef = useRef(/* @__PURE__ */ new WeakMap());
 	const mcpAppMetadataCacheRef = useRef(/* @__PURE__ */ new Map());
+	const toolArtifactsRef = useRef(/* @__PURE__ */ new Map());
+	const toolInteractionsRef = useRef(/* @__PURE__ */ new Map());
 	const lastRunConfigRef = useRef(void 0);
+	const markToolArtifactsChanged = useCallback(() => {
+		setToolArtifactEpoch((epoch) => epoch + 1);
+	}, []);
+	const markToolInteractionsChanged = useCallback(() => {
+		setToolInteractionEpoch((epoch_0) => epoch_0 + 1);
+	}, []);
 	const hasExecutingTools = Object.values(toolStatuses).some((s) => s?.type === "executing");
 	const providerIsRunning = chatHelpers.status === "submitted" || chatHelpers.status === "streaming";
 	const isRunning = providerIsRunning || hasExecutingTools;
@@ -154,6 +181,16 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 	const lastMessage = chatHelpers.messages.at(-1);
 	const optimisticMessageId = isRunning && lastMessage?.role === "assistant" ? lastMessage.id : void 0;
 	const cancelledMessageIds = cancelledMessages?.chatId === chatHelpers.id ? cancelledMessages.ids : NO_CANCELLED_MESSAGE_IDS;
+	const supportsRichToolApprovalResponses = customOnRespondToToolApproval != null;
+	const toThreadMessages = useCallback((sourceMessages) => {
+		const metadata = {
+			supportsRichToolApprovalResponses,
+			toolArtifacts: toolArtifactsRef.current,
+			toolInteractions: toolInteractionsRef.current,
+			toolApprovalResponses: toolApprovalResponsesRef.current
+		};
+		return AISDKMessageConverter.toThreadMessages(sourceMessages, false, metadata);
+	}, [supportsRichToolApprovalResponses]);
 	const retractCancellation = useCallback((chatId, messageId) => {
 		setCancelledMessages((prev) => {
 			if (prev?.chatId !== chatId || !prev.ids.has(messageId)) return prev;
@@ -185,30 +222,42 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 			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 && { error: toChatError(chatHelpers.error) },
-			...cancelledMessageIds.size > 0 && { cancelledMessageIds }
+			...cancelledMessageIds.size > 0 && { cancelledMessageIds },
+			...toolApprovalResponses.size > 0 && { toolApprovalResponses }
 		}), [
 			toolStatuses,
 			messageTiming,
 			optimisticMessageId,
 			chatHelpers.error,
-			cancelledMessageIds
+			cancelledMessageIds,
+			toolApprovalResponses,
+			supportsRichToolApprovalResponses,
+			toolArtifactEpoch,
+			toolInteractionEpoch
 		])
 	});
 	const exportedMessageRepository = useMemo(() => {
 		if (!messageRepository) return void 0;
-		const converted = toExportedMessageRepository(AISDKMessageConverter.toThreadMessages, messageRepository);
+		const converted = toExportedMessageRepository(toThreadMessages, messageRepository);
 		return converted.messages.length > 0 ? converted : void 0;
-	}, [messageRepository]);
+	}, [messageRepository, toThreadMessages]);
 	const generatedSuggestions = useGeneratedSuggestions(suggestionAdapter, messages, isRunning);
 	const [runtimeRef] = useState(() => ({ get current() {
 		return runtime;
 	} }));
-	const { isLoading, deleteMessage: deleteHistoryMessage } = useExternalHistory(runtimeRef, adapters?.history ?? contextAdapters?.history, AISDKMessageConverter.toThreadMessages, aiSDKV6FormatAdapter, (messages_0) => {
+	const { isLoading, deleteMessage: deleteHistoryMessage, persistToolInteractions, persistToolApprovalResponses } = useExternalHistory(runtimeRef, adapters?.history ?? contextAdapters?.history, toThreadMessages, aiSDKV6FormatAdapter, (messages_0) => {
 		chatHelpers.setMessages(messages_0);
+	}, toolArtifactsRef.current, markToolArtifactsChanged, toolInteractionsRef.current, markToolInteractionsChanged, toolApprovalResponsesRef.current, () => {
+		hostApprovalIdsRef.current = new Set(toolApprovalResponsesRef.current.keys());
+		setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
 	});
 	const { id: chatId_0, messages: chatMessages, status: chatStatus, error } = chatHelpers;
 	const extras = useMemo(() => aiSDKExtras.provide({
@@ -223,36 +272,82 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 	const completePendingToolCalls = async () => {
 		if (!cancelPendingToolCallsOnSend) return;
 		chatHelpers.setMessages((messages_1) => {
-			const lastMessage_0 = messages_1.at(-1);
-			if (lastMessage_0?.role !== "assistant") return messages_1;
 			let hasChanges = false;
-			const parts = lastMessage_0.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_1.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",
+						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",
-					errorText: "User cancelled tool call by sending a new message."
+					...message,
+					parts
 				};
 			});
 			if (!hasChanges) return messages_1;
-			return [...messages_1.slice(0, -1), {
-				...lastMessage_0,
-				parts
-			}];
+			return next;
 		});
 	};
+	const respondViaAISDK = ({ approvalId, approved, reason }) => Promise.resolve(chatHelpers.addToolApprovalResponse({
+		id: approvalId,
+		approved,
+		...reason != null && { reason },
+		options: { metadata: lastRunConfigRef.current }
+	}));
+	const respondViaHost = async (onRespond, response) => {
+		const { approvalId: approvalId_0 } = response;
+		const requested = chatHelpers.messages.flatMap((message_0) => message_0.parts.flatMap((part_0) => isToolUIPart(part_0) ? [{
+			messageId: message_0.id,
+			part: part_0
+		}] : [])).find(({ part: part_1 }) => part_1.state === "approval-requested" && part_1.approval.id === approvalId_0);
+		if (!requested || hostApprovalIdsRef.current.has(approvalId_0)) throw new Error(`Tool approval ${approvalId_0} is not waiting for a response.`);
+		const applyResponse = (applied) => {
+			if (applied) hostApprovalIdsRef.current.add(approvalId_0);
+			else hostApprovalIdsRef.current.delete(approvalId_0);
+			if (applied) toolApprovalResponsesRef.current.set(approvalId_0, response);
+			else toolApprovalResponsesRef.current.delete(approvalId_0);
+			setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
+		};
+		applyResponse(true);
+		try {
+			await onRespond(response, {
+				toolCallId: requested.part.toolCallId,
+				toolName: getToolName(requested.part),
+				respondViaAISDK: async () => {
+					try {
+						await respondViaAISDK(response);
+					} finally {
+						applyResponse(false);
+					}
+				}
+			});
+		} catch (error_0) {
+			if (hostApprovalIdsRef.current.has(approvalId_0)) applyResponse(false);
+			throw error_0;
+		}
+		if (hostApprovalIdsRef.current.has(approvalId_0)) await persistToolApprovalResponses(requested.messageId);
+	};
 	const hasSeededRepositoryRef = useRef(false);
 	const shouldFeedRepository = exportedMessageRepository != null && !hasSeededRepositoryRef.current && messages.length === 0;
 	const runtime = useExternalStoreRuntime({
+		unstable_persistsHistory: true,
 		isRunning: providerIsRunning,
 		...shouldFeedRepository ? { messageRepository: exportedMessageRepository } : { messages },
 		unstable_enableToolInvocations: true,
 		setToolStatuses,
 		setMessages: (messages_2) => chatHelpers.setMessages(messages_2.map(getVercelAIMessages).filter(Boolean).flat()),
 		onImport: (messages_3) => chatHelpers.setMessages(messages_3.map(getVercelAIMessages).filter(Boolean).flat()),
+		onVoiceTranscript: (message_1) => chatHelpers.setMessages((current) => [...current, toVoiceTranscriptUIMessage(message_1)]),
 		onExportExternalState: () => {
 			const exported = runtimeRef.current.thread.export();
 			const expandedMessages = [];
@@ -274,12 +369,12 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 			return result;
 		},
 		onLoadExternalState: (repo) => {
-			const exportedRepo = toExportedMessageRepository(AISDKMessageConverter.toThreadMessages, repo);
+			const exportedRepo = toExportedMessageRepository(toThreadMessages, repo);
 			runtimeRef.current.thread.import(exportedRepo);
 		},
 		onCancel: async () => {
-			const message = chatHelpers.messages.at(-1);
-			const cancelledId = isRunning && message?.role === "assistant" ? message.id : void 0;
+			const message_2 = chatHelpers.messages.at(-1);
+			const cancelledId = isRunning && message_2?.role === "assistant" ? message_2.id : void 0;
 			if (cancelledId) {
 				const liveIds = new Set(chatHelpers.messages.map((m) => m.id));
 				setCancelledMessages((prev_0) => {
@@ -292,40 +387,55 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 			}
 			try {
 				await chatHelpers.stop();
-			} catch (error_0) {
-				if (!(error_0 instanceof Error && error_0.name === "AbortError")) {
+			} catch (error_1) {
+				if (!(error_1 instanceof Error && error_1.name === "AbortError")) {
 					if (cancelledId) retractCancellation(chatHelpers.id, cancelledId);
-					throw error_0;
+					throw error_1;
 				}
 			}
 		},
-		onNew: async (message_0) => {
-			const createMessage = (customToCreateMessage ?? toCreateMessage)(message_0);
-			if (!(message_0.startRun ?? message_0.role === "user")) {
-				chatHelpers.setMessages((current) => [...current, toUIMessage(createMessage, message_0.role)]);
+		onNew: async (message_3) => {
+			const createMessage = (customToCreateMessage ?? toCreateMessage)(message_3);
+			if (!(message_3.startRun ?? message_3.role === "user")) {
+				chatHelpers.setMessages((current_0) => [...current_0, toUIMessage(createMessage, message_3.role)]);
 				return;
 			}
-			lastRunConfigRef.current = message_0.runConfig;
+			lastRunConfigRef.current = message_3.runConfig;
 			await completePendingToolCalls();
-			await chatHelpers.sendMessage(createMessage, { metadata: message_0.runConfig });
+			await chatHelpers.sendMessage(createMessage, { metadata: message_3.runConfig });
 		},
-		onEdit: async (message_1) => {
-			const createMessage_0 = (customToCreateMessage ?? toCreateMessage)(message_1);
-			if (!(message_1.startRun ?? message_1.role === "user")) {
-				chatHelpers.setMessages((current_0) => [...sliceMessagesUntil(current_0, message_1.parentId), toUIMessage(createMessage_0, message_1.role)]);
+		onEdit: async (message_4) => {
+			const createMessage_0 = (customToCreateMessage ?? toCreateMessage)(message_4);
+			if (!(message_4.startRun ?? message_4.role === "user")) {
+				chatHelpers.setMessages((current_1) => [...sliceMessagesUntil(current_1, message_4.parentId), toUIMessage(createMessage_0, message_4.role)]);
 				return;
 			}
-			lastRunConfigRef.current = message_1.runConfig;
-			chatHelpers.setMessages((current_1) => sliceMessagesUntil(current_1, message_1.parentId));
-			await chatHelpers.sendMessage(createMessage_0, { metadata: message_1.runConfig });
+			lastRunConfigRef.current = message_4.runConfig;
+			chatHelpers.setMessages((current_2) => sliceMessagesUntil(current_2, message_4.parentId));
+			await chatHelpers.sendMessage(createMessage_0, { metadata: message_4.runConfig });
 		},
 		onDelete: async (messageId_0) => {
 			const threadMessages = runtimeRef.current.thread.getState().messages;
-			const messageIndex = threadMessages.findIndex((message_2) => message_2.id === messageId_0);
+			const messageIndex = threadMessages.findIndex((message_5) => message_5.id === messageId_0);
 			if (messageIndex === -1) return;
 			await deleteHistoryMessage(messageId_0);
-			const deleteIds = new Set(getExternalStoreMessages(threadMessages[messageIndex]).map((message_3) => message_3.id));
-			chatHelpers.setMessages((current_2) => current_2.filter((message_4) => !deleteIds.has(message_4.id)));
+			let removedToolArtifact = false;
+			let removedToolInteractions = false;
+			let removedToolApprovalResponse = false;
+			let removedHostApprovalId = false;
+			for (const part_2 of threadMessages[messageIndex].content) if (part_2.type === "tool-call") {
+				removedToolArtifact = toolArtifactsRef.current.delete(part_2.toolCallId) || removedToolArtifact;
+				removedToolInteractions = toolInteractionsRef.current.delete(part_2.toolCallId) || removedToolInteractions;
+				if (part_2.approval) {
+					removedToolApprovalResponse = toolApprovalResponsesRef.current.delete(part_2.approval.id) || removedToolApprovalResponse;
+					removedHostApprovalId = hostApprovalIdsRef.current.delete(part_2.approval.id) || removedHostApprovalId;
+				}
+			}
+			if (removedToolArtifact) markToolArtifactsChanged();
+			if (removedToolInteractions) markToolInteractionsChanged();
+			if (removedToolApprovalResponse || removedHostApprovalId) setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
+			const deleteIds = new Set(getExternalStoreMessages(threadMessages[messageIndex]).map((message_6) => message_6.id));
+			chatHelpers.setMessages((current_3) => current_3.filter((message_7) => !deleteIds.has(message_7.id)));
 		},
 		onReload: async (parentId_0, config) => {
 			lastRunConfigRef.current = config.runConfig;
@@ -333,7 +443,11 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 			chatHelpers.setMessages(newMessages);
 			await chatHelpers.regenerate({ metadata: config.runConfig });
 		},
-		onAddToolResult: ({ toolCallId, toolName, result: result_0, isError, modelContent }) => {
+		onAddToolResult: ({ toolCallId, toolName, result: result_0, isError, artifact, modelContent }) => {
+			if (artifact !== void 0) {
+				toolArtifactsRef.current.set(toolCallId, artifact);
+				markToolArtifactsChanged();
+			}
 			const options = { metadata: lastRunConfigRef.current };
 			if (isError) return Promise.resolve(chatHelpers.addToolOutput({
 				state: "output-error",
@@ -352,12 +466,12 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 				}));
 			}
 		},
-		onRespondToToolApproval: ({ approvalId, approved, reason }) => Promise.resolve(chatHelpers.addToolApprovalResponse({
-			id: approvalId,
-			approved,
-			...reason != null && { reason },
-			options: { metadata: lastRunConfigRef.current }
-		})),
+		onRespondToToolApproval: customOnRespondToToolApproval ? (response_0) => respondViaHost(customOnRespondToToolApproval, response_0) : respondViaAISDK,
+		unstable_onRecordToolInteraction: ({ messageId: messageId_1, toolCallId: toolCallId_0, interaction }) => {
+			toolInteractionsRef.current.set(toolCallId_0, appendToolInteraction(toolInteractionsRef.current.get(toolCallId_0), interaction));
+			markToolInteractionsChanged();
+			return persistToolInteractions(messageId_1);
+		},
 		...pickExternalStoreSharedOptions(adapter),
 		...adapter.unstable_messageRepositoryInstance && { unstable_messageRepositoryInstance: adapter.unstable_messageRepositoryInstance },
 		...suggestionAdapter ? { suggestions: generatedSuggestions } : {},