@mastra/react 1.7.3-alpha.3 → 1.8.0-alpha.5

package/dist/hooks-BFQK_s4g.js

@@ -0,0 +1,1231 @@
+import { n as useMastraClient } from "./mastra-client-context-Bx_g84YB.js";
+import { a as CLIENT_MESSAGE_ID_KEY, n as accumulateNetworkChunk, o as convertSignalDataToBase64String, r as finishStreamingAssistantMessage, s as encodeFilePartDataForStorage, t as accumulateChunk } from "./accumulator-B1MuNX3j.js";
+import { MastraClient } from "@mastra/client-js";
+import { useCallback, useEffect, useRef, useState } from "react";
+import { v4 } from "@lukeed/uuid";
+import { AIV5Adapter } from "@mastra/core/agent/message-list";
+//#region src/lib/mastra-db/fromCoreUserMessage.ts
+/**
+* Convert a CoreUserMessage into a canonical `MastraDBMessage` (`format: 2`).
+*
+* Image and file inputs are emitted as the canonical V4 `file` part shape
+* (`{ type: 'file', mimeType, data }`) — the exact shape memory resolves on
+* reload (see `AIV4Adapter`), so optimistic-send and reload render identically.
+*
+* Handles all CoreUserMessage content types:
+* - String content → single text part
+* - Array content with text/image/file parts → corresponding `MastraMessagePart`s
+*/
+const coreUserMessageToParts = (coreUserMessage) => typeof coreUserMessage.content === "string" ? [{
+	type: "text",
+	text: coreUserMessage.content
+}] : coreUserMessage.content.map((part) => {
+	switch (part.type) {
+		case "text": return {
+			type: "text",
+			text: part.text
+		};
+		case "image": {
+			const mimeType = part.mimeType ?? "image/*";
+			return {
+				type: "file",
+				mimeType,
+				data: encodeFilePartDataForStorage(part.image, mimeType)
+			};
+		}
+		case "file": return {
+			type: "file",
+			mimeType: part.mimeType,
+			data: encodeFilePartDataForStorage(part.data, part.mimeType),
+			...part.filename !== void 0 ? { filename: part.filename } : {}
+		};
+		default: throw new Error(`Unhandled content part type: ${part.type}`);
+	}
+});
+const newUserMessage = (parts) => ({
+	id: `user-${Date.now()}-${Math.random().toString(36).substring(2, 9)}`,
+	role: "user",
+	createdAt: /* @__PURE__ */ new Date(),
+	content: {
+		format: 2,
+		parts
+	}
+});
+const fromCoreUserMessageToMastraDBMessage = (coreUserMessage) => newUserMessage(coreUserMessageToParts(coreUserMessage));
+/**
+* Merge multiple `CoreUserMessage`s into a single canonical `MastraDBMessage`.
+*
+* A user turn that carries attachments arrives as several `CoreUserMessage`s
+* (one for the text, one per attachment). Flatten their parts for the optimistic
+* display. The send path must also submit a single multipart message: this
+* display conversion alone cannot combine separately persisted messages.
+*/
+const fromCoreUserMessagesToMastraDBMessage = (coreUserMessages) => newUserMessage(coreUserMessages.flatMap(coreUserMessageToParts));
+//#endregion
+//#region src/agent/extract-tasks.ts
+const TASK_TOOL_NAMES = /* @__PURE__ */ new Set([
+	"task_write",
+	"task_update",
+	"task_complete",
+	"task_check"
+]);
+const TASK_SIGNAL_ID = "tasks";
+const TASK_TAG_NAMES = /* @__PURE__ */ new Set(["current-task-list", "task-list-update"]);
+const TASK_STATUSES = /* @__PURE__ */ new Set([
+	"pending",
+	"in_progress",
+	"completed"
+]);
+const isDataChunk$1 = (chunk) => typeof chunk.type === "string" && chunk.type.startsWith("data-");
+const isRecord$1 = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+const isTaskStatus = (value) => typeof value === "string" && TASK_STATUSES.has(value);
+const isTaskItemArray = (value) => Array.isArray(value) && value.every((item) => isRecord$1(item) && typeof item.id === "string" && typeof item.content === "string" && isTaskStatus(item.status) && typeof item.activeForm === "string");
+const isTaskSignal = (value) => {
+	if (!isRecord$1(value)) return false;
+	return value.id === TASK_SIGNAL_ID || typeof value.tagName === "string" && TASK_TAG_NAMES.has(value.tagName);
+};
+const extractTasksFromSignalData = (data) => {
+	if (!isTaskSignal(data) || !isRecord$1(data)) return void 0;
+	const metadata = data.metadata;
+	if (!isRecord$1(metadata)) return void 0;
+	const value = metadata.value;
+	if (!isRecord$1(value)) return void 0;
+	return isTaskItemArray(value.tasks) ? value.tasks : void 0;
+};
+const parseTasksFromResult = (raw) => {
+	if (isRecord$1(raw) && isTaskItemArray(raw.tasks)) return raw.tasks;
+	if (typeof raw !== "string") return void 0;
+	try {
+		const parsed = JSON.parse(raw);
+		return isRecord$1(parsed) && isTaskItemArray(parsed.tasks) ? parsed.tasks : void 0;
+	} catch {
+		return;
+	}
+};
+const extractTasksFromSignalChunk = (chunk) => {
+	if (!isDataChunk$1(chunk)) return void 0;
+	return extractTasksFromSignalData(chunk.data);
+};
+const extractTasksFromToolResultChunk = (chunk) => {
+	if (chunk.type !== "tool-result") return void 0;
+	const payload = chunk.payload;
+	if (!isRecord$1(payload) || typeof payload.toolName !== "string" || !TASK_TOOL_NAMES.has(payload.toolName)) return;
+	return parseTasksFromResult(payload.result);
+};
+const extractTasksFromToolInvocationPart = (part) => {
+	if (!isRecord$1(part) || part.type !== "tool-invocation" || !isRecord$1(part.toolInvocation)) return void 0;
+	const toolInvocation = part.toolInvocation;
+	if (typeof toolInvocation.toolName !== "string" || !TASK_TOOL_NAMES.has(toolInvocation.toolName)) return void 0;
+	return parseTasksFromResult(toolInvocation.result);
+};
+const extractTasksFromDataPart = (part) => {
+	if (!isRecord$1(part) || typeof part.type !== "string" || !part.type.startsWith("data-")) return void 0;
+	return extractTasksFromSignalData(part.data);
+};
+const extractTasksFromSignalMessage = (message) => {
+	if (message.role !== "signal") return void 0;
+	const metadata = message.content?.metadata;
+	if (!isRecord$1(metadata)) return void 0;
+	return extractTasksFromSignalData(metadata.signal);
+};
+const extractLatestTasksFromMessages = (messages) => {
+	let latest;
+	for (const message of messages) {
+		for (const part of message.content?.parts ?? []) {
+			const toolTasks = extractTasksFromToolInvocationPart(part);
+			if (toolTasks !== void 0) latest = toolTasks;
+		}
+		const signalTasks = extractTasksFromSignalMessage(message);
+		if (signalTasks !== void 0) latest = signalTasks;
+		for (const part of message.content?.parts ?? []) {
+			const dataTasks = extractTasksFromDataPart(part);
+			if (dataTasks !== void 0) latest = dataTasks;
+		}
+	}
+	return latest ?? [];
+};
+//#endregion
+//#region src/agent/extractRunIdFromMessages.ts
+const isRecord = (value) => value !== null && typeof value === "object";
+const runIdMetadataKeys = [
+	"pendingToolApprovals",
+	"requireApprovalMetadata",
+	"suspendedTools"
+];
+const isRunIdMetadataSource = (value) => isRecord(value) && Object.values(value).every((entry) => isRecord(entry));
+const getRunIdMetadataSources = (metadata) => {
+	if (!isRecord(metadata)) return [];
+	const sources = [];
+	for (const key of runIdMetadataKeys) {
+		const source = metadata[key];
+		if (isRunIdMetadataSource(source)) sources.push(source);
+	}
+	return sources;
+};
+/**
+* Scan initial DB-shape messages for any pending approvals, suspended tools, or
+* `requireApprovalMetadata` entries and return the first non-empty `runId`.
+*
+* Metadata is read off `message.content.metadata`, the canonical location for
+* MastraDBMessage UX hints.
+*/
+const extractRunIdFromMessages = (messages) => {
+	for (const message of messages) for (const source of getRunIdMetadataSources(message.content?.metadata)) for (const entry of Object.values(source)) if (isRecord(entry) && typeof entry.runId === "string" && entry.runId.length > 0) return entry.runId;
+};
+//#endregion
+//#region src/agent/merge-history.ts
+const liveClientMessageId = (message) => {
+	const clientMessageId = message.content.metadata?.[CLIENT_MESSAGE_ID_KEY];
+	return typeof clientMessageId === "string" ? clientMessageId : void 0;
+};
+const storedClientMessageId = (message) => {
+	const signal = message.content.metadata?.signal;
+	const clientMessageId = isRecord$1(signal) && isRecord$1(signal.metadata) ? signal.metadata[CLIENT_MESSAGE_ID_KEY] : void 0;
+	return typeof clientMessageId === "string" ? clientMessageId : void 0;
+};
+const mergeHistoryIntoConversation = ({ conversation, history, previousHistory }) => {
+	const previousById = new Map(previousHistory.map((message) => [message.id, message]));
+	const live = conversation.filter((message) => previousById.get(message.id) !== message);
+	const liveById = new Map(live.map((message) => [message.id, message]));
+	const liveClientMessageIds = new Set(live.flatMap((message) => liveClientMessageId(message) ?? []));
+	const historyIds = new Set(history.map((message) => message.id));
+	const storedClientMessageIds = new Set(history.flatMap((message) => storedClientMessageId(message) ?? []));
+	const mergedHistory = history.map((message) => {
+		const liveCopy = liveById.get(message.id);
+		if (liveCopy) return liveCopy;
+		const clientMessageId = storedClientMessageId(message);
+		if (!clientMessageId || !liveClientMessageIds.has(clientMessageId)) return message;
+		return {
+			...message,
+			content: {
+				...message.content,
+				metadata: {
+					...message.content.metadata,
+					[CLIENT_MESSAGE_ID_KEY]: clientMessageId
+				}
+			}
+		};
+	});
+	const unstoredLive = live.filter((message) => {
+		const clientMessageId = liveClientMessageId(message);
+		return !historyIds.has(message.id) && !(clientMessageId && storedClientMessageIds.has(clientMessageId));
+	});
+	return [...mergedHistory, ...unstoredLive];
+};
+//#endregion
+//#region src/agent/user-message.ts
+const messageParts = (message) => {
+	const parts = typeof message.content === "string" ? [{
+		type: "text",
+		text: message.content
+	}] : message.content;
+	const inheritedOptions = message.providerOptions ?? message.experimental_providerMetadata;
+	if (!inheritedOptions) return parts;
+	return parts.map((part) => {
+		const providerOptions = { ...inheritedOptions };
+		for (const [provider, options] of Object.entries(part.providerOptions ?? part.experimental_providerMetadata ?? {})) providerOptions[provider] = {
+			...providerOptions[provider],
+			...options
+		};
+		return {
+			...part,
+			providerOptions
+		};
+	});
+};
+/** One send is one user message, with each attachment retained as a content part. */
+const createUserMessage = (text, attachments = []) => ({
+	role: "user",
+	content: [...text || attachments.length === 0 ? [{
+		type: "text",
+		text
+	}] : [], ...attachments.flatMap(messageParts)]
+});
+//#endregion
+//#region src/agent/hooks.ts
+const extractPendingToolApprovalIdsFromMessages = (messages, runId) => {
+	const pendingToolApprovalIds = /* @__PURE__ */ new Set();
+	for (const message of messages) {
+		const metadata = message.content?.metadata;
+		if (!metadata) continue;
+		const metadataSources = [
+			metadata.pendingToolApprovals,
+			metadata.requireApprovalMetadata,
+			metadata.suspendedTools
+		];
+		for (const source of metadataSources) {
+			if (!source || typeof source !== "object") continue;
+			for (const suspensionData of Object.values(source)) {
+				if (runId && suspensionData?.runId !== runId) continue;
+				const toolCallId = suspensionData?.toolCallId;
+				if (typeof toolCallId === "string" && toolCallId.length > 0) pendingToolApprovalIds.add(toolCallId);
+			}
+		}
+	}
+	return pendingToolApprovalIds;
+};
+const toolCallHasOutput = (parts, toolCallId) => parts.some((part) => {
+	if (part.type !== "tool-invocation") return false;
+	const invocation = part.toolInvocation;
+	if (invocation.toolCallId !== toolCallId) return false;
+	return invocation.state === "result" || invocation.result != null;
+});
+const filterUnresolvedApprovals = (entries, parts) => {
+	if (!entries || typeof entries !== "object") return void 0;
+	const pending = Object.fromEntries(Object.entries(entries).filter(([, approval]) => approval && typeof approval === "object" && typeof approval.toolCallId === "string" && !toolCallHasOutput(parts, approval.toolCallId)));
+	return Object.keys(pending).length ? pending : void 0;
+};
+/**
+* Normalize persisted initial messages back into the stream-friendly shape the
+* UI renders from. Mirrors `main`'s `resolveInitialMessages`:
+*
+* - Converts persisted `pendingToolApprovals` (DB shape) into
+*   `requireApprovalMetadata` (stream shape) so reloaded threads still render
+*   approve/decline buttons, filtering out approvals whose tool already
+*   produced output, and marks the message `mode: 'stream'`.
+* - Drops assistant completion messages flagged `suppressFeedback`, which are
+*   persisted by the supervisor agent but must stay hidden on reload.
+*/
+const resolveInitialMessages = (messages) => messages.filter((message) => {
+	const metadata = message.content?.metadata;
+	if (metadata?.completionResult?.suppressFeedback || metadata?.isTaskCompleteResult?.suppressFeedback) return false;
+	return true;
+}).map((message) => {
+	const metadata = message.content?.metadata;
+	const normalizedMessage = metadata && (metadata.status === "pending" || "clientMessageId" in metadata) ? (() => {
+		const { [CLIENT_MESSAGE_ID_KEY]: _omitClientMessageId, ...rest } = metadata;
+		const { status: _omitStatus, ...restWithoutStatus } = rest;
+		return {
+			...message,
+			content: {
+				...message.content,
+				metadata: metadata.status === "pending" ? restWithoutStatus : rest
+			}
+		};
+	})() : message;
+	const normalizedMetadata = normalizedMessage.content?.metadata;
+	if (!normalizedMetadata?.pendingToolApprovals && !normalizedMetadata?.requireApprovalMetadata && !normalizedMetadata?.suspendedTools) return normalizedMessage;
+	const { pendingToolApprovals, requireApprovalMetadata, suspendedTools, ...restMetadata } = normalizedMetadata;
+	const parts = normalizedMessage.content.parts;
+	const pending = filterUnresolvedApprovals(pendingToolApprovals, parts);
+	const required = {
+		...filterUnresolvedApprovals(requireApprovalMetadata, parts),
+		...pending
+	};
+	const suspended = filterUnresolvedApprovals(suspendedTools, parts);
+	return {
+		...normalizedMessage,
+		content: {
+			...normalizedMessage.content,
+			metadata: {
+				...restMetadata,
+				...pendingToolApprovals ? { mode: "stream" } : {},
+				...pending ? { pendingToolApprovals: pending } : {},
+				...Object.keys(required).length ? { requireApprovalMetadata: required } : {},
+				...suspended ? { suspendedTools: suspended } : {}
+			}
+		}
+	};
+});
+const isObject = (value) => typeof value === "object" && value !== null;
+const getErrorName = (error) => isObject(error) && typeof error.name === "string" ? error.name : void 0;
+const isAbortError = (error) => getErrorName(error) === "AbortError";
+const isThreadSignalUnsupportedError = (error) => {
+	if (!isObject(error)) return false;
+	const status = error.status;
+	if (status === 404 || status === 405 || status === 501) return true;
+	return status === 400 && typeof error.message === "string" && error.message.includes("No active agent run found for signal target");
+};
+const isDataChunk = (chunk) => typeof chunk.type === "string" && chunk.type.startsWith("data-");
+/**
+* Convert AI-SDK v5 UIMessages returned by the server (generate mode) into
+* `MastraDBMessage[]`, stamping the supplied metadata onto each message's
+* `content.metadata`. Private helper — `useChat` never exposes the AI-SDK
+* shape to consumers.
+*/
+const dbFromServerUiMessages = (uiMessages, metadata) => uiMessages.map((uiMsg) => {
+	const dbMsg = AIV5Adapter.fromUIMessage(uiMsg);
+	return {
+		...dbMsg,
+		content: {
+			...dbMsg.content,
+			metadata: {
+				...dbMsg.content.metadata ?? {},
+				...metadata
+			}
+		}
+	};
+});
+const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContext: propsRequestContext, clientTools: hookClientTools, onSignalSent, onSignalEcho, onThreadSignalsUnsupported, enableThreadSignals = false, streamPath, withInitialHistory }) => {
+	const threadSignalsDisabled = enableThreadSignals === false;
+	const _currentRunId = useRef(void 0);
+	const _onChunk = useRef(void 0);
+	const _networkRunId = useRef(void 0);
+	const _onNetworkChunk = useRef(void 0);
+	const _activeContinuation = useRef({ requestContext: propsRequestContext });
+	const _streamAbortRef = useRef(null);
+	const _threadSubscriptionAbortRef = useRef(null);
+	const _threadSubscriptionRef = useRef(null);
+	const _threadSubscriptionKeyRef = useRef(void 0);
+	const _threadSubscriptionPromiseRef = useRef(null);
+	const _threadSignalsUnsupportedRef = useRef(false);
+	const [messages, setMessages] = useState([]);
+	const [tasks, setTasks] = useState([]);
+	const liveTasks = useRef(void 0);
+	const [toolCallApprovals, setToolCallApprovals] = useState({});
+	const [networkToolCallApprovals, setNetworkToolCallApprovals] = useState({});
+	const pendingToolApprovalIdsRef = useRef(/* @__PURE__ */ new Set());
+	const liveApprovalIds = useRef(/* @__PURE__ */ new Set());
+	const liveRunId = useRef(void 0);
+	const liveRunFinished = useRef(false);
+	const [isAwaitingToolApproval, setIsAwaitingToolApproval] = useState(false);
+	const baseClient = useMastraClient();
+	const [isRunning, setIsRunning] = useState(false);
+	const [subscriptionHistory, setSubscriptionHistory] = useState(void 0);
+	const historyKey = `${agentId}:${resourceId ?? ""}:${threadId ?? ""}`;
+	const hydratedMessages = withInitialHistory && subscriptionHistory?.key === historyKey ? subscriptionHistory.messages : initialMessages;
+	const lastHydration = useRef(void 0);
+	useEffect(() => {
+		const previous = lastHydration.current;
+		const sameThread = previous?.agentId === agentId && previous.resourceId === resourceId && previous.threadId === threadId;
+		if (sameThread && previous.initialMessages === hydratedMessages) return;
+		const formattedMessages = resolveInitialMessages(hydratedMessages ?? []);
+		lastHydration.current = {
+			agentId,
+			resourceId,
+			threadId,
+			initialMessages: hydratedMessages,
+			formattedMessages
+		};
+		if (sameThread) {
+			setMessages((current) => mergeHistoryIntoConversation({
+				conversation: current,
+				history: formattedMessages,
+				previousHistory: previous.formattedMessages
+			}));
+			setTasks(liveTasks.current ?? extractLatestTasksFromMessages(formattedMessages));
+			const historyRunId = extractRunIdFromMessages(formattedMessages);
+			if (liveRunFinished.current) return;
+			if (!liveRunId.current && isRunning && historyRunId !== _currentRunId.current) return;
+		} else {
+			liveTasks.current = void 0;
+			liveApprovalIds.current.clear();
+			liveRunId.current = void 0;
+			liveRunFinished.current = false;
+			if (previous) setIsRunning(false);
+			setMessages(formattedMessages);
+			setTasks(extractLatestTasksFromMessages(formattedMessages));
+		}
+		const pendingApprovals = extractPendingToolApprovalIdsFromMessages(formattedMessages, liveRunId.current);
+		for (const toolCallId of liveApprovalIds.current) if (pendingToolApprovalIdsRef.current.has(toolCallId)) pendingApprovals.add(toolCallId);
+		else pendingApprovals.delete(toolCallId);
+		pendingToolApprovalIdsRef.current = pendingApprovals;
+		setIsAwaitingToolApproval(pendingApprovals.size > 0);
+		_currentRunId.current = liveRunId.current ?? extractRunIdFromMessages(formattedMessages);
+	}, [
+		agentId,
+		resourceId,
+		threadId,
+		hydratedMessages,
+		isRunning,
+		isAwaitingToolApproval
+	]);
+	useEffect(() => {
+		_activeContinuation.current = {
+			..._activeContinuation.current,
+			requestContext: propsRequestContext
+		};
+	}, [propsRequestContext]);
+	const normalizeSignalFileData = (data) => {
+		if (data instanceof URL) return data.toString();
+		return convertSignalDataToBase64String(data);
+	};
+	const getSignalContents = (coreUserMessages) => {
+		const parts = coreUserMessages.reduce((allParts, message) => {
+			if (typeof message.content === "string") {
+				allParts.push({
+					type: "text",
+					text: message.content
+				});
+				return allParts;
+			}
+			for (const part of message.content) if (part.type === "text") allParts.push({
+				type: "text",
+				text: part.text
+			});
+			else if (part.type === "file") allParts.push({
+				type: "file",
+				data: normalizeSignalFileData(part.data),
+				mediaType: part.mimeType,
+				...part.filename ? { filename: part.filename } : {}
+			});
+			else if (part.type === "image") allParts.push({
+				type: "file",
+				data: normalizeSignalFileData(part.image),
+				mediaType: part.mimeType ?? "image/png"
+			});
+			return allParts;
+		}, []);
+		return parts.length === 1 && parts[0]?.type === "text" ? parts[0].text : parts;
+	};
+	const markThreadSignalsUnsupported = useCallback(() => {
+		_threadSignalsUnsupportedRef.current = true;
+		onThreadSignalsUnsupported?.();
+	}, [onThreadSignalsUnsupported]);
+	const getSignalPreview = (coreUserMessages) => {
+		return coreUserMessages.flatMap((message) => {
+			if (typeof message.content === "string") return [message.content];
+			return message.content.map((part) => {
+				if (part.type === "text") return part.text;
+				if (part.type === "image") return "Image";
+				return part.filename ? `File: ${part.filename}` : "File";
+			});
+		}).join(" ").replace(/\s+/g, " ").trim() || "Attachment";
+	};
+	const closeThreadSubscription = useCallback(() => {
+		const subscription = _threadSubscriptionRef.current;
+		if (subscription?.unsubscribe) subscription.unsubscribe();
+		else _threadSubscriptionAbortRef.current?.abort();
+		_threadSubscriptionRef.current = null;
+		_threadSubscriptionAbortRef.current = null;
+		_threadSubscriptionKeyRef.current = void 0;
+		_threadSubscriptionPromiseRef.current = null;
+	}, []);
+	const processStreamChunk = useCallback(async (chunk, onChunk) => {
+		const isTerminal = chunk.type === "finish" || chunk.type === "abort" || chunk.type === "error";
+		if (isTerminal && liveRunId.current && chunk.runId !== liveRunId.current) return;
+		const runId = "runId" in chunk && typeof chunk.runId === "string" ? chunk.runId : void 0;
+		setMessages((prev) => {
+			const metadata = {
+				mode: "stream",
+				runId
+			};
+			const next = accumulateChunk({
+				chunk,
+				conversation: prev,
+				metadata
+			});
+			if ((chunk.type === "start" || chunk.type === "step-start") && chunk.payload?.messageId && runId) return next.map((message) => message.id === chunk.payload.messageId && message.role === "assistant" ? {
+				...message,
+				content: {
+					...message.content,
+					metadata: {
+						...message.content.metadata,
+						...metadata
+					}
+				}
+			} : message);
+			return next;
+		});
+		const streamedTasks = extractTasksFromToolResultChunk(chunk) ?? extractTasksFromSignalChunk(chunk);
+		if (streamedTasks !== void 0) {
+			liveTasks.current = streamedTasks;
+			setTasks(streamedTasks);
+		}
+		if (chunk.type === "data-user-message" && isDataChunk(chunk) && (chunk.data?.type === "user-message" || chunk.data?.type === "user") && typeof chunk.data?.id === "string") onSignalEcho?.(chunk.data.id);
+		if (chunk.type === "start") {
+			setIsRunning(true);
+			if ("runId" in chunk && typeof chunk.runId === "string") {
+				if (liveRunId.current !== chunk.runId) liveApprovalIds.current.clear();
+				liveRunFinished.current = false;
+				liveRunId.current = chunk.runId;
+				_currentRunId.current = chunk.runId;
+			}
+		}
+		if (chunk.type === "tool-call-approval" || chunk.type === "tool-call-suspended") {
+			const toolCallId = chunk.payload?.toolCallId;
+			if (typeof toolCallId === "string") {
+				liveApprovalIds.current.add(toolCallId);
+				pendingToolApprovalIdsRef.current.add(toolCallId);
+				setIsAwaitingToolApproval(true);
+			}
+			if (runId) {
+				if (!liveRunId.current || liveRunFinished.current) {
+					liveRunId.current = runId;
+					liveRunFinished.current = false;
+				}
+				if (liveRunId.current === runId) _currentRunId.current = runId;
+			}
+			setIsRunning(false);
+		}
+		if (chunk.type === "tool-call-resumed") {
+			const toolCallId = chunk.payload?.toolCallId;
+			if (typeof toolCallId === "string") {
+				liveApprovalIds.current.add(toolCallId);
+				pendingToolApprovalIdsRef.current.delete(toolCallId);
+				setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
+			}
+		}
+		if (isTerminal) {
+			if (chunk.runId === liveRunId.current) liveRunFinished.current = true;
+			for (const toolCallId of pendingToolApprovalIdsRef.current) liveApprovalIds.current.add(toolCallId);
+			pendingToolApprovalIdsRef.current.clear();
+			setIsAwaitingToolApproval(false);
+			setIsRunning(false);
+		}
+		(onChunk ?? _onChunk.current)?.(chunk);
+	}, [onSignalEcho]);
+	const ensureThreadSubscription = useCallback(async ({ threadId, resourceId }) => {
+		const subscriptionKey = `${agentId}:${resourceId ?? ""}:${threadId}:${streamPath ?? ""}`;
+		if (_threadSubscriptionKeyRef.current === subscriptionKey && _threadSubscriptionPromiseRef.current) {
+			await _threadSubscriptionPromiseRef.current;
+			return;
+		}
+		closeThreadSubscription();
+		const subscriptionAbort = new AbortController();
+		_threadSubscriptionAbortRef.current = subscriptionAbort;
+		_threadSubscriptionKeyRef.current = subscriptionKey;
+		const releaseSubscriptionRefs = () => {
+			if (_threadSubscriptionAbortRef.current !== subscriptionAbort) return;
+			_threadSubscriptionRef.current = null;
+			_threadSubscriptionAbortRef.current = null;
+			_threadSubscriptionKeyRef.current = void 0;
+			_threadSubscriptionPromiseRef.current = null;
+		};
+		const subscriptionAgent = new MastraClient({
+			...baseClient.options,
+			abortSignal: subscriptionAbort.signal
+		}).getAgent(agentId, void 0, { stream: streamPath });
+		_threadSubscriptionPromiseRef.current = subscriptionAgent.subscribeToThread({
+			resourceId,
+			threadId,
+			...withInitialHistory ? { withInitialHistory } : {}
+		}).then((response) => {
+			const subscription = response;
+			if (_threadSubscriptionAbortRef.current !== subscriptionAbort) {
+				subscription.unsubscribe();
+				return;
+			}
+			_threadSubscriptionRef.current = subscription;
+			subscription.processDataStream({ onChunk: (chunk) => {
+				if (chunk.type === "thread-history") {
+					const history = resolveInitialMessages(chunk.payload.messages);
+					const previousHistory = lastHydration.current?.formattedMessages ?? [];
+					setMessages((current) => mergeHistoryIntoConversation({
+						conversation: current,
+						history,
+						previousHistory
+					}));
+					setSubscriptionHistory({
+						key: `${agentId}:${resourceId ?? ""}:${threadId}`,
+						messages: chunk.payload.messages
+					});
+					return;
+				}
+				return processStreamChunk(chunk);
+			} }).catch((error) => {
+				if (!isAbortError(error)) {
+					console.error("[useChat] Thread subscription failed", error);
+					setIsRunning(false);
+				}
+			}).finally(() => {
+				if (_threadSubscriptionRef.current === subscription) _threadSubscriptionRef.current = null;
+				releaseSubscriptionRefs();
+			});
+		}).catch((error) => {
+			releaseSubscriptionRefs();
+			if (isThreadSignalUnsupportedError(error)) {
+				markThreadSignalsUnsupported();
+				return;
+			}
+			if (!isAbortError(error)) {
+				console.error("[useChat] Thread subscription failed", error);
+				setIsRunning(false);
+			}
+			throw error;
+		});
+		await _threadSubscriptionPromiseRef.current;
+	}, [
+		agentId,
+		baseClient,
+		closeThreadSubscription,
+		markThreadSignalsUnsupported,
+		processStreamChunk,
+		streamPath,
+		withInitialHistory
+	]);
+	useEffect(() => {
+		_threadSignalsUnsupportedRef.current = false;
+		return closeThreadSubscription;
+	}, [
+		agentId,
+		resourceId,
+		threadId,
+		closeThreadSubscription
+	]);
+	useEffect(() => {
+		if (!threadId || threadSignalsDisabled) {
+			closeThreadSubscription();
+			return;
+		}
+		ensureThreadSubscription({
+			threadId,
+			resourceId: resourceId || agentId
+		}).catch((error) => {
+			if (!isAbortError(error)) console.error("[useChat] Thread subscription failed", error);
+		});
+	}, [
+		agentId,
+		closeThreadSubscription,
+		ensureThreadSubscription,
+		resourceId,
+		threadId,
+		threadSignalsDisabled
+	]);
+	const generate = async ({ coreUserMessages, model, requestContext, threadId, modelSettings, signal, onFinish, tracingOptions, clientTools, clientToolsResolver }) => {
+		const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, instructions, system, providerOptions, maxSteps, requireToolApproval } = modelSettings || {};
+		const resolvedRequestContext = requestContext ?? propsRequestContext;
+		const resolvedClientTools = clientTools ?? hookClientTools;
+		_activeContinuation.current = {
+			model,
+			requestContext: resolvedRequestContext
+		};
+		setIsRunning(true);
+		const agent = new MastraClient({
+			...baseClient.options,
+			abortSignal: signal
+		}).getAgent(agentId, void 0, { stream: streamPath });
+		const runId = v4();
+		_currentRunId.current = runId;
+		const response = await agent.generate(coreUserMessages, {
+			model,
+			runId,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			instructions,
+			system,
+			requestContext: resolvedRequestContext,
+			...threadId ? { memory: {
+				thread: threadId,
+				resource: resourceId || agentId
+			} } : {},
+			providerOptions,
+			tracingOptions,
+			requireToolApproval,
+			clientTools: resolvedClientTools,
+			clientToolsResolver
+		});
+		if (response.finishReason === "suspended" && response.suspendPayload) {
+			const { toolCallId, toolName, args } = response.suspendPayload;
+			if (response.response?.uiMessages) {
+				const dbMessages = dbFromServerUiMessages(response.response.uiMessages, {
+					mode: "generate",
+					requireApprovalMetadata: { [toolName]: {
+						toolCallId,
+						toolName,
+						args
+					} }
+				});
+				setMessages((prev) => [...prev, ...dbMessages]);
+			}
+			setIsRunning(false);
+			return;
+		}
+		setIsRunning(false);
+		if (response && "uiMessages" in response.response && response.response.uiMessages) {
+			const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+			onFinish?.(dbMessages);
+			setMessages((prev) => [...prev, ...dbMessages]);
+		}
+	};
+	const stream = async ({ coreUserMessages, model, requestContext, threadId, onChunk, modelSettings, signal, tracingOptions, clientTools, clientToolsResolver, signalId, clientMessageId }) => {
+		const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, instructions, system, providerOptions, maxSteps, requireToolApproval } = modelSettings || {};
+		const resolvedRequestContext = requestContext ?? propsRequestContext;
+		const resolvedClientTools = clientTools ?? hookClientTools;
+		const signalContinuationOptions = {
+			model,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			instructions,
+			system,
+			providerOptions,
+			requireToolApproval,
+			tracingOptions
+		};
+		_activeContinuation.current = {
+			model,
+			requestContext: resolvedRequestContext
+		};
+		setIsRunning(true);
+		_streamAbortRef.current?.abort();
+		const internalAbort = new AbortController();
+		_streamAbortRef.current = internalAbort;
+		if (signal) if (signal.aborted) internalAbort.abort();
+		else signal.addEventListener("abort", () => internalAbort.abort(), { once: true });
+		const agent = new MastraClient({
+			...baseClient.options,
+			abortSignal: internalAbort.signal
+		}).getAgent(agentId, void 0, { stream: streamPath });
+		const streamWithLegacyRoute = async () => {
+			const runId = v4();
+			const response = await agent.stream(coreUserMessages, {
+				model,
+				runId,
+				maxSteps,
+				untilIdle: true,
+				modelSettings: {
+					frequencyPenalty,
+					presencePenalty,
+					maxRetries,
+					maxOutputTokens: maxTokens,
+					temperature,
+					topK,
+					topP
+				},
+				instructions,
+				system,
+				requestContext: resolvedRequestContext,
+				...threadId ? { memory: {
+					thread: threadId,
+					resource: resourceId || agentId
+				} } : {},
+				providerOptions,
+				requireToolApproval,
+				tracingOptions,
+				clientTools: resolvedClientTools,
+				clientToolsResolver
+			});
+			_onChunk.current = onChunk;
+			_currentRunId.current = runId;
+			await response.processDataStream({ onChunk: (chunk) => processStreamChunk(chunk, onChunk) });
+			if (_streamAbortRef.current === internalAbort) _streamAbortRef.current = null;
+			setIsRunning(false);
+		};
+		if (!threadId || _threadSignalsUnsupportedRef.current || threadSignalsDisabled) {
+			await streamWithLegacyRoute();
+			return;
+		}
+		_onChunk.current = onChunk;
+		await ensureThreadSubscription({
+			threadId,
+			resourceId: resourceId || agentId
+		});
+		if (_threadSignalsUnsupportedRef.current) {
+			await streamWithLegacyRoute();
+			return;
+		}
+		const resolvedSignalId = signalId ?? v4();
+		const messageContents = getSignalContents(coreUserMessages);
+		const requestContextRecord = resolvedRequestContext;
+		const streamOptions = {
+			model,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			instructions,
+			system,
+			requestContext: requestContextRecord,
+			providerOptions,
+			requireToolApproval,
+			tracingOptions,
+			clientTools: resolvedClientTools,
+			clientToolsResolver
+		};
+		try {
+			const result = await agent.sendMessage({
+				message: clientMessageId ? {
+					contents: messageContents,
+					metadata: { [CLIENT_MESSAGE_ID_KEY]: clientMessageId }
+				} : messageContents,
+				resourceId: resourceId || agentId,
+				threadId,
+				ifIdle: { streamOptions: {
+					...signalContinuationOptions,
+					requestContext: requestContextRecord,
+					clientTools: resolvedClientTools,
+					clientToolsResolver
+				} }
+			});
+			const echoedSignalId = result.signal && typeof result.signal === "object" && "id" in result.signal && typeof result.signal.id === "string" ? result.signal.id : resolvedSignalId;
+			onSignalSent?.(echoedSignalId, getSignalPreview(coreUserMessages));
+			if (pendingToolApprovalIdsRef.current.size > 0) setIsRunning(false);
+		} catch (error) {
+			if (isThreadSignalUnsupportedError(error)) try {
+				await agent.sendSignal({
+					signal: {
+						id: resolvedSignalId,
+						type: "user-message",
+						contents: messageContents
+					},
+					resourceId: resourceId || agentId,
+					threadId,
+					ifIdle: { streamOptions }
+				});
+				onSignalSent?.(resolvedSignalId, getSignalPreview(coreUserMessages));
+				return;
+			} catch (signalError) {
+				onSignalEcho?.(resolvedSignalId);
+				if (isThreadSignalUnsupportedError(signalError)) {
+					markThreadSignalsUnsupported();
+					setMessages((prev) => [...prev, fromCoreUserMessagesToMastraDBMessage(coreUserMessages)]);
+					await streamWithLegacyRoute();
+					return;
+				}
+				throw signalError;
+			}
+			throw error;
+		}
+		if (_streamAbortRef.current === internalAbort) _streamAbortRef.current = null;
+	};
+	const network = async ({ coreUserMessages, model, requestContext, threadId, onNetworkChunk, modelSettings, signal, tracingOptions }) => {
+		const { frequencyPenalty, presencePenalty, maxRetries, maxTokens, temperature, topK, topP, maxSteps } = modelSettings || {};
+		const resolvedRequestContext = requestContext ?? propsRequestContext;
+		_activeContinuation.current = {
+			model,
+			requestContext: resolvedRequestContext
+		};
+		setIsRunning(true);
+		const agent = new MastraClient({
+			...baseClient.options,
+			abortSignal: signal
+		}).getAgent(agentId, void 0, { stream: streamPath });
+		const runId = v4();
+		_currentRunId.current = runId;
+		const response = await agent.network(coreUserMessages, {
+			model,
+			maxSteps,
+			modelSettings: {
+				frequencyPenalty,
+				presencePenalty,
+				maxRetries,
+				maxOutputTokens: maxTokens,
+				temperature,
+				topK,
+				topP
+			},
+			runId,
+			requestContext: resolvedRequestContext,
+			...threadId ? { memory: {
+				thread: threadId,
+				resource: resourceId || agentId
+			} } : {},
+			tracingOptions
+		});
+		_onNetworkChunk.current = onNetworkChunk;
+		_networkRunId.current = runId;
+		await response.processDataStream({ onChunk: async (chunk) => {
+			setMessages((prev) => accumulateNetworkChunk({
+				chunk,
+				conversation: prev,
+				metadata: {
+					mode: "network",
+					runId
+				}
+			}));
+			onNetworkChunk?.(chunk);
+		} });
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		setIsRunning(false);
+	};
+	const handleCancelRun = () => {
+		_streamAbortRef.current?.abort();
+		_streamAbortRef.current = null;
+		const threadSubscription = _threadSubscriptionRef.current;
+		Promise.resolve(threadSubscription?.abort?.()).catch((error) => {
+			console.error("[useChat] Failed to abort thread subscription", error);
+		});
+		closeThreadSubscription();
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		liveRunFinished.current = true;
+		pendingToolApprovalIdsRef.current.clear();
+		setIsAwaitingToolApproval(false);
+		setIsRunning(false);
+		_currentRunId.current = void 0;
+		_onChunk.current = void 0;
+		_networkRunId.current = void 0;
+		_onNetworkChunk.current = void 0;
+		_activeContinuation.current = {};
+	};
+	const approveToolCall = async (toolCallId, resumeData) => {
+		const onChunk = _onChunk.current;
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[approveToolCall] approveToolCall can only be called after a stream has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "approved" }
+		}));
+		const agent = baseClient.getAgent(agentId, void 0, { stream: streamPath });
+		if (_threadSubscriptionKeyRef.current && threadId) {
+			try {
+				await agent.sendToolApproval({
+					resourceId: resourceId || agentId,
+					threadId,
+					toolCallId,
+					approved: true,
+					...continuation.model !== void 0 ? { streamOptions: { model: continuation.model } } : {},
+					...resumeData !== void 0 ? { resumeData } : {},
+					requestContext: continuation.requestContext
+				});
+				liveRunId.current ??= currentRunId;
+				liveApprovalIds.current.add(toolCallId);
+				pendingToolApprovalIdsRef.current.delete(toolCallId);
+				setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
+				setIsRunning(false);
+			} catch (error) {
+				setToolCallApprovals((prev) => {
+					const next = { ...prev };
+					delete next[toolCallId];
+					return next;
+				});
+				setIsRunning(false);
+				throw error;
+			}
+			return;
+		}
+		try {
+			await (resumeData !== void 0 ? await agent.resumeStream(resumeData, {
+				runId: currentRunId,
+				toolCallId,
+				...continuation
+			}) : await agent.approveToolCall({
+				runId: currentRunId,
+				toolCallId,
+				...continuation
+			})).processDataStream({ onChunk: async (chunk) => {
+				await processStreamChunk(chunk, onChunk);
+			} });
+			setIsRunning(false);
+		} catch (error) {
+			setToolCallApprovals((prev) => {
+				const next = { ...prev };
+				delete next[toolCallId];
+				return next;
+			});
+			setIsRunning(false);
+			throw error;
+		}
+	};
+	const declineToolCall = async (toolCallId) => {
+		const onChunk = _onChunk.current;
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[declineToolCall] declineToolCall can only be called after a stream has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "declined" }
+		}));
+		const agent = baseClient.getAgent(agentId, void 0, { stream: streamPath });
+		if (_threadSubscriptionKeyRef.current && threadId) {
+			try {
+				await agent.sendToolApproval({
+					resourceId: resourceId || agentId,
+					threadId,
+					toolCallId,
+					approved: false,
+					...continuation.model !== void 0 ? { streamOptions: { model: continuation.model } } : {},
+					requestContext: continuation.requestContext
+				});
+				liveRunId.current ??= currentRunId;
+				liveApprovalIds.current.add(toolCallId);
+				pendingToolApprovalIdsRef.current.delete(toolCallId);
+				setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
+				setIsRunning(false);
+			} catch (error) {
+				setToolCallApprovals((prev) => {
+					const next = { ...prev };
+					delete next[toolCallId];
+					return next;
+				});
+				setIsRunning(false);
+				throw error;
+			}
+			return;
+		}
+		await (await agent.declineToolCall({
+			runId: currentRunId,
+			toolCallId,
+			...continuation
+		})).processDataStream({ onChunk: async (chunk) => {
+			await processStreamChunk(chunk, onChunk);
+		} });
+		setIsRunning(false);
+	};
+	const approveToolCallGenerate = async (toolCallId) => {
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[approveToolCallGenerate] approveToolCallGenerate can only be called after a generate has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "approved" }
+		}));
+		const response = await baseClient.getAgent(agentId, void 0, { stream: streamPath }).approveToolCallGenerate({
+			runId: currentRunId,
+			toolCallId,
+			...continuation
+		});
+		if (response && "uiMessages" in response.response && response.response.uiMessages) {
+			const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+			setMessages((prev) => [...prev, ...dbMessages]);
+		}
+		setIsRunning(false);
+	};
+	const declineToolCallGenerate = async (toolCallId) => {
+		const currentRunId = _currentRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!currentRunId) return console.info("[declineToolCallGenerate] declineToolCallGenerate can only be called after a generate has started");
+		setIsRunning(true);
+		setToolCallApprovals((prev) => ({
+			...prev,
+			[toolCallId]: { status: "declined" }
+		}));
+		const response = await baseClient.getAgent(agentId, void 0, { stream: streamPath }).declineToolCallGenerate({
+			runId: currentRunId,
+			toolCallId,
+			...continuation
+		});
+		if (response && "uiMessages" in response.response && response.response.uiMessages) {
+			const dbMessages = dbFromServerUiMessages(response.response.uiMessages, { mode: "generate" });
+			setMessages((prev) => [...prev, ...dbMessages]);
+		}
+		setIsRunning(false);
+	};
+	const approveNetworkToolCall = async (toolName, runId) => {
+		const onNetworkChunk = _onNetworkChunk.current;
+		const networkRunId = runId || _networkRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!networkRunId) return console.info("[approveNetworkToolCall] approveNetworkToolCall can only be called after a network stream has started");
+		_currentRunId.current = networkRunId;
+		setIsRunning(true);
+		setNetworkToolCallApprovals((prev) => ({
+			...prev,
+			[runId ? `${runId}-${toolName}` : toolName]: { status: "approved" }
+		}));
+		await (await baseClient.getAgent(agentId, void 0, { stream: streamPath }).approveNetworkToolCall({
+			runId: networkRunId,
+			...continuation
+		})).processDataStream({ onChunk: async (chunk) => {
+			setMessages((prev) => accumulateNetworkChunk({
+				chunk,
+				conversation: prev,
+				metadata: {
+					mode: "network",
+					runId: networkRunId
+				}
+			}));
+			onNetworkChunk?.(chunk);
+		} });
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		setIsRunning(false);
+	};
+	const declineNetworkToolCall = async (toolName, runId) => {
+		const onNetworkChunk = _onNetworkChunk.current;
+		const networkRunId = runId || _networkRunId.current;
+		const continuation = _activeContinuation.current;
+		if (!networkRunId) return console.info("[declineNetworkToolCall] declineNetworkToolCall can only be called after a network stream has started");
+		_currentRunId.current = networkRunId;
+		setIsRunning(true);
+		setNetworkToolCallApprovals((prev) => ({
+			...prev,
+			[runId ? `${runId}-${toolName}` : toolName]: { status: "declined" }
+		}));
+		await (await baseClient.getAgent(agentId, void 0, { stream: streamPath }).declineNetworkToolCall({
+			runId: networkRunId,
+			...continuation
+		})).processDataStream({ onChunk: async (chunk) => {
+			setMessages((prev) => accumulateNetworkChunk({
+				chunk,
+				conversation: prev,
+				metadata: {
+					mode: "network",
+					runId: networkRunId
+				}
+			}));
+			onNetworkChunk?.(chunk);
+		} });
+		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		setIsRunning(false);
+	};
+	const sendMessage = async ({ mode = "stream", ...args }) => {
+		if (!isRunning && !isAwaitingToolApproval) _currentRunId.current = void 0;
+		const coreUserMessages = [createUserMessage(args.message, args.coreUserMessages)];
+		const dbUserMessage = fromCoreUserMessagesToMastraDBMessage(coreUserMessages);
+		const clientSetId = mode === "stream" && args.threadId && !_threadSignalsUnsupportedRef.current && !threadSignalsDisabled ? `client-set-${v4()}` : void 0;
+		const signalId = clientSetId;
+		const clientMessageId = clientSetId;
+		if (signalId) {
+			const metadata = {
+				...dbUserMessage.content.metadata,
+				mode: "stream",
+				status: "pending",
+				[CLIENT_MESSAGE_ID_KEY]: clientMessageId
+			};
+			const pendingMessage = {
+				...dbUserMessage,
+				id: clientSetId,
+				content: {
+					...dbUserMessage.content,
+					metadata
+				}
+			};
+			setMessages((s) => [...s, pendingMessage]);
+		} else setMessages((s) => [...s, dbUserMessage]);
+		try {
+			if (mode === "generate") await generate({
+				...args,
+				coreUserMessages
+			});
+			else if (mode === "stream") await stream({
+				...args,
+				coreUserMessages,
+				signalId,
+				clientMessageId
+			});
+			else if (mode === "network") await network({
+				...args,
+				coreUserMessages
+			});
+		} catch (error) {
+			setIsRunning(false);
+			throw error;
+		}
+	};
+	return {
+		setMessages,
+		sendMessage,
+		isRunning,
+		activeRunId: isRunning || isAwaitingToolApproval ? _currentRunId.current : void 0,
+		isAwaitingToolApproval,
+		messages,
+		tasks,
+		approveToolCall,
+		declineToolCall,
+		approveToolCallGenerate,
+		declineToolCallGenerate,
+		cancelRun: handleCancelRun,
+		toolCallApprovals,
+		approveNetworkToolCall,
+		declineNetworkToolCall,
+		networkToolCallApprovals
+	};
+};
+//#endregion
+export { fromCoreUserMessageToMastraDBMessage as n, fromCoreUserMessagesToMastraDBMessage as r, useChat as t };
+
+//# sourceMappingURL=hooks-BFQK_s4g.js.map