@ulearning/ai-sdk-adapter 0.0.0-stage → 1.0.0-next.0

package/dist/runtime/useAISDKRuntime.js

@@ -0,0 +1,754 @@
+"use client";
+import { aiSDKV6FormatAdapter } from "../adapters/aiSDKFormatAdapter.js";
+import { vercelAttachmentAdapter } from "../adapters/vercelAttachmentAdapter.js";
+import { aiSDKExtras } from "../aiSDKExtras.js";
+import { AISDKMessageConverter, convertAISDKMessage, createAISDKMetadataKey } from "../converters/convertMessage.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 { aiSdkStreamingTimingAccessors } from "./useStreamingTiming.js";
+import { useMessageQueue } from "./useMessageQueue.js";
+import { MessageRepository, appendToolInteraction, consumeSuggestionResult } from "@ulearning/ai-core/internal";
+import { generateId, getToolName, isToolUIPart } from "ai";
+import { useExternalStoreRuntime } from "@ulearning/ai-core/vue";
+import { getExternalStoreMessages, pickExternalStoreSharedOptions } from "@ulearning/ai-core";
+import { wrapModelContentEnvelope } from "@ulearning/ai-stream/internal";
+import { useCallback, useEffect, useInsertionEffect, useMemo, useRef, useState, useSyncExternalStore } from "@ulearning/ai-tap";
+import { useReplaySafeEffect } from "@ulearning/ai-store/internal";
+import { useExternalMessageConverterValue, useRuntimeAdaptersValue, useRuntimeResource, useStreamingTimingValue } from "@ulearning/ai-core/vue/internal";
+import { isResourceExecution } from "@ulearning/ai-tap/internal";
+import { toValue } from "vue";
+// 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 [suggestions, setSuggestions] = useState(EMPTY_SUGGESTIONS);
+	const controllerRef = useRef(null);
+	const wasRunningRef = useRef(false);
+	const messagesRef = useRef(messages);
+	useInsertionEffect(() => {
+		messagesRef.current = messages;
+	}, [messages]);
+	const adapterKey = suggestionAdapter?.key;
+	const adapterRef = useRef(suggestionAdapter);
+	const lastAdapterKeyRef = useRef(adapterKey);
+	const adapterReplacedRef = useRef(false);
+	useInsertionEffect(() => {
+		const previousAdapter = adapterRef.current;
+		adapterRef.current = suggestionAdapter;
+		const adapterReplaced = previousAdapter !== void 0 && suggestionAdapter !== void 0 && lastAdapterKeyRef.current !== adapterKey;
+		adapterReplacedRef.current ||= adapterReplaced;
+		if (suggestionAdapter === void 0 || adapterReplaced) controllerRef.current?.abort();
+		lastAdapterKeyRef.current = adapterKey;
+	}, [adapterKey, suggestionAdapter]);
+	const hasAdapter = suggestionAdapter !== void 0;
+	const adapterPresentRef = useRef(hasAdapter);
+	useEffect(() => {
+		const clearSuggestions = () => {
+			controllerRef.current?.abort();
+			controllerRef.current = null;
+			setSuggestions((prev) => prev.length === 0 ? prev : EMPTY_SUGGESTIONS);
+		};
+		const adapter = adapterRef.current;
+		const adapterRestored = hasAdapter && !adapterPresentRef.current;
+		adapterPresentRef.current = hasAdapter;
+		const adapterReplaced = adapterReplacedRef.current;
+		adapterReplacedRef.current = false;
+		if (!adapter) {
+			clearSuggestions();
+			wasRunningRef.current = isRunning;
+			return;
+		}
+		if (adapterReplaced) clearSuggestions();
+		if (isRunning) {
+			if (!wasRunningRef.current) clearSuggestions();
+			wasRunningRef.current = true;
+			return;
+		}
+		if (!wasRunningRef.current && !adapterReplaced && !adapterRestored) return;
+		wasRunningRef.current = false;
+		const currentMessages = messagesRef.current;
+		const last = currentMessages.at(-1);
+		if (last?.role !== "assistant") return;
+		if (last.status?.type === "requires-action") return;
+		const controller = new AbortController();
+		controllerRef.current = controller;
+		const { signal } = controller;
+		(async () => {
+			try {
+				const promiseOrGenerator = adapter.generate({
+					messages: currentMessages,
+					signal
+				});
+				await consumeSuggestionResult(promiseOrGenerator, {
+					signal,
+					onUpdate: (nextSuggestions) => {
+						if (controllerRef.current !== controller) return;
+						setSuggestions(nextSuggestions);
+					}
+				});
+			} catch {}
+		})();
+	}, [
+		adapterKey,
+		hasAdapter,
+		isRunning
+	]);
+	useReplaySafeEffect(() => {
+		return () => {
+			controllerRef.current?.abort();
+		};
+	}, []);
+	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 chatRuntimeStates = /* @__PURE__ */ new WeakMap();
+const getChatRuntimeState = (owner) => {
+	if (owner === void 0) return void 0;
+	let state = chatRuntimeStates.get(owner);
+	if (state === void 0) {
+		state = {
+			approvals: /* @__PURE__ */ new Map(),
+			cancelledMessageIds: NO_CANCELLED_MESSAGE_IDS,
+			cancelledToolCallIds: /* @__PURE__ */ new Set()
+		};
+		chatRuntimeStates.set(owner, state);
+	}
+	return state;
+};
+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 chatRuntimeListeners = /* @__PURE__ */ new WeakMap();
+const subscribeToChatRuntimeState = (owner, listener) => {
+	const listeners = chatRuntimeListeners.get(owner) ?? /* @__PURE__ */ new Set();
+	chatRuntimeListeners.set(owner, listeners);
+	listeners.add(listener);
+	return () => {
+		listeners.delete(listener);
+	};
+};
+const notifyChatRuntimeState = (owner) => {
+	for (const listener of [...chatRuntimeListeners.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 (typeof part?.type !== "string" || !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 (typeof part?.type !== "string" || !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) => typeof part?.type === "string" && 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, statusCode } = error;
+	return {
+		code: typeof code === "string" ? code : error.name !== "Error" ? error.name : "unknown",
+		message: error.message,
+		...typeof statusCode === "number" && { statusCode }
+	};
+};
+const useAISDKRuntimeResource = (chatHelpers, adapter = {}) => {
+	const { adapters, toCreateMessage: customToCreateMessage, cancelPendingToolCallsOnSend = true, onResume, canResume, onResumeToolCall, onRespondToToolApproval: customOnRespondToToolApproval, joinStrategy, messageRepository, unstable_onBranchChange, unstable_enableMessageQueue } = adapter;
+	const suggestionAdapter = adapters?.suggestion;
+	const contextAdapters = useRuntimeAdaptersValue();
+	const [queueError, setQueueError] = useState();
+	const runtimeError = unstable_enableMessageQueue ? queueError ?? chatHelpers.error : chatHelpers.error;
+	const [toolStatuses, setToolStatuses] = useState({});
+	const [cancelledMessages, setCancelledMessages] = useState(null);
+	const approvalOwner = adapter.unstable_hostApprovalOwner;
+	const chatRuntimeState = getChatRuntimeState(approvalOwner);
+	const ownedApprovals = chatRuntimeState?.approvals;
+	const localCancelledToolCallIdsRef = useRef(/* @__PURE__ */ new Set());
+	const cancelledToolCallIds = chatRuntimeState?.cancelledToolCallIds ?? localCancelledToolCallIdsRef.current;
+	const ownedCancelledMessageIds = useSyncExternalStore(useCallback((listener) => approvalOwner ? subscribeToChatRuntimeState(approvalOwner, listener) : () => {}, [approvalOwner]), useCallback(() => chatRuntimeState?.cancelledMessageIds ?? NO_CANCELLED_MESSAGE_IDS, [chatRuntimeState]), () => NO_CANCELLED_MESSAGE_IDS);
+	const [toolApprovalResponses, setToolApprovalResponses] = useState(() => toApprovalResponses(ownedApprovals));
+	const [toolArtifacts, setToolArtifacts] = useState(() => /* @__PURE__ */ new Map());
+	const [toolInteractions, setToolInteractions] = useState(() => /* @__PURE__ */ new Map());
+	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, entry] of ownedApprovals) toolApprovalResponsesRef.current.set(id, 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, response]) => prev.get(id) === response) ? prev : next;
+			});
+		};
+		const unsubscribe = subscribeToChatRuntimeState(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 [createdAtCaches] = useState(() => /* @__PURE__ */ new Map());
+	let createdAtCache = createdAtCaches.get(chatHelpers.id);
+	if (!createdAtCache) {
+		createdAtCache = /* @__PURE__ */ new Map();
+		createdAtCaches.set(chatHelpers.id, createdAtCache);
+	}
+	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 restoreToolArtifacts = useCallback((next) => {
+		toolArtifactsRef.current = next;
+		setToolArtifacts(next);
+	}, []);
+	const restoreToolInteractions = useCallback((next) => {
+		toolInteractionsRef.current = next;
+		setToolInteractions(next);
+	}, []);
+	const getToolArtifacts = useCallback(() => toolArtifactsRef.current, []);
+	const getToolInteractions = useCallback(() => toolInteractionsRef.current, []);
+	const hasExecutingTools = Object.values(toolStatuses).some((s) => s?.type === "executing");
+	const providerIsRunning = chatHelpers.status === "submitted" || chatHelpers.status === "streaming";
+	const isRunning = providerIsRunning || hasExecutingTools;
+	const wasProviderRunningRef = useRef(providerIsRunning);
+	const messageTiming = useStreamingTimingValue(chatHelpers.messages, isRunning, aiSdkStreamingTimingAccessors);
+	const lastMessage = chatHelpers.messages.at(-1);
+	const optimisticMessageId = isRunning && lastMessage?.role === "assistant" ? lastMessage.id : void 0;
+	const cancelledMessageIds = chatRuntimeState ? ownedCancelledMessageIds : 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) => previous.approvalIds.has(id)) && [...projection.statusMessageIds].every((id) => previous.statusMessageIds.has(id))) return previous;
+		supersededApprovalProjectionRef.current = projection;
+		return projection;
+	}, [
+		chatHelpers.messages,
+		joinStrategy,
+		isRunning,
+		toolApprovalResponses
+	]);
+	const toThreadMessages = useCallback((sourceMessages) => {
+		const metadata = {
+			createdAtCache,
+			supportsRichToolApprovalResponses,
+			toolArtifacts: toolArtifactsRef.current,
+			toolInteractions: toolInteractionsRef.current,
+			toolApprovalResponses: toolApprovalResponsesRef.current
+		};
+		return AISDKMessageConverter.toThreadMessages(sourceMessages, false, metadata);
+	}, [createdAtCache, supportsRichToolApprovalResponses]);
+	const retractCancellation = useCallback((chatId, messageId) => {
+		if (chatRuntimeState !== void 0 && approvalOwner !== void 0) {
+			if (!chatRuntimeState.cancelledMessageIds.has(messageId)) return;
+			const ids = new Set(chatRuntimeState.cancelledMessageIds);
+			ids.delete(messageId);
+			chatRuntimeState.cancelledMessageIds = ids;
+			notifyChatRuntimeState(approvalOwner);
+			return;
+		}
+		setCancelledMessages((prev) => {
+			if (prev?.chatId !== chatId || !prev.ids.has(messageId)) return prev;
+			const ids = new Set(prev.ids);
+			ids.delete(messageId);
+			return {
+				chatId,
+				ids
+			};
+		});
+	}, [approvalOwner, chatRuntimeState]);
+	const resumedMessageId = providerIsRunning && lastMessage?.role === "assistant" ? lastMessage.id : void 0;
+	useEffect(() => {
+		const wasProviderRunning = wasProviderRunningRef.current;
+		wasProviderRunningRef.current = providerIsRunning;
+		if (wasProviderRunning || !resumedMessageId) return;
+		retractCancellation(chatHelpers.id, resumedMessageId);
+	}, [
+		providerIsRunning,
+		resumedMessageId,
+		chatHelpers.id,
+		retractCancellation
+	]);
+	const [getConverterMetadataKey] = useState(createAISDKMetadataKey);
+	const messages = useExternalMessageConverterValue({
+		callback: convertAISDKMessage,
+		isRunning,
+		messages: chatHelpers.messages,
+		joinStrategy,
+		metadata: useMemo(() => ({
+			createdAtCache,
+			toolStatuses,
+			messageTiming,
+			toolArgsKeyOrderCache: toolArgsKeyOrderCacheRef.current,
+			toolArgsTextCache: toolArgsTextCacheRef.current,
+			toolLastInputCache: toolLastInputCacheRef.current,
+			mcpAppMetadataCache: mcpAppMetadataCacheRef.current,
+			toolArtifacts,
+			toolInteractions,
+			supportsRichToolApprovalResponses,
+			cancelledToolApprovalIds: supersededApprovalProjection.approvalIds,
+			cancelledStatusMessageIds: supersededApprovalProjection.statusMessageIds,
+			...optimisticMessageId && { optimisticMessageId },
+			...chatHelpers.error && { error: toChatError(chatHelpers.error) },
+			...cancelledMessageIds.size > 0 && { cancelledMessageIds },
+			...toolApprovalResponses.size > 0 && { toolApprovalResponses }
+		}), [
+			createdAtCache,
+			toolStatuses,
+			messageTiming,
+			optimisticMessageId,
+			chatHelpers.error,
+			cancelledMessageIds,
+			toolApprovalResponses,
+			supportsRichToolApprovalResponses,
+			supersededApprovalProjection,
+			toolArtifacts,
+			toolInteractions
+		]),
+		getMetadataKey: getConverterMetadataKey
+	});
+	const exportedMessageRepository = useMemo(() => {
+		if (!messageRepository) return void 0;
+		const converted = toExportedMessageRepository(toThreadMessages, messageRepository);
+		return converted.messages.length > 0 ? converted : void 0;
+	}, [messageRepository, toThreadMessages]);
+	const generatedSuggestions = useGeneratedSuggestions(suggestionAdapter, messages, isRunning);
+	const [runtimeRef] = useState(() => ({ get current() {
+		return runtime;
+	} }));
+	const { isLoading, deleteMessage: deleteHistoryMessage, markRunCancelled, persistToolInteractions, persistToolApprovalResponses } = useExternalHistory(runtimeRef, adapters?.history ?? contextAdapters?.history, toThreadMessages, aiSDKV6FormatAdapter, (messages) => {
+		chatHelpers.setMessages(messages);
+	}, getToolArtifacts, restoreToolArtifacts, getToolInteractions, restoreToolInteractions, toolApprovalResponsesRef.current, () => {
+		for (const [id, entry] of ownedApprovals ?? []) toolApprovalResponsesRef.current.set(id, entry.response);
+		hostApprovalIdsRef.current = new Set(toolApprovalResponsesRef.current.keys());
+		setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
+	});
+	const { id: chatId, messages: chatMessages, status: chatStatus } = chatHelpers;
+	const extras = useMemo(() => aiSDKExtras.provide({
+		chat: chatHelpers,
+		error: runtimeError
+	}), [
+		chatId,
+		chatMessages,
+		chatStatus,
+		runtimeError
+	]);
+	const completePendingToolCalls = async () => {
+		if (!cancelPendingToolCallsOnSend) return;
+		chatHelpers.setMessages((messages) => {
+			let hasChanges = false;
+			const next = messages.map((message) => {
+				if (message.role !== "assistant") return message;
+				let messageChanged = false;
+				const parts = message.parts?.map((part) => {
+					if (typeof part?.type !== "string" || !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;
+				return {
+					...message,
+					parts
+				};
+			});
+			if (!hasChanges) return messages;
+			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 } = response;
+		const requested = chatHelpers.messages.flatMap((message) => message.parts.flatMap((part) => typeof part?.type === "string" && isToolUIPart(part) ? [{
+			messageId: message.id,
+			part
+		}] : [])).find(({ part }) => part.state === "approval-requested" && part.approval?.id === approvalId);
+		if (!requested || hostApprovalIdsRef.current.has(approvalId)) throw new Error(`Tool approval ${approvalId} 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, { response });
+			else startedWith?.delete(approvalId);
+			if (startedOwner) {
+				notifyChatRuntimeState(startedOwner);
+				return;
+			}
+			if (lastApprovalOwnerRef.current !== startedOwner) return;
+			if (applied) hostApprovalIdsRef.current.add(approvalId);
+			else hostApprovalIdsRef.current.delete(approvalId);
+			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.part.toolCallId,
+				toolName: getToolName(requested.part),
+				respondViaAISDK: async () => {
+					try {
+						await respondViaAISDK(response);
+					} finally {
+						applyResponse(false);
+					}
+				}
+			});
+		} catch (error) {
+			if (isApplied) applyResponse(false);
+			throw error;
+		}
+		const remainsApplied = startedWith?.has(approvalId) ?? startedResponses.has(approvalId);
+		if (isApplied && remainsApplied) await persistToolApprovalResponses(requested.messageId);
+	};
+	const lastAISDKMessageId = (threadMessageId) => {
+		if (threadMessageId == null) return null;
+		const threadMessage = runtimeRef.current.thread.getState().messages.find((message) => message.id === threadMessageId);
+		return (threadMessage && getVercelAIMessages(threadMessage).at(-1)?.id) ?? threadMessageId;
+	};
+	const cancelRun = async () => {
+		markRunCancelled();
+		for (const toolCallId of Object.keys(toolStatuses)) cancelledToolCallIds.add(toolCallId);
+		const message = chatHelpers.messages.at(-1);
+		const cancelledId = isRunning && message?.role === "assistant" ? message.id : void 0;
+		if (cancelledId) {
+			const liveIds = new Set(chatHelpers.messages.map((m) => m.id));
+			if (chatRuntimeState !== void 0 && approvalOwner !== void 0) {
+				chatRuntimeState.cancelledMessageIds = /* @__PURE__ */ new Set([...[...chatRuntimeState.cancelledMessageIds].filter((id) => liveIds.has(id)), cancelledId]);
+				notifyChatRuntimeState(approvalOwner);
+			} else setCancelledMessages((prev) => {
+				const kept = prev?.chatId === chatHelpers.id ? [...prev.ids].filter((id) => liveIds.has(id)) : [];
+				return {
+					chatId: chatHelpers.id,
+					ids: /* @__PURE__ */ new Set([...kept, cancelledId])
+				};
+			});
+		}
+		try {
+			await chatHelpers.stop();
+		} catch (error) {
+			if (!(error instanceof Error && error.name === "AbortError")) {
+				if (cancelledId) retractCancellation(chatHelpers.id, cancelledId);
+				throw error;
+			}
+		}
+	};
+	const sendNew = async (message) => {
+		setQueueError(void 0);
+		const createMessage = (customToCreateMessage ?? toCreateMessage)(message);
+		if (!(message.startRun ?? message.role === "user")) {
+			chatHelpers.setMessages((current) => [...current, toUIMessage(createMessage, message.role)]);
+			return;
+		}
+		lastRunConfigRef.current = message.runConfig;
+		await completePendingToolCalls();
+		await chatHelpers.sendMessage(createMessage, { metadata: message.runConfig });
+	};
+	const messageQueue = useMessageQueue({
+		onError: (error) => {
+			if (error?.name === "AbortError") setQueueError(void 0);
+			else setQueueError(error);
+		},
+		enabled: unstable_enableMessageQueue === true,
+		isRunning,
+		isSendDisabled: adapter.isSendDisabled === true,
+		send: sendNew,
+		cancel: cancelRun
+	});
+	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) => chatHelpers.setMessages(messages.map(getVercelAIMessages).filter(Boolean).flat()),
+		onImport: (messages) => chatHelpers.setMessages(messages.map(getVercelAIMessages).filter(Boolean).flat()),
+		onVoiceTranscript: (message) => chatHelpers.setMessages((current) => [...current, toVoiceTranscriptUIMessage(message)]),
+		onExportExternalState: () => {
+			const exported = runtimeRef.current.thread.export();
+			const expandedMessages = [];
+			const lastInnerIdMap = /* @__PURE__ */ new Map();
+			for (const item of exported.messages) {
+				const innerMessages = getExternalStoreMessages(item.message);
+				let parentId = item.parentId != null ? lastInnerIdMap.get(item.parentId) ?? item.parentId : null;
+				for (const innerMessage of innerMessages) {
+					expandedMessages.push({
+						parentId,
+						message: innerMessage
+					});
+					parentId = aiSDKV6FormatAdapter.getId(innerMessage);
+				}
+				if (innerMessages.length > 0) lastInnerIdMap.set(item.message.id, aiSDKV6FormatAdapter.getId(innerMessages[innerMessages.length - 1]));
+			}
+			const result = { messages: expandedMessages };
+			if (exported.headId != null) result.headId = lastInnerIdMap.get(exported.headId) ?? exported.headId;
+			return result;
+		},
+		onLoadExternalState: (repo) => {
+			const exportedRepo = toExportedMessageRepository(toThreadMessages, repo);
+			runtimeRef.current.thread.import(exportedRepo);
+		},
+		onCancel: messageQueue.cancel,
+		onNew: sendNew,
+		...messageQueue.adapter && { queue: messageQueue.adapter },
+		onEdit: async (message) => {
+			messageQueue.clear();
+			const createMessage = (customToCreateMessage ?? toCreateMessage)(message);
+			const parentId = lastAISDKMessageId(message.parentId);
+			if (!(message.startRun ?? message.role === "user")) {
+				chatHelpers.setMessages((current) => [...sliceMessagesUntil(current, parentId), toUIMessage(createMessage, message.role)]);
+				return;
+			}
+			lastRunConfigRef.current = message.runConfig;
+			chatHelpers.setMessages((current) => sliceMessagesUntil(current, parentId));
+			await chatHelpers.sendMessage(createMessage, { metadata: message.runConfig });
+		},
+		onDelete: async (messageId) => {
+			const threadMessages = runtimeRef.current.thread.getState().messages;
+			const messageIndex = threadMessages.findIndex((message) => message.id === messageId);
+			if (messageIndex === -1) return;
+			await deleteHistoryMessage(messageId);
+			let removedToolArtifact = false;
+			let removedToolInteractions = false;
+			let removedToolApprovalResponse = false;
+			let removedHostApprovalId = false;
+			const nextToolArtifacts = new Map(toolArtifactsRef.current);
+			const nextToolInteractions = new Map(toolInteractionsRef.current);
+			for (const part of threadMessages[messageIndex].content) if (part.type === "tool-call") {
+				removedToolArtifact = nextToolArtifacts.delete(part.toolCallId) || removedToolArtifact;
+				removedToolInteractions = nextToolInteractions.delete(part.toolCallId) || removedToolInteractions;
+				if (part.approval) {
+					ownedApprovals?.delete(part.approval.id);
+					removedToolApprovalResponse = toolApprovalResponsesRef.current.delete(part.approval.id) || removedToolApprovalResponse;
+					removedHostApprovalId = hostApprovalIdsRef.current.delete(part.approval.id) || removedHostApprovalId;
+				}
+			}
+			if (removedToolArtifact) {
+				toolArtifactsRef.current = nextToolArtifacts;
+				setToolArtifacts(nextToolArtifacts);
+			}
+			if (removedToolInteractions) {
+				toolInteractionsRef.current = nextToolInteractions;
+				setToolInteractions(nextToolInteractions);
+			}
+			if (removedToolApprovalResponse || removedHostApprovalId) {
+				if (approvalOwner) notifyChatRuntimeState(approvalOwner);
+				setToolApprovalResponses(new Map(toolApprovalResponsesRef.current));
+			}
+			const deleteIds = new Set(getExternalStoreMessages(threadMessages[messageIndex]).map((message) => message.id));
+			chatHelpers.setMessages((current) => current.filter((message) => !deleteIds.has(message.id)));
+		},
+		onReload: async (parentId, config) => {
+			messageQueue.clear();
+			lastRunConfigRef.current = config.runConfig;
+			const newMessages = sliceMessagesUntil(chatHelpers.messages, lastAISDKMessageId(parentId));
+			const reloaded = chatHelpers.messages[newMessages.length];
+			if (reloaded?.role === "assistant") newMessages.push(reloaded);
+			chatHelpers.setMessages(newMessages);
+			await chatHelpers.regenerate({ metadata: config.runConfig });
+		},
+		onAddToolResult: ({ messageId, toolCallId, toolName, result, isError, artifact, modelContent }) => {
+			const wasCancelled = cancelledToolCallIds.delete(toolCallId);
+			if (artifact !== void 0) {
+				const next = new Map(toolArtifactsRef.current);
+				next.set(toolCallId, artifact);
+				toolArtifactsRef.current = next;
+				setToolArtifacts(next);
+			}
+			const targetIndex = findRawToolMessageIndex(chatHelpers.messages, messageId, toolCallId, joinStrategy);
+			const errorText = typeof result === "string" ? result : JSON.stringify(result);
+			const output = !isError && modelContent !== void 0 ? wrapModelContentEnvelope(result, modelContent) : result;
+			if (targetIndex >= 0 && (targetIndex !== chatHelpers.messages.length - 1 || wasCancelled)) {
+				const target = chatHelpers.messages[targetIndex];
+				const targetPart = target.parts.find((part) => typeof part?.type === "string" && isToolUIPart(part) && part.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) => current.map((message) => {
+					if (message.id !== targetMessageId) return message;
+					return {
+						...message,
+						parts: message.parts.map((part) => {
+							if (typeof part?.type !== "string" || !isToolUIPart(part) || part.toolCallId !== toolCallId) return part;
+							const { preliminary: _preliminary, ...finalPart } = part;
+							return {
+								...finalPart,
+								state: isError ? "output-error" : "output-available",
+								output: isError ? void 0 : output,
+								errorText: isError ? errorText : void 0
+							};
+						})
+					};
+				}));
+				return Promise.resolve();
+			}
+			if (wasCancelled) return Promise.resolve();
+			const options = { metadata: lastRunConfigRef.current };
+			if (isError) return Promise.resolve(chatHelpers.addToolOutput({
+				state: "output-error",
+				tool: toolName ?? toolCallId,
+				toolCallId,
+				errorText,
+				options
+			}));
+			return Promise.resolve(chatHelpers.addToolOutput({
+				tool: toolName,
+				toolCallId,
+				output,
+				options
+			}));
+		},
+		onRespondToToolApproval: (response) => {
+			if (supersededApprovalProjection.approvalIds.has(response.approvalId)) return Promise.reject(/* @__PURE__ */ new Error(`Tool approval ${response.approvalId} is not waiting for a response.`));
+			return customOnRespondToToolApproval ? respondViaHost(customOnRespondToToolApproval, response) : respondViaAISDK(response);
+		},
+		unstable_onRecordToolInteraction: ({ messageId, toolCallId, interaction }) => {
+			const next = new Map(toolInteractionsRef.current);
+			next.set(toolCallId, appendToolInteraction(next.get(toolCallId), interaction));
+			toolInteractionsRef.current = next;
+			setToolInteractions(next);
+			return persistToolInteractions(messageId);
+		},
+		...pickExternalStoreSharedOptions(adapter),
+		...adapter.unstable_messageRepositoryInstance && { unstable_messageRepositoryInstance: adapter.unstable_messageRepositoryInstance },
+		...suggestionAdapter ? { suggestions: generatedSuggestions } : {},
+		...onResume && { onResume },
+		...canResume !== void 0 && { canResume },
+		...onResumeToolCall && { onResumeToolCall },
+		...unstable_onBranchChange && { unstable_onBranchChange },
+		adapters: {
+			attachments: vercelAttachmentAdapter,
+			...contextAdapters,
+			...adapters
+		},
+		extras,
+		isLoading
+	});
+	const setMessagesRef = useRef(chatHelpers.setMessages);
+	useInsertionEffect(() => {
+		setMessagesRef.current = chatHelpers.setMessages;
+	}, [chatHelpers.setMessages]);
+	useEffect(() => {
+		if (hasSeededRepositoryRef.current) return;
+		if (!exportedMessageRepository) return;
+		if (chatHelpers.messages.length > 0) {
+			hasSeededRepositoryRef.current = true;
+			return;
+		}
+		const tempRepo = new MessageRepository();
+		tempRepo.import(exportedMessageRepository);
+		setMessagesRef.current(tempRepo.getMessages().flatMap(getExternalStoreMessages));
+		hasSeededRepositoryRef.current = true;
+	}, [exportedMessageRepository, chatHelpers.messages.length]);
+	return runtime;
+};
+/** Vue setup owns the resource; reactive helper/adapter getters stay live. */
+const useAISDKRuntime = (helpers, adapter = {}) => {
+	if (isResourceExecution()) return useAISDKRuntimeResource(toValue(helpers), toValue(adapter));
+	return useRuntimeResource(() => useAISDKRuntimeResource(toValue(helpers), toValue(adapter)));
+};
+export { useAISDKRuntime };
+
+//# sourceMappingURL=useAISDKRuntime.js.map