@mastra/react 1.4.12 → 1.4.13-alpha.1

package/dist/index.js

@@ -1795,7 +1795,7 @@ const extractRunIdFromMessages = (messages) => {
 };
 //#endregion
 //#region src/agent/hooks.ts
-const extractPendingToolApprovalIdsFromMessages = (messages) => {
+const extractPendingToolApprovalIdsFromMessages = (messages, runId) => {
 	const pendingToolApprovalIds = /* @__PURE__ */ new Set();
 	for (const message of messages) {
 		const metadata = message.content?.metadata;
@@ -1808,6 +1808,7 @@ const extractPendingToolApprovalIdsFromMessages = (messages) => {
 		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);
 			}
@@ -1821,6 +1822,11 @@ const toolCallHasOutput = (parts, toolCallId) => parts.some((part) => {
 	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`:
@@ -1850,22 +1856,25 @@ const resolveInitialMessages = (messages) => messages.filter((message) => {
 		};
 	})() : message;
 	const normalizedMetadata = normalizedMessage.content?.metadata;
-	const pendingToolApprovals = normalizedMetadata?.pendingToolApprovals;
-	if (!pendingToolApprovals || typeof pendingToolApprovals !== "object") return normalizedMessage;
-	const stillPending = Object.fromEntries(Object.entries(pendingToolApprovals).filter(([, approval]) => approval && typeof approval === "object" && typeof approval.toolCallId === "string" && !toolCallHasOutput(normalizedMessage.content.parts, approval.toolCallId)));
-	const { pendingToolApprovals: _omit, ...restMetadata } = normalizedMetadata;
-	const hasStillPending = Object.keys(stillPending).length > 0;
+	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,
-				mode: "stream",
-				...hasStillPending ? {
-					pendingToolApprovals: stillPending,
-					requireApprovalMetadata: stillPending
-				} : {}
+				...pendingToolApprovals ? { mode: "stream" } : {},
+				...pending ? { pendingToolApprovals: pending } : {},
+				...Object.keys(required).length ? { requireApprovalMetadata: required } : {},
+				...suspended ? { suspendedTools: suspended } : {}
 			}
 		}
 	};
@@ -1914,20 +1923,64 @@ const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContex
 	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 lastHydration = useRef(void 0);
 	useEffect(() => {
+		const previous = lastHydration.current;
+		const sameThread = previous?.agentId === agentId && previous.resourceId === resourceId && previous.threadId === threadId;
+		if (sameThread && previous.initialMessages === initialMessages) return;
 		const formattedMessages = resolveInitialMessages(initialMessages ?? []);
-		setMessages(formattedMessages);
-		setTasks(extractLatestTasksFromMessages(formattedMessages));
-		pendingToolApprovalIdsRef.current = extractPendingToolApprovalIdsFromMessages(formattedMessages);
-		setIsAwaitingToolApproval(pendingToolApprovalIdsRef.current.size > 0);
-		_currentRunId.current = extractRunIdFromMessages(formattedMessages);
-	}, [initialMessages]);
+		lastHydration.current = {
+			agentId,
+			resourceId,
+			threadId,
+			initialMessages,
+			formattedMessages
+		};
+		if (sameThread) {
+			const previousById = new Map(previous.formattedMessages.map((message) => [message.id, message]));
+			setMessages((current) => {
+				const live = current.filter((message) => previousById.get(message.id) !== message);
+				const liveById = new Map(live.map((message) => [message.id, message]));
+				const historyIds = new Set(formattedMessages.map((message) => message.id));
+				return [...formattedMessages.map((message) => liveById.get(message.id) ?? message), ...live.filter((message) => !historyIds.has(message.id))];
+			});
+			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,
+		initialMessages,
+		isRunning,
+		isAwaitingToolApproval
+	]);
 	useEffect(() => {
 		_activeContinuation.current = {
 			..._activeContinuation.current,
@@ -1990,29 +2043,40 @@ const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContex
 		_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;
 		setMessages((prev) => accumulateChunk({
 			chunk,
 			conversation: prev,
 			metadata: { mode: "stream" }
 		}));
-		const signalTasks = extractTasksFromSignalChunk(chunk);
-		if (signalTasks !== void 0) setTasks(signalTasks);
-		const toolTasks = extractTasksFromToolResultChunk(chunk);
-		if (toolTasks !== void 0) setTasks(toolTasks);
+		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") _currentRunId.current = chunk.runId;
+			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);
 			}
 			setIsRunning(false);
 		}
-		if (chunk.type === "finish" || chunk.type === "abort" || chunk.type === "error") {
+		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);
@@ -2293,30 +2357,28 @@ const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContex
 			onSignalSent?.(echoedSignalId, getSignalPreview(coreUserMessages));
 			if (pendingToolApprovalIdsRef.current.size > 0) setIsRunning(false);
 		} catch (error) {
-			if (isThreadSignalUnsupportedError(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));
-				try {
-					await agent.sendSignal({
-						signal: {
-							id: resolvedSignalId,
-							type: "user-message",
-							contents: messageContents
-						},
-						resourceId: resourceId || agentId,
-						threadId,
-						ifIdle: { streamOptions }
-					});
+				return;
+			} catch (signalError) {
+				onSignalEcho?.(resolvedSignalId);
+				if (isThreadSignalUnsupportedError(signalError)) {
+					markThreadSignalsUnsupported();
+					setMessages((prev) => [...prev, fromCoreUserMessagesToMastraDBMessage(coreUserMessages)]);
+					await streamWithLegacyRoute();
 					return;
-				} catch (signalError) {
-					onSignalEcho?.(resolvedSignalId);
-					if (isThreadSignalUnsupportedError(signalError)) {
-						markThreadSignalsUnsupported();
-						setMessages((prev) => [...prev, fromCoreUserMessagesToMastraDBMessage(coreUserMessages)]);
-						await streamWithLegacyRoute();
-						return;
-					}
-					throw signalError;
 				}
+				throw signalError;
 			}
 			throw error;
 		}
@@ -2377,6 +2439,7 @@ const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContex
 		});
 		closeThreadSubscription();
 		setMessages((prev) => finishStreamingAssistantMessage(prev));
+		liveRunFinished.current = true;
 		pendingToolApprovalIdsRef.current.clear();
 		setIsAwaitingToolApproval(false);
 		setIsRunning(false);
@@ -2408,6 +2471,8 @@ const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContex
 					...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);
@@ -2466,6 +2531,8 @@ const useChat = ({ agentId, resourceId, threadId, initialMessages, requestContex
 					...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);