@assistant-ui/ai-sdk 0.0.7 → 0.0.9

package/dist/runtime/useAISDKRuntime.js

@@ -1,20 +1,21 @@
 "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, getToolName, isToolUIPart } from "ai";
-import { getExternalStoreMessages, pickExternalStoreSharedOptions } from "@assistant-ui/core";
-import { MessageRepository, consumeSuggestionResult } from "@assistant-ui/core/internal";
+import { useReplaySafeEffect } from "@assistant-ui/store/internal";
 //#region src/runtime/useAISDKRuntime.ts
 const toUIMessage = (createMessage, fallbackRole) => ({
 	...createMessage,
@@ -29,7 +30,7 @@ const toVoiceTranscriptUIMessage = (message) => ({
 		text: part.text
 	})),
 	metadata: {
-		modality: "voice",
+		...message.metadata.modality && { modality: message.metadata.modality },
 		...Object.keys(message.metadata.custom).length > 0 && { custom: message.metadata.custom }
 	}
 });
@@ -137,11 +138,97 @@ const useGeneratedSuggestions = (suggestionAdapter, messages, isRunning) => {
 		t6 = $[11];
 		t7 = $[12];
 	}
-	useEffect(t6, t7);
+	useReplaySafeEffect(t6, t7);
 	return suggestions;
 };
 const NO_CANCELLED_MESSAGE_IDS = /* @__PURE__ */ new Set();
+const NO_SUPERSEDED_APPROVAL_PROJECTION = Object.freeze({
+	approvalIds: Object.freeze(/* @__PURE__ */ new Set()),
+	statusMessageIds: Object.freeze(/* @__PURE__ */ new Set())
+});
 const NO_TOOL_APPROVAL_RESPONSES = /* @__PURE__ */ new Map();
+const hostToolApprovalsByChat = /* @__PURE__ */ new WeakMap();
+const toApprovalResponses = (owned) => owned && owned.size > 0 ? new Map([...owned].map(([id, entry]) => [id, entry.response])) : NO_TOOL_APPROVAL_RESPONSES;
+/**
+* The answers live on the owner, but each mounted runtime renders them from
+* its own state, so a write has to be announced: the runtime that performed it
+* may already be unmounted (a rollback resolving after a remount), and another
+* runtime may be mounted over the same owner.
+*/
+const hostApprovalListenersByChat = /* @__PURE__ */ new WeakMap();
+const subscribeToHostApprovals = (owner, listener) => {
+	const listeners = hostApprovalListenersByChat.get(owner) ?? /* @__PURE__ */ new Set();
+	hostApprovalListenersByChat.set(owner, listeners);
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+};
+const notifyHostApprovals = (owner) => {
+	for (const listener of [...hostApprovalListenersByChat.get(owner) ?? []]) listener();
+};
+const getSupersededApprovalProjection = (messages, hostApprovalIds, joinStrategy, isRunning) => {
+	const approvalIds = /* @__PURE__ */ new Set();
+	const statusMessageIds = /* @__PURE__ */ new Set();
+	const lastIndex = messages.length - 1;
+	let lastAssistant;
+	let hasSupersededApproval = false;
+	let previousWasVoice = false;
+	const flush = () => {
+		const hasOpenToolPart = lastAssistant === messages[lastIndex] && lastAssistant?.parts?.some((part) => {
+			if (!isToolUIPart(part) || part.state === "output-available" || part.state === "output-error" || part.state === "output-denied") return false;
+			const approval = part.approval;
+			const resolution = approval?.resolution ?? (approval?.descriptor)?.resolution;
+			return resolution !== "cancelled" && resolution !== "expired";
+		});
+		if (lastAssistant && hasSupersededApproval && !hasOpenToolPart && !(isRunning && lastAssistant === messages[lastIndex])) statusMessageIds.add(lastAssistant.id);
+		lastAssistant = void 0;
+		hasSupersededApproval = false;
+		previousWasVoice = false;
+	};
+	for (let index = 0; index < messages.length; index++) {
+		const message = messages[index];
+		if (message.role !== "assistant") flush();
+		else {
+			const isVoice = message.metadata?.modality === "voice";
+			if (isVoice || previousWasVoice || joinStrategy === "none") flush();
+			lastAssistant = message;
+			previousWasVoice = isVoice;
+		}
+		for (const part of message.parts ?? []) {
+			if (!isToolUIPart(part) || part.state !== "approval-requested") continue;
+			const approval = part.approval;
+			if (!approval) continue;
+			const approvalId = approval.id;
+			if (hostApprovalIds.has(approvalId)) continue;
+			const resolution = approval.resolution ?? approval.descriptor?.resolution;
+			if (resolution === "cancelled" || resolution === "expired") continue;
+			if (index !== lastIndex) {
+				approvalIds.add(approvalId);
+				if (message.role === "assistant") hasSupersededApproval = true;
+			}
+		}
+	}
+	flush();
+	if (approvalIds.size === 0 && statusMessageIds.size === 0) return NO_SUPERSEDED_APPROVAL_PROJECTION;
+	return {
+		approvalIds,
+		statusMessageIds
+	};
+};
+const findRawToolMessageIndex = (messages, messageId, toolCallId, joinStrategy) => {
+	const containsToolCall = (message) => message.parts?.some((part) => isToolUIPart(part) && part.toolCallId === toolCallId) === true;
+	const messageIndex = messages.findIndex((message) => message.id === messageId);
+	if (messageIndex === -1) return -1;
+	if (containsToolCall(messages[messageIndex])) return messageIndex;
+	if (joinStrategy === "none" || messages[messageIndex]?.role !== "assistant") return -1;
+	let start = messageIndex;
+	while (start > 0 && messages[start - 1]?.role === "assistant") start--;
+	let end = messageIndex;
+	while (end + 1 < messages.length && messages[end + 1]?.role === "assistant") end++;
+	for (let index = start; index <= end; index++) if (containsToolCall(messages[index])) return index;
+	return -1;
+};
 const toChatError = (error) => {
 	const code = error.code;
 	return {
@@ -155,12 +242,55 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 	const contextAdapters = useRuntimeAdapters();
 	const [toolStatuses, setToolStatuses] = useState({});
 	const [cancelledMessages, setCancelledMessages] = useState(null);
-	const [toolApprovalResponses, setToolApprovalResponses] = useState(NO_TOOL_APPROVAL_RESPONSES);
-	const hostApprovalIdsRef = useRef(/* @__PURE__ */ new Set());
+	const approvalOwner = adapter.unstable_hostApprovalOwner;
+	const ownedApprovals = approvalOwner ? hostToolApprovalsByChat.get(approvalOwner) ?? (() => {
+		const created = /* @__PURE__ */ new Map();
+		hostToolApprovalsByChat.set(approvalOwner, created);
+		return created;
+	})() : void 0;
+	const [toolApprovalResponses, setToolApprovalResponses] = useState(() => toApprovalResponses(ownedApprovals));
+	const [toolArtifactEpoch, setToolArtifactEpoch] = useState(0);
+	const [toolInteractionEpoch, setToolInteractionEpoch] = useState(0);
+	const toolApprovalResponsesRef = useRef(new Map(toApprovalResponses(ownedApprovals)));
+	const ownedApprovalIdsRef = useRef(new Set(ownedApprovals?.keys()));
+	const hostApprovalIdsRef = useRef(new Set(ownedApprovals?.keys()));
+	useEffect(() => {
+		if (!approvalOwner || !ownedApprovals) return void 0;
+		const sync = () => {
+			for (const id of ownedApprovalIdsRef.current) toolApprovalResponsesRef.current.delete(id);
+			for (const [id_0, entry] of ownedApprovals) toolApprovalResponsesRef.current.set(id_0, entry.response);
+			ownedApprovalIdsRef.current = new Set(ownedApprovals.keys());
+			hostApprovalIdsRef.current = new Set(toolApprovalResponsesRef.current.keys());
+			setToolApprovalResponses((prev) => {
+				const next = new Map(toolApprovalResponsesRef.current);
+				return prev.size === next.size && [...next].every(([id_1, response]) => prev.get(id_1) === response) ? prev : next;
+			});
+		};
+		const unsubscribe = subscribeToHostApprovals(approvalOwner, sync);
+		sync();
+		return unsubscribe;
+	}, [approvalOwner, ownedApprovals]);
+	const lastApprovalOwnerRef = useRef(approvalOwner);
+	if (lastApprovalOwnerRef.current !== approvalOwner) {
+		lastApprovalOwnerRef.current = approvalOwner;
+		hostApprovalIdsRef.current = new Set(ownedApprovals?.keys());
+		toolApprovalResponsesRef.current = new Map(toApprovalResponses(ownedApprovals));
+		ownedApprovalIdsRef.current = new Set(ownedApprovals?.keys());
+		setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
+	}
 	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;
@@ -170,14 +300,32 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 	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 supersededApprovalProjectionRef = useRef(NO_SUPERSEDED_APPROVAL_PROJECTION);
+	const supersededApprovalProjection = useMemo(() => {
+		const projection = getSupersededApprovalProjection(chatHelpers.messages, hostApprovalIdsRef.current, joinStrategy, isRunning);
+		const previous = supersededApprovalProjectionRef.current;
+		if (projection.approvalIds.size === previous.approvalIds.size && projection.statusMessageIds.size === previous.statusMessageIds.size && [...projection.approvalIds].every((id_3) => previous.approvalIds.has(id_3)) && [...projection.statusMessageIds].every((id_2) => previous.statusMessageIds.has(id_2))) return previous;
+		supersededApprovalProjectionRef.current = projection;
+		return projection;
+	}, [
+		chatHelpers.messages,
+		joinStrategy,
+		isRunning,
+		toolApprovalResponses
+	]);
 	const toThreadMessages = useCallback((sourceMessages) => {
-		const metadata = { supportsRichToolApprovalResponses };
+		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;
-			const ids = new Set(prev.ids);
+		setCancelledMessages((prev_0) => {
+			if (prev_0?.chatId !== chatId || !prev_0.ids.has(messageId)) return prev_0;
+			const ids = new Set(prev_0.ids);
 			ids.delete(messageId);
 			return {
 				chatId,
@@ -205,9 +353,14 @@ 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,
+			cancelledToolApprovalIds: supersededApprovalProjection.approvalIds,
+			cancelledStatusMessageIds: supersededApprovalProjection.statusMessageIds,
 			...optimisticMessageId && { optimisticMessageId },
 			...chatHelpers.error && { error: toChatError(chatHelpers.error) },
 			...cancelledMessageIds.size > 0 && { cancelledMessageIds },
@@ -219,7 +372,10 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 			chatHelpers.error,
 			cancelledMessageIds,
 			toolApprovalResponses,
-			supportsRichToolApprovalResponses
+			supportsRichToolApprovalResponses,
+			supersededApprovalProjection,
+			toolArtifactEpoch,
+			toolInteractionEpoch
 		])
 	});
 	const exportedMessageRepository = useMemo(() => {
@@ -231,8 +387,12 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 	const [runtimeRef] = useState(() => ({ get current() {
 		return runtime;
 	} }));
-	const { isLoading, deleteMessage: deleteHistoryMessage } = useExternalHistory(runtimeRef, adapters?.history ?? contextAdapters?.history, 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, () => {
+		for (const [id_4, entry_0] of ownedApprovals ?? []) toolApprovalResponsesRef.current.set(id_4, entry_0.response);
+		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({
@@ -247,25 +407,30 @@ 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_0 = 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_0;
 		});
 	};
 	const respondViaAISDK = ({ approvalId, approved, reason }) => Promise.resolve(chatHelpers.addToolApprovalResponse({
@@ -274,48 +439,63 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 		...reason != null && { reason },
 		options: { metadata: lastRunConfigRef.current }
 	}));
-	const respondViaHost = async (onRespond, response) => {
-		const { approvalId: approvalId_0 } = response;
-		const requested = chatHelpers.messages.flatMap((message) => message.parts).filter(isToolUIPart).find((part_0) => part_0.state === "approval-requested" && part_0.approval.id === approvalId_0);
+	const respondViaHost = async (onRespond, response_0) => {
+		const { approvalId: approvalId_0 } = response_0;
+		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 startedWith = ownedApprovals;
+		const startedOwner = approvalOwner;
+		const startedResponses = toolApprovalResponsesRef.current;
+		let isApplied = false;
 		const applyResponse = (applied) => {
+			isApplied = applied;
+			if (applied) startedWith?.set(approvalId_0, { response: response_0 });
+			else startedWith?.delete(approvalId_0);
+			if (startedOwner) {
+				notifyHostApprovals(startedOwner);
+				return;
+			}
+			if (lastApprovalOwnerRef.current !== startedOwner) return;
 			if (applied) hostApprovalIdsRef.current.add(approvalId_0);
 			else hostApprovalIdsRef.current.delete(approvalId_0);
-			setToolApprovalResponses((prev_0) => {
-				const responses = new Map(prev_0);
-				if (applied) responses.set(approvalId_0, response);
-				else responses.delete(approvalId_0);
-				return responses;
-			});
+			if (applied) toolApprovalResponsesRef.current.set(approvalId_0, response_0);
+			else toolApprovalResponsesRef.current.delete(approvalId_0);
+			setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
 		};
 		applyResponse(true);
 		try {
-			await onRespond(response, {
-				toolCallId: requested.toolCallId,
-				toolName: getToolName(requested),
+			await onRespond(response_0, {
+				toolCallId: requested.part.toolCallId,
+				toolName: getToolName(requested.part),
 				respondViaAISDK: async () => {
 					try {
-						await respondViaAISDK(response);
+						await respondViaAISDK(response_0);
 					} finally {
 						applyResponse(false);
 					}
 				}
 			});
 		} catch (error_0) {
-			if (hostApprovalIdsRef.current.has(approvalId_0)) applyResponse(false);
+			if (isApplied) applyResponse(false);
 			throw error_0;
 		}
+		const remainsApplied = startedWith?.has(approvalId_0) ?? startedResponses.has(approvalId_0);
+		if (isApplied && remainsApplied) 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_0) => chatHelpers.setMessages((current) => [...current, toVoiceTranscriptUIMessage(message_0)]),
+		onVoiceTranscript: (message_1) => chatHelpers.setMessages((current) => [...current, toVoiceTranscriptUIMessage(message_1)]),
 		onExportExternalState: () => {
 			const exported = runtimeRef.current.thread.export();
 			const expandedMessages = [];
@@ -341,12 +521,12 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 			runtimeRef.current.thread.import(exportedRepo);
 		},
 		onCancel: async () => {
-			const message_1 = chatHelpers.messages.at(-1);
-			const cancelledId = isRunning && message_1?.role === "assistant" ? message_1.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_1) => {
-					const kept = prev_1?.chatId === chatHelpers.id ? [...prev_1.ids].filter((id) => liveIds.has(id)) : [];
+					const kept = prev_1?.chatId === chatHelpers.id ? [...prev_1.ids].filter((id_5) => liveIds.has(id_5)) : [];
 					return {
 						chatId: chatHelpers.id,
 						ids: /* @__PURE__ */ new Set([...kept, cancelledId])
@@ -362,33 +542,52 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 				}
 			}
 		},
-		onNew: async (message_2) => {
-			const createMessage = (customToCreateMessage ?? toCreateMessage)(message_2);
-			if (!(message_2.startRun ?? message_2.role === "user")) {
-				chatHelpers.setMessages((current_0) => [...current_0, toUIMessage(createMessage, message_2.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_2.runConfig;
+			lastRunConfigRef.current = message_3.runConfig;
 			await completePendingToolCalls();
-			await chatHelpers.sendMessage(createMessage, { metadata: message_2.runConfig });
+			await chatHelpers.sendMessage(createMessage, { metadata: message_3.runConfig });
 		},
-		onEdit: async (message_3) => {
-			const createMessage_0 = (customToCreateMessage ?? toCreateMessage)(message_3);
-			if (!(message_3.startRun ?? message_3.role === "user")) {
-				chatHelpers.setMessages((current_1) => [...sliceMessagesUntil(current_1, message_3.parentId), toUIMessage(createMessage_0, message_3.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_3.runConfig;
-			chatHelpers.setMessages((current_2) => sliceMessagesUntil(current_2, message_3.parentId));
-			await chatHelpers.sendMessage(createMessage_0, { metadata: message_3.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_4) => message_4.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_5) => message_5.id));
-			chatHelpers.setMessages((current_3) => current_3.filter((message_6) => !deleteIds.has(message_6.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) {
+					ownedApprovals?.delete(part_2.approval.id);
+					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) {
+				if (approvalOwner) notifyHostApprovals(approvalOwner);
+				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;
@@ -396,26 +595,61 @@ const useAISDKRuntime = (chatHelpers, adapter = {}) => {
 			chatHelpers.setMessages(newMessages);
 			await chatHelpers.regenerate({ metadata: config.runConfig });
 		},
-		onAddToolResult: ({ toolCallId, toolName, result: result_0, isError, modelContent }) => {
+		onAddToolResult: ({ messageId: messageId_1, toolCallId, toolName, result: result_0, isError, artifact, modelContent }) => {
+			if (artifact !== void 0) {
+				toolArtifactsRef.current.set(toolCallId, artifact);
+				markToolArtifactsChanged();
+			}
+			const targetIndex = findRawToolMessageIndex(chatHelpers.messages, messageId_1, toolCallId, joinStrategy);
+			const errorText = typeof result_0 === "string" ? result_0 : JSON.stringify(result_0);
+			const output = !isError && modelContent !== void 0 ? wrapModelContentEnvelope(result_0, modelContent) : result_0;
+			if (targetIndex >= 0 && targetIndex !== chatHelpers.messages.length - 1) {
+				const target = chatHelpers.messages[targetIndex];
+				const targetPart = target.parts.find((part_3) => isToolUIPart(part_3) && part_3.toolCallId === toolCallId);
+				if (targetPart?.state === "output-error" || targetPart?.state === "output-denied" || targetPart?.state === "output-available" && !targetPart.preliminary) return Promise.resolve();
+				const targetMessageId = target.id;
+				chatHelpers.setMessages((current_4) => current_4.map((message_8) => {
+					if (message_8.id !== targetMessageId) return message_8;
+					return {
+						...message_8,
+						parts: message_8.parts.map((part_4) => {
+							if (!isToolUIPart(part_4) || part_4.toolCallId !== toolCallId) return part_4;
+							const { preliminary: _preliminary, ...finalPart } = part_4;
+							return {
+								...finalPart,
+								state: isError ? "output-error" : "output-available",
+								output: isError ? void 0 : output,
+								errorText: isError ? errorText : void 0
+							};
+						})
+					};
+				}));
+				return Promise.resolve();
+			}
 			const options = { metadata: lastRunConfigRef.current };
 			if (isError) return Promise.resolve(chatHelpers.addToolOutput({
 				state: "output-error",
 				tool: toolName ?? toolCallId,
 				toolCallId,
-				errorText: typeof result_0 === "string" ? result_0 : JSON.stringify(result_0),
+				errorText,
 				options
 			}));
-			else {
-				const output = modelContent !== void 0 ? wrapModelContentEnvelope(result_0, modelContent) : result_0;
-				return Promise.resolve(chatHelpers.addToolOutput({
-					tool: toolName,
-					toolCallId,
-					output,
-					options
-				}));
-			}
+			return Promise.resolve(chatHelpers.addToolOutput({
+				tool: toolName,
+				toolCallId,
+				output,
+				options
+			}));
+		},
+		onRespondToToolApproval: (response_1) => {
+			if (supersededApprovalProjection.approvalIds.has(response_1.approvalId)) return Promise.reject(/* @__PURE__ */ new Error(`Tool approval ${response_1.approvalId} is not waiting for a response.`));
+			return customOnRespondToToolApproval ? respondViaHost(customOnRespondToToolApproval, response_1) : respondViaAISDK(response_1);
+		},
+		unstable_onRecordToolInteraction: ({ messageId: messageId_2, toolCallId: toolCallId_0, interaction }) => {
+			toolInteractionsRef.current.set(toolCallId_0, appendToolInteraction(toolInteractionsRef.current.get(toolCallId_0), interaction));
+			markToolInteractionsChanged();
+			return persistToolInteractions(messageId_2);
 		},
-		onRespondToToolApproval: customOnRespondToToolApproval ? (response_0) => respondViaHost(customOnRespondToToolApproval, response_0) : respondViaAISDK,
 		...pickExternalStoreSharedOptions(adapter),
 		...adapter.unstable_messageRepositoryInstance && { unstable_messageRepositoryInstance: adapter.unstable_messageRepositoryInstance },
 		...suggestionAdapter ? { suggestions: generatedSuggestions } : {},