@assistant-ui/react-ag-ui 0.1.0 → 0.1.2

package/dist/runtime/AgUiThreadController.js

@@ -2,21 +2,27 @@
 import { createAgUiThreadState, reduceAgUiThreadState } from "./agUiThreadState.js";
 import { readMcpAppResourceUri, toolContentText } from "./mcp-tool-result.js";
 import { AG_UI_METADATA_NAMESPACE } from "./types.js";
-import { buildToolApprovalResume, projectAgUiToolApprovals, withSettledToolApprovals, withToolApprovalDecision } from "./adapter/tool-approval.js";
+import { buildToolApprovalResume, preserveToolApprovalDecision, projectAgUiToolApprovals, withSettledToolApprovals, withToolApprovalDecision } from "./adapter/tool-approval.js";
+import { fromAgUiSnapshotMessages, toAgUiMessages, toAgUiTools, withAgUiPartMessageMetadata } from "./adapter/conversions.js";
 import { RunAggregator, isPlainObject, tryParseJSON } from "./adapter/run-aggregator.js";
-import { fromAgUiMessages, toAgUiMessages, toAgUiTools } from "./adapter/conversions.js";
 import { createAgUiSubscriber } from "./adapter/subscriber.js";
+import { createReplayContentMerger, groupReplayToolContent, indexReplayToolOwners, preserveToolResult } from "./adapter/replay-content.js";
 import { fromThreadMessageLike, generateId, isMcpAppUri } from "@assistant-ui/core";
 import { appendToolInteraction, createHistoryWriteChain, createMessageRepositorySession, invokeUserCallback, iterateToolCallParts, mapToolCallPartsDeep } from "@assistant-ui/core/internal";
 import jsonpatch from "fast-json-patch";
-//#region src/runtime/AgUiThreadController.ts
+// src/runtime/AgUiThreadController.ts
 const optimisticPrefix = "__optimistic__";
 const generateOptimisticId = () => `${optimisticPrefix}${generateId()}`;
 const isOptimisticId = (id) => id.startsWith(optimisticPrefix);
 const isResolvedToolCall = (part) => part.type === "tool-call" && "result" in part && part.result !== void 0;
+const hasResolvedToolCalls = (message) => {
+	if (message.role !== "assistant") return false;
+	for (const part of iterateToolCallParts(message.content)) if (isResolvedToolCall(part)) return true;
+	return false;
+};
 const listedPendingToolCallIds = (assistant) => {
 	const ids = assistant.metadata.custom[AG_UI_METADATA_NAMESPACE]?.pendingToolCallIds;
-	return ids?.length ? new Set(ids) : void 0;
+	return ids === void 0 ? void 0 : new Set(ids);
 };
 const withoutPendingToolCallIds = (metadata) => {
 	const namespace = metadata.custom[AG_UI_METADATA_NAMESPACE];
@@ -31,11 +37,62 @@ const withoutPendingToolCallIds = (metadata) => {
 		}
 	};
 };
+const withPendingToolCallIds = (metadata, ids) => ({
+	...metadata,
+	custom: {
+		...metadata.custom,
+		[AG_UI_METADATA_NAMESPACE]: {
+			...metadata.custom[AG_UI_METADATA_NAMESPACE],
+			pendingToolCallIds: [...ids]
+		}
+	}
+});
+const actionableToolCallIds = (message) => {
+	if (message?.role !== "assistant" || message.status?.type !== "requires-action" || message.status.reason !== "tool-calls") return /* @__PURE__ */ new Set();
+	const permitted = listedPendingToolCallIds(message);
+	return new Set(Array.from(iterateToolCallParts(message.content)).filter((part) => !isResolvedToolCall(part) && (!permitted || permitted.has(part.toolCallId))).map((part) => part.toolCallId));
+};
 const isActivityPart = (part) => part.type === "data" && part.name.startsWith("agui-activity/");
 const FALLBACK_USER_STATUS = {
 	type: "complete",
 	reason: "unknown"
 };
+const textOf = (content) => content.flatMap((part) => part.type === "text" ? [part.text] : []).join("");
+/**
+* Swaps `content`'s text parts, in order, for `source`'s. A text part `source`
+* has beyond `content`'s text slots goes after the nearest earlier part of
+* `source` that `content` also has: a tool call by id, another part by its
+* type and position among parts of that type. With none, it goes first.
+*/
+const replaceTextParts = (content, source) => {
+	const texts = source.filter((part) => part.type === "text");
+	const result = [];
+	let used = 0;
+	for (const part of content) if (part.type !== "text") result.push(part);
+	else if (used < texts.length) result.push(texts[used++]);
+	const positionIn = (parts, part) => parts.filter((other) => other.type === part.type).indexOf(part);
+	for (const text of texts.slice(used)) {
+		let anchor = -1;
+		for (let index = source.indexOf(text) - 1; index >= 0 && anchor < 0; index--) {
+			const before = source[index];
+			if (before.type === "tool-call") anchor = result.findIndex((part) => part.type === "tool-call" && part.toolCallId === before.toolCallId);
+			else if (before.type === "text") anchor = result.indexOf(before);
+			else {
+				const match = result.filter((part) => part.type === before.type)[positionIn(source, before)];
+				anchor = match ? result.indexOf(match) : -1;
+			}
+		}
+		result.splice(anchor + 1, 0, text);
+	}
+	return result;
+};
+const settleNestedContent = (content, status) => mapToolCallPartsDeep(content, (part) => part.messages ? {
+	...part,
+	messages: part.messages.map((message) => message.role === "assistant" && message.status?.type === "running" ? {
+		...message,
+		status
+	} : message)
+} : part).content;
 const invokeRuntimeCallback = (name, callback, ...args) => {
 	invokeUserCallback("react-ag-ui", name, callback, ...args);
 };
@@ -86,6 +143,7 @@ var AgUiThreadController = class {
 	activeRunAgent = null;
 	history;
 	assistantHistoryParents = /* @__PURE__ */ new Map();
+	subagentParentToolCallIds = /* @__PURE__ */ new Map();
 	snapshotHistoryIds = /* @__PURE__ */ new Set();
 	persistedHistoryIds = /* @__PURE__ */ new Set();
 	historyWrites = createHistoryWriteChain();
@@ -167,6 +225,7 @@ var AgUiThreadController = class {
 			if (!repo) return;
 			this.session.applyExternalMessageRepository(repo);
 			this.assistantHistoryParents.clear();
+			this.subagentParentToolCallIds.clear();
 			this.snapshotHistoryIds.clear();
 			this.persistedHistoryIds.clear();
 			for (const { message } of repo.messages) this.persistedHistoryIds.add(message.id);
@@ -299,7 +358,7 @@ var AgUiThreadController = class {
 		const historyImport = this.waitForHistoryImport();
 		if (historyImport && !await historyImport) return;
 		this.assertNoPendingInterrupts();
-		await this.startRun(config.parentId, config.runConfig ?? this.state.lastRunConfig, void 0, config.stream);
+		await this.startRun(config.parentId, config.runConfig ?? this.state.lastRunConfig, void 0, config.stream, true);
 	}
 	async resumeInFlightRun(messages) {
 		const historyImport = this.waitForHistoryImport();
@@ -321,9 +380,7 @@ var AgUiThreadController = class {
 		throw new Error("[agui] cannot start a new run while interrupts are pending; resolve them with submitInterruptResponses()");
 	}
 	findRequiresActionAssistant(reason) {
-		const assistant = this.getMessages().findLast((message) => message.role === "assistant");
-		if (!assistant || assistant.status?.type !== "requires-action" || assistant.status.reason !== reason) return null;
-		return assistant;
+		return this.getTrailingAssistantTurn().findLast((message) => message.status?.type === "requires-action" && message.status.reason === reason) ?? null;
 	}
 	getTrailingAssistantTurn() {
 		const messages = this.getMessages();
@@ -383,8 +440,9 @@ var AgUiThreadController = class {
 	* unretryable.
 	*/
 	async resumeWithResponses(messageId, resume) {
+		const parentId = this.session.headId ?? messageId;
 		this.clearPendingInterrupts(messageId, resume);
-		await this.startRun(messageId, this.state.lastRunConfig, {
+		await this.startRun(parentId, this.state.lastRunConfig, {
 			entries: resume,
 			interruptedMessageId: messageId
 		});
@@ -535,7 +593,10 @@ var AgUiThreadController = class {
 					custom: newCustom
 				}
 			};
-		})) this.publishUpdate();
+		})) {
+			this.publishUpdate();
+			this.persistSettledAssistant(messageId);
+		}
 	}
 	findMessageIdForToolCall(toolCallId) {
 		let fallbackMessageId;
@@ -589,9 +650,31 @@ var AgUiThreadController = class {
 				};
 			});
 			if (!matchedToolCall) return message;
+			const settled = mapToolCallPartsDeep(content, (part) => {
+				if (!part.messages) return part;
+				let changed = false;
+				const messages = part.messages.map((nested) => {
+					if (nested.role !== "assistant" || nested.status.type !== "requires-action" || nested.status.reason !== "tool-calls") return nested;
+					const listed = listedPendingToolCallIds(nested);
+					if (Array.from(iterateToolCallParts(nested.content)).some((call) => !isResolvedToolCall(call) && (!listed || listed.has(call.toolCallId)))) return nested;
+					changed = true;
+					return {
+						...nested,
+						status: {
+							type: "complete",
+							reason: "unknown"
+						},
+						metadata: withoutPendingToolCallIds(nested.metadata)
+					};
+				});
+				return changed ? {
+					...part,
+					messages
+				} : part;
+			}).content;
 			return {
 				...assistant,
-				content
+				content: settled
 			};
 		})) return;
 		this.publishUpdate();
@@ -657,23 +740,27 @@ var AgUiThreadController = class {
 		}
 		this.startResumeRun(parentId);
 	}
-	maybeResumeAfterToolResults(messageId) {
+	maybeResumeAfterToolResults(messageId, accountedResultIds) {
 		if (!this.maybeCompleteAfterToolResults(messageId)) return;
+		if (accountedResultIds) {
+			const message = this.session.tryGetMessage(messageId)?.message;
+			if (message?.role !== "assistant" || !Array.from(iterateToolCallParts(message.content)).some((part) => isResolvedToolCall(part) && !accountedResultIds.has(part.toolCallId))) return;
+		}
 		if (this.getPendingInterrupts()) return;
 		const turn = this.getTrailingAssistantTurn();
 		if (!turn.some((message) => message.id === messageId)) return;
-		if (this.getPendingToolCalls()) return;
-		const headId = turn.at(-1)?.id;
-		if (headId === void 0) return;
 		const owner = this.abortController;
 		if (owner) {
 			this.dispatch({
 				type: "resumeDeferred",
 				owner,
-				messageId: headId
+				messageId
 			});
 			return;
 		}
+		if (this.getPendingToolCalls()) return;
+		const headId = turn.at(-1)?.id;
+		if (headId === void 0) return;
 		this.startResumeRun(headId);
 	}
 	maybeCompleteAfterToolResults(messageId) {
@@ -700,7 +787,8 @@ var AgUiThreadController = class {
 			metadata: withoutPendingToolCallIds(current.metadata)
 		} : current)) return false;
 		this.publishUpdate();
-		this.persistAssistantHistory(messageId);
+		if (this.history?.update) this.persistSettledAssistant(messageId);
+		else this.persistAssistantHistory(messageId);
 		return true;
 	}
 	startResumeRun(messageId) {
@@ -729,6 +817,10 @@ var AgUiThreadController = class {
 			let lastAppliedId = null;
 			let hardReplace = false;
 			const seen = /* @__PURE__ */ new Set();
+			const retainToolResults = (existing, message) => existing?.role === "assistant" && message.role === "assistant" ? {
+				...message,
+				content: this.preserveToolResults(existing.content, message.content)
+			} : message;
 			for (const message of messages) {
 				if (seen.has(message.id)) continue;
 				seen.add(message.id);
@@ -737,11 +829,12 @@ var AgUiThreadController = class {
 					hardReplace = true;
 					break;
 				}
-				this.session.addOrUpdateMessage(expectedParentId, message);
+				this.session.addOrUpdateMessage(expectedParentId, retainToolResults(existing?.message, message));
 				expectedParentId = message.id;
 				lastAppliedId = message.id;
 			}
 			if (hardReplace) {
+				const previous = new Map(this.getMessageRepository().messages.map(({ message }) => [message.id, message]));
 				this.session.clear();
 				expectedParentId = null;
 				lastAppliedId = null;
@@ -749,17 +842,29 @@ var AgUiThreadController = class {
 				for (const message of messages) {
 					if (seen.has(message.id)) continue;
 					seen.add(message.id);
-					this.session.addOrUpdateMessage(expectedParentId, message);
+					this.session.addOrUpdateMessage(expectedParentId, retainToolResults(previous.get(message.id), message));
 					expectedParentId = message.id;
 					lastAppliedId = message.id;
 				}
 			}
 			this.session.resetHead(lastAppliedId);
+			for (const messageId of seen) this.maybeCompleteAfterToolResults(messageId);
 		}
 		this.snapshotHistoryIds.clear();
 		for (const { message } of this.getMessageRepository().messages) this.snapshotHistoryIds.add(message.id);
-		const resumeTarget = this.state.pendingResume?.messageId;
-		if (resumeTarget !== void 0 && !this.session.getMessages().some((message) => message.id === resumeTarget)) this.dispatch({ type: "resumeCleared" });
+		const pendingResume = this.state.pendingResume;
+		if (pendingResume) {
+			const selectedResultOwnerIds = new Set(this.session.getMessages().filter(hasResolvedToolCalls).map((message) => message.id));
+			const retained = pendingResume.messageIds.filter((id) => selectedResultOwnerIds.has(id));
+			if (retained.length !== pendingResume.messageIds.length) {
+				this.dispatch({ type: "resumeCleared" });
+				for (const messageId of retained) this.dispatch({
+					type: "resumeDeferred",
+					owner: pendingResume.owner,
+					messageId
+				});
+			}
+		}
 		this.publishUpdate();
 	}
 	loadExternalState(state) {
@@ -786,6 +891,7 @@ var AgUiThreadController = class {
 		const controller = this.abortController;
 		const activeRunAgent = this.activeRunAgent;
 		this.dispatch({ type: "resetThread" });
+		this.subagentParentToolCallIds.clear();
 		if (controller) {
 			this.abortController = null;
 			this.activeRunAgent = null;
@@ -799,9 +905,10 @@ var AgUiThreadController = class {
 			}
 		} else this.publishUpdate();
 	}
-	async startRun(parentId, runConfig, resume, resumeStream) {
+	async startRun(parentId, runConfig, resume, resumeStream, replayExistingMessages = false) {
 		if (this.isThreadSwitching?.()) return;
 		if (!this.supersedeActiveRun()) return;
+		const generation = this.state.historyMutationGeneration;
 		const normalizedRunConfig = runConfig ?? {};
 		this.dispatch({
 			type: "runConfigRecorded",
@@ -811,36 +918,79 @@ var AgUiThreadController = class {
 		const shouldEagerlyInsertAssistant = parentId !== null && parent !== void 0 && parentId !== this.session.headId;
 		const historicalMessages = [...shouldEagerlyInsertAssistant ? this.session.tryGetMessages(parentId) ?? this.session.getMessages() : this.session.getMessages()];
 		const runStartMessageIds = new Set(this.getMessageRepository().messages.map(({ message }) => message.id));
+		const selectedMessages = this.session.getMessages();
+		const parentIndex = selectedMessages.findIndex((message) => message.id === parentId);
+		let replayStart = parentIndex + 1;
+		if (selectedMessages[parentIndex]?.role === "assistant") {
+			replayStart = parentIndex;
+			while (replayStart > 0 && selectedMessages[replayStart - 1]?.role === "assistant") replayStart--;
+		}
+		const replayMessageIds = [];
+		if (replayExistingMessages && !resumeStream && parentIndex >= 0) for (const message of selectedMessages.slice(replayStart)) {
+			if (message.role !== "assistant") break;
+			replayMessageIds.push(message.id);
+		}
+		const accountedResultIds = new Set(historicalMessages.flatMap((message) => message.role === "assistant" ? Array.from(iterateToolCallParts(message.content)).filter(isResolvedToolCall).map((part) => part.toolCallId) : []));
+		const candidateContexts = /* @__PURE__ */ new Map();
+		for (const message of selectedMessages) {
+			if (message.role !== "assistant" || !replayMessageIds.includes(message.id)) continue;
+			candidateContexts.set(message.id, {
+				originalContent: message.content,
+				accountedResultIds,
+				admittedToolCallIds: actionableToolCallIds(message),
+				merge: createReplayContentMerger()
+			});
+		}
+		let replayContexts = /* @__PURE__ */ new Map();
+		let lastReplayedIndex = -1;
+		let replayEnded = replayMessageIds.length === 0;
+		const replayTail = replayMessageIds.at(-1);
 		const joinStrategy = this.joinStrategy;
 		const hasRunUserBoundary = parent?.message.role === "user" && !resume;
 		let pendingError = null;
 		const assistantParentId = parent ? parentId : this.session.headId;
 		let assistantMessageId;
+		let snapshotAssistantId;
+		let replayInterruptMessageId;
 		let assistantCollided = false;
 		const heldMessages = /* @__PURE__ */ new Map();
+		let frameOwnerIds = /* @__PURE__ */ new Set();
 		let restrictedPendingToolCallIds;
 		let settlingRun = false;
+		let latestSnapshot;
+		let snapshotToolCallIds = /* @__PURE__ */ new Set();
 		const ensureAssistant = (allowRecreate = false) => {
 			const cached = assistantMessageId;
 			if (cached !== void 0 && this.session.tryGetMessage(cached)) return cached;
 			if (cached !== void 0 && (assistantCollided || !allowRecreate)) return cached;
 			const repositoryHeadId = this.session.headId;
-			const parentId = (cached === void 0 || shouldEagerlyInsertAssistant && (repositoryHeadId === null || runStartMessageIds.has(repositoryHeadId))) && assistantParentId && this.session.hasMessage(assistantParentId) ? assistantParentId : repositoryHeadId;
+			const parentId = replayContexts.size === 0 && (cached === void 0 || shouldEagerlyInsertAssistant && (repositoryHeadId === null || runStartMessageIds.has(repositoryHeadId))) && (replayMessageIds.length === 0 || repositoryHeadId === null || runStartMessageIds.has(repositoryHeadId)) && assistantParentId && this.session.hasMessage(assistantParentId) ? assistantParentId : repositoryHeadId;
 			const created = this.insertAssistantPlaceholder(parentId, cached);
 			assistantMessageId = created;
 			this.markPendingAssistantHistory(created, parentId);
 			return created;
 		};
-		if (shouldEagerlyInsertAssistant) ensureAssistant();
+		if (shouldEagerlyInsertAssistant && replayEnded) ensureAssistant();
 		const settleHeldMessages = (terminalStatus) => {
 			const pendingMessages = [];
+			const producerPending = restrictedPendingToolCallIds;
+			const canWaitForTools = terminalStatus.type === "complete" || terminalStatus.type === "requires-action";
+			if (producerPending && canWaitForTools) for (const message of this.getTrailingAssistantTurn()) {
+				const replay = replayContexts.get(message.id);
+				if (message.id === assistantMessageId || heldMessages.has(message.id) || !replay || message.status?.type === "requires-action" && message.status.reason === "interrupt") continue;
+				if (replay.admittedToolCallIds.size > 0 || actionableToolCallIds(message).size > 0 || Array.from(iterateToolCallParts(message.content)).some((part) => producerPending.has(part.toolCallId) && !accountedResultIds.has(part.toolCallId))) heldMessages.set(message.id, /* @__PURE__ */ new Set());
+			}
 			for (const [messageId, openToolCallIds] of heldMessages) {
+				const existing = this.session.tryGetMessage(messageId);
+				if (existing) this.markPendingAssistantHistory(messageId, existing.parentId);
 				let requiresToolResult = false;
 				if (this.session.updateMessage(messageId, (message) => {
 					if (message.role !== "assistant") return message;
 					const assistant = message;
-					const pendingToolCallIds = Array.from(openToolCallIds).filter((id) => !restrictedPendingToolCallIds || restrictedPendingToolCallIds.has(id));
-					const status = terminalStatus.type === "complete" || terminalStatus.type === "requires-action" ? pendingToolCallIds.length > 0 ? {
+					const pendingToolCallIds = producerPending ? Array.from(iterateToolCallParts(assistant.content)).filter((part) => producerPending.has(part.toolCallId) && (!isResolvedToolCall(part) || openToolCallIds.has(part.toolCallId) || replayContexts.has(messageId) && !accountedResultIds.has(part.toolCallId))).map((part) => part.toolCallId) : Array.from(openToolCallIds);
+					const replay = replayContexts.get(messageId);
+					if (replay) replay.admittedToolCallIds = new Set(pendingToolCallIds);
+					const status = canWaitForTools ? pendingToolCallIds.length > 0 ? {
 						type: "requires-action",
 						reason: "tool-calls"
 					} : {
@@ -852,16 +1002,7 @@ var AgUiThreadController = class {
 					return {
 						...assistant,
 						status,
-						metadata: status.type === "requires-action" && restrictedPendingToolCallIds ? {
-							...metadata,
-							custom: {
-								...metadata.custom,
-								["agui"]: {
-									...metadata.custom["agui"],
-									pendingToolCallIds
-								}
-							}
-						} : metadata
+						metadata: status.type === "requires-action" && (restrictedPendingToolCallIds || replayContexts.has(messageId)) ? withPendingToolCallIds(metadata, pendingToolCallIds) : metadata
 					};
 				})) {
 					this.publishUpdate();
@@ -872,29 +1013,139 @@ var AgUiThreadController = class {
 			heldMessages.clear();
 			return pendingMessages;
 		};
+		const accountProducerResults = (content) => {
+			for (const part of iterateToolCallParts(content)) if (isResolvedToolCall(part)) accountedResultIds.add(part.toolCallId);
+		};
+		const reconcileReplaySnapshot = (snapshot, previous) => {
+			accountProducerResults(snapshot.content);
+			const replay = candidateContexts.get(snapshot.id);
+			if (!replay) return snapshot;
+			replay.admittedToolCallIds = actionableToolCallIds(snapshot);
+			if (heldMessages.has(snapshot.id)) heldMessages.set(snapshot.id, new Set(replay.admittedToolCallIds));
+			if (!replayContexts.has(snapshot.id)) return snapshot;
+			return previous ? {
+				...snapshot,
+				content: this.preserveToolResults(previous.content, snapshot.content, replay.originalContent)
+			} : snapshot;
+		};
 		const applyUpdate = (update) => {
+			if (!assistantCollided && replayContexts.size && update.content !== void 0) accountProducerResults(update.content);
+			let ownerParts;
+			let contentOwnerIds;
+			const hasStreamContent = Array.isArray(update.content) && update.content.some((part) => part.type !== "data");
+			if (!replayEnded && assistantMessageId === void 0) {
+				if (!update.status || update.status.type === "running") return;
+				replayEnded = true;
+				if (replayContexts.size === 0 && snapshotAssistantId !== void 0 && this.session.headId === snapshotAssistantId && !hasStreamContent) {
+					if (update.status.type !== "complete") this.updateAssistantMessage(snapshotAssistantId, {
+						status: update.status,
+						...update.metadata ? { metadata: update.metadata } : {}
+					});
+					return;
+				}
+			}
+			const streamMessageId = assistantMessageId;
+			let primaryMessageId = streamMessageId;
 			const terminalStatus = update.status;
+			const replayInterrupt = replayContexts.size > 0 && terminalStatus?.type === "requires-action" && terminalStatus.reason === "interrupt";
+			if (streamMessageId !== void 0 && !assistantCollided && replayContexts.size > 0 && (update.content !== void 0 || replayInterrupt)) {
+				const owners = this.getTrailingAssistantTurn().filter((message) => replayContexts.has(message.id));
+				const grouped = update.content !== void 0 ? groupReplayToolContent(owners, update.content, streamMessageId) : /* @__PURE__ */ new Map([[streamMessageId, [...update.content ?? []]]]);
+				if (update.content !== void 0) {
+					const currentOwnerIds = new Set(grouped.keys());
+					for (const ownerId of frameOwnerIds) grouped.set(ownerId, grouped.get(ownerId) ?? []);
+					contentOwnerIds = new Set(grouped.keys());
+					frameOwnerIds = currentOwnerIds;
+				}
+				ownerParts = grouped;
+				if (replayInterrupt) {
+					const interrupts = (update.metadata?.custom?.[AG_UI_METADATA_NAMESPACE])?.interrupts;
+					const approvals = projectAgUiToolApprovals(interrupts);
+					for (const owner of owners) if (Array.from(iterateToolCallParts(owner.content)).some((part) => approvals.has(part.toolCallId))) grouped.set(owner.id, grouped.get(owner.id) ?? []);
+					const anchor = owners.find((message) => projectAgUiToolApprovals(interrupts, new Set(Array.from(iterateToolCallParts([...message.content, ...grouped.get(message.id) ?? []])).map((part) => part.toolCallId))).size > 0);
+					if (anchor) {
+						primaryMessageId = anchor.id;
+						replayInterruptMessageId = anchor.id;
+						grouped.set(anchor.id, grouped.get(anchor.id) ?? []);
+					}
+				}
+			}
 			const pendingMessages = settlingRun && terminalStatus && terminalStatus.type !== "running" ? settleHeldMessages(terminalStatus) : [];
-			const hasStreamContent = Array.isArray(update.content) && update.content.some((part) => part.type !== "data");
-			const resolved = this.updateAssistantMessage(ensureAssistant(hasStreamContent), update);
-			if (resolved !== assistantMessageId) assistantMessageId = resolved;
-			for (const messageId of pendingMessages) this.maybeResumeAfterToolResults(messageId);
+			const frameMessageId = ensureAssistant(hasStreamContent);
+			const messageId = primaryMessageId ?? frameMessageId;
+			let primaryUpdate = update;
+			if (ownerParts) {
+				const interrupt = terminalStatus?.type === "requires-action" && terminalStatus.reason === "interrupt";
+				const ownerStatus = terminalStatus?.type === "requires-action" ? {
+					type: "complete",
+					reason: "unknown"
+				} : terminalStatus;
+				for (const [ownerId, content] of ownerParts) {
+					const existing = this.session.tryGetMessage(ownerId);
+					if (existing) this.markPendingAssistantHistory(ownerId, existing.parentId);
+					if (ownerId === messageId) continue;
+					this.updateAssistantMessage(ownerId, {
+						...contentOwnerIds?.has(ownerId) ? { content } : {},
+						...ownerStatus ? { status: ownerStatus } : {}
+					}, replayContexts.get(ownerId), interrupt ? /* @__PURE__ */ new Set() : restrictedPendingToolCallIds);
+				}
+				const { content: _content, ...controlUpdate } = update;
+				const content = ownerParts.get(messageId) ?? [];
+				primaryUpdate = {
+					...controlUpdate,
+					...contentOwnerIds?.has(messageId) ? { content } : {},
+					...ownerStatus && !interrupt && replayContexts.has(messageId) ? { status: ownerStatus } : {}
+				};
+			}
+			const resolved = this.updateAssistantMessage(messageId, primaryUpdate, replayContexts.get(messageId), restrictedPendingToolCallIds);
+			if (messageId === frameMessageId && resolved !== assistantMessageId) assistantMessageId = resolved;
+			for (const messageId of pendingMessages) this.maybeResumeAfterToolResults(messageId, replayMessageIds.includes(messageId) ? accountedResultIds : void 0);
 		};
 		const adoptServerMessageId = (serverId, startNewMessage, openToolCallIds = []) => {
+			const existing = this.session.tryGetMessage(serverId);
+			const replayIndex = replayMessageIds.indexOf(serverId);
+			const adoptsReplay = !replayEnded && !assistantCollided && replayIndex > lastReplayedIndex && existing?.message.role === "assistant" && this.session.getMessages().some((message) => message.id === serverId);
+			if (adoptsReplay && replayContexts.size === 0) {
+				replayContexts = candidateContexts;
+				const selected = this.session.getMessages();
+				let tailId = serverId;
+				for (const message of selected.slice(selected.findIndex((message) => message.id === serverId) + 1)) {
+					if (message.role !== "assistant") break;
+					tailId = message.id;
+				}
+				this.session.selectHead(tailId);
+			}
 			if (startNewMessage && assistantMessageId !== void 0) {
-				if (openToolCallIds.length > 0) heldMessages.set(assistantMessageId, new Set(openToolCallIds));
+				let hasReplayCallsToHold = false;
+				const replay = replayContexts.get(assistantMessageId);
+				if (replay) {
+					const current = this.session.tryGetMessage(assistantMessageId)?.message;
+					if (current?.role === "assistant") {
+						const retainedPending = Array.from(iterateToolCallParts(current.content)).filter((part) => !isResolvedToolCall(part) || replay.admittedToolCallIds.has(part.toolCallId) && !accountedResultIds.has(part.toolCallId));
+						hasReplayCallsToHold = retainedPending.length > 0;
+						openToolCallIds = [.../* @__PURE__ */ new Set([...openToolCallIds, ...retainedPending.filter((part) => replay.admittedToolCallIds.has(part.toolCallId)).map((part) => part.toolCallId)])];
+					}
+				}
+				if (openToolCallIds.length > 0 || hasReplayCallsToHold) heldMessages.set(assistantMessageId, new Set(openToolCallIds));
 				else applyUpdate({ status: {
 					type: "complete",
 					reason: "unknown"
 				} });
 				const previousId = assistantMessageId;
 				assistantMessageId = void 0;
-				if (this.session.tryGetMessage(previousId)) {
+				if (!adoptsReplay && this.session.tryGetMessage(previousId)) {
 					const created = this.insertAssistantPlaceholder(previousId);
 					assistantMessageId = created;
 					this.markPendingAssistantHistory(created, previousId);
 				}
 			}
+			if (adoptsReplay) {
+				assistantMessageId = serverId;
+				lastReplayedIndex = replayIndex;
+				this.markPendingAssistantHistory(serverId, existing.parentId);
+				return;
+			}
+			replayEnded = true;
 			const placeholder = ensureAssistant(true);
 			if (placeholder === serverId) return;
 			const reassigned = this.reassignAssistantId(placeholder, serverId);
@@ -913,25 +1164,103 @@ var AgUiThreadController = class {
 			showThinking: this.showThinking,
 			joinStrategy,
 			logger: this.logger,
-			emit: applyUpdate,
+			emit: (update) => {
+				const currentSnapshotAssistant = assistantMessageId === void 0 ? void 0 : this.session.tryGetMessage(assistantMessageId)?.message;
+				const listedSnapshotToolCallIds = currentSnapshotAssistant?.role === "assistant" ? listedPendingToolCallIds(currentSnapshotAssistant) : void 0;
+				const hasPendingSnapshotToolCall = latestSnapshot?.id === assistantMessageId && currentSnapshotAssistant?.role === "assistant" && Array.from(iterateToolCallParts(currentSnapshotAssistant.content)).some((part) => !isResolvedToolCall(part) && (!listedSnapshotToolCallIds || listedSnapshotToolCallIds.has(part.toolCallId)) && (!restrictedPendingToolCallIds || restrictedPendingToolCallIds.has(part.toolCallId)));
+				const reconciledUpdate = settlingRun && update.status?.type === "complete" && hasPendingSnapshotToolCall ? {
+					...update,
+					status: {
+						type: "requires-action",
+						reason: "tool-calls"
+					},
+					...restrictedPendingToolCallIds ? { metadata: {
+						...update.metadata,
+						custom: {
+							...update.metadata?.custom,
+							[AG_UI_METADATA_NAMESPACE]: {
+								...update.metadata?.custom?.[AG_UI_METADATA_NAMESPACE],
+								pendingToolCallIds: [...restrictedPendingToolCallIds]
+							}
+						}
+					} } : {}
+				} : update;
+				if (settlingRun && latestSnapshot && latestSnapshot.id === assistantMessageId && reconciledUpdate.status && reconciledUpdate.status.type !== "running" && reconciledUpdate.status.type !== "requires-action") {
+					const status = reconciledUpdate.status;
+					const current = this.session.tryGetMessage(assistantMessageId)?.message;
+					const content = settleNestedContent(current?.role === "assistant" ? current.content : latestSnapshot.content, status);
+					applyUpdate({
+						...reconciledUpdate,
+						content
+					});
+				} else if (latestSnapshot && latestSnapshot.id === assistantMessageId && reconciledUpdate.content !== void 0) {
+					const content = this.mergeSnapshotAssistantContent(latestSnapshot.content, reconciledUpdate.content, reconciledUpdate.content.some((part) => part.type === "reasoning"), reconciledUpdate.content.some(isActivityPart), snapshotToolCallIds);
+					applyUpdate({
+						...reconciledUpdate,
+						content
+					});
+				} else applyUpdate(reconciledUpdate);
+				const current = assistantMessageId ? this.session.tryGetMessage(assistantMessageId)?.message : void 0;
+				latestSnapshot = !settlingRun && current?.role === "assistant" && current.id === latestSnapshot?.id ? current : void 0;
+			},
 			onServerMessageId: (serverId) => {
 				adoptServerMessageId(serverId, false);
 			},
-			onTextMessageStart: (serverId, openToolCallIds) => adoptServerMessageId(serverId, true, openToolCallIds)
+			onTextMessageStart: (serverId, openToolCallIds) => {
+				const owners = this.getTrailingAssistantTurn().filter((message) => replayContexts.has(message.id));
+				const toolOwners = indexReplayToolOwners(owners);
+				const frameOpenIds = openToolCallIds.filter((id) => {
+					const ownerId = toolOwners.get(id);
+					if (!ownerId || ownerId === assistantMessageId || assistantCollided) return true;
+					const held = heldMessages.get(ownerId) ?? /* @__PURE__ */ new Set();
+					held.add(id);
+					heldMessages.set(ownerId, held);
+					return false;
+				});
+				for (const ownerId of frameOwnerIds) {
+					const replay = replayContexts.get(ownerId);
+					if (replay) replay.merge = createReplayContentMerger();
+				}
+				frameOwnerIds.clear();
+				adoptServerMessageId(serverId, true, frameOpenIds);
+			}
 		});
 		let runFinished = false;
 		const dispatch = (event) => {
 			if (this.abortController !== abortController) return;
 			if (event.type === "RUN_FINISHED") {
 				runFinished = true;
+				if (event.outcome?.type === "interrupt") replayInterruptMessageId = assistantMessageId ?? replayTail;
 				const ids = event.outcome?.type === "success" ? event.outcome.pendingToolCallIds : void 0;
-				restrictedPendingToolCallIds = ids?.length ? new Set(ids) : void 0;
+				restrictedPendingToolCallIds = ids === void 0 ? void 0 : new Set(ids);
+			}
+			if (event.type === "TOOL_CALL_RESULT") {
+				if (!assistantCollided && candidateContexts.size) accountedResultIds.add(event.toolCallId);
+				for (const openToolCallIds of heldMessages.values()) openToolCallIds.delete(event.toolCallId);
 			}
-			if (event.type === "TOOL_CALL_RESULT") for (const openToolCallIds of heldMessages.values()) openToolCallIds.delete(event.toolCallId);
 			settlingRun = event.type === "RUN_FINISHED" || event.type === "RUN_ERROR" || event.type === "RUN_CANCELLED";
+			const beforeSnapshot = event.type === "MESSAGES_SNAPSHOT" ? this.session.getMessages() : [];
 			try {
-				const nextAssistantMessageId = this.handleEvent(aggregator, event, assistantMessageId, joinStrategy, runStartMessageIds, hasRunUserBoundary);
-				if (event.type === "MESSAGES_SNAPSHOT") assistantMessageId = nextAssistantMessageId;
+				const nextAssistantMessageId = this.handleEvent(aggregator, event, assistantMessageId, joinStrategy, runStartMessageIds, hasRunUserBoundary, candidateContexts.size ? reconcileReplaySnapshot : void 0);
+				if (event.type === "MESSAGES_SNAPSHOT") {
+					for (const message of beforeSnapshot) {
+						const context = replayContexts.get(message.id);
+						const current = this.session.tryGetMessage(message.id)?.message;
+						if (context && current?.content !== message.content) {
+							context.merge = createReplayContentMerger();
+							frameOwnerIds.delete(message.id);
+						}
+					}
+					assistantMessageId = nextAssistantMessageId;
+					const imported = assistantMessageId ? this.session.tryGetMessage(assistantMessageId)?.message : void 0;
+					const source = event.messages.find((message) => message?.role === "assistant" && message.id === imported?.id);
+					latestSnapshot = imported?.role === "assistant" && source ? imported : void 0;
+					snapshotToolCallIds = new Set(Array.isArray(source?.toolCalls) ? source.toolCalls.map((call) => call.id).filter((id) => typeof id === "string") : []);
+					if (!replayEnded && assistantMessageId === void 0) {
+						const tail = this.session.getMessages().at(-1);
+						snapshotAssistantId = tail?.role === "assistant" ? tail.id : void 0;
+					}
+				}
 			} finally {
 				settlingRun = false;
 			}
@@ -974,7 +1303,6 @@ var AgUiThreadController = class {
 				const input = this.buildRunInput(runId, normalizedRunConfig, historicalMessages, resume);
 				const subscriber = createAgUiSubscriber({
 					dispatch,
-					runId,
 					logger: this.logger,
 					onRunFailed: (error) => {
 						if (abortSignal.aborted) return;
@@ -985,7 +1313,7 @@ var AgUiThreadController = class {
 				try {
 					runAgentInstance.messages = input.messages;
 					runAgentInstance.threadId = input.threadId;
-					runAgentInstance.state = input.state ?? null;
+					runAgentInstance.state = input.state;
 				} catch {}
 				await runAgentInstance.runAgent.bind(runAgentInstance)(input, subscriber, { signal: abortSignal });
 			}
@@ -1000,6 +1328,19 @@ var AgUiThreadController = class {
 				pendingError = err;
 			}
 		} finally {
+			const current = assistantMessageId ? this.session.tryGetMessage(assistantMessageId)?.message : void 0;
+			if (this.abortController === abortController && current?.role === "assistant" && current.status?.type === "running") {
+				const status = {
+					type: "incomplete",
+					reason: "error",
+					error: "The connection ended before the answer finished."
+				};
+				settleHeldMessages(status);
+				applyUpdate({
+					status,
+					content: settleNestedContent(current.content, status)
+				});
+			}
 			this.finishRun(abortController);
 		}
 		if (pendingError) {
@@ -1008,10 +1349,40 @@ var AgUiThreadController = class {
 			this.clearDeferredContinuations(abortController);
 			throw err;
 		}
+		const pending = replayInterruptMessageId ? this.getPendingInterrupts() : null;
+		if (pending && pending.messageId === replayInterruptMessageId && replayContexts.has(pending.messageId) && !abortSignal.aborted && this.abortController === null && generation === this.state.historyMutationGeneration && !this.isThreadSwitching?.()) {
+			const message = this.session.tryGetMessage(pending.messageId)?.message;
+			const responses = message?.role === "assistant" ? buildToolApprovalResume(message.content, pending.interrupts) : null;
+			if (responses) {
+				this.clearDeferredContinuations(abortController);
+				try {
+					await this.submitInterruptResponses(responses);
+				} catch (error) {
+					const err = error instanceof Error ? error : new Error(String(error));
+					if (!this.reportedErrors.has(err)) {
+						this.reportError(err);
+						this.reportedErrors.add(err);
+					}
+					throw err;
+				}
+				return;
+			}
+		}
 		if (this.state.pendingResume?.owner === abortController) {
-			const { messageId } = this.state.pendingResume;
+			const { messageIds } = this.state.pendingResume;
 			this.dispatch({ type: "resumeCleared" });
-			if (!abortSignal.aborted) this.startResumeRun(messageId);
+			if (!abortSignal.aborted && !this.getPendingInterrupts() && !this.getPendingToolCalls()) {
+				const turn = this.getTrailingAssistantTurn();
+				if (turn.some((message) => {
+					if (!messageIds.includes(message.id)) return false;
+					const replay = replayContexts.get(message.id);
+					if (!replay) return hasResolvedToolCalls(message);
+					return Array.from(iterateToolCallParts(message.content)).some((part) => isResolvedToolCall(part) && replay.admittedToolCallIds.has(part.toolCallId) && !accountedResultIds.has(part.toolCallId));
+				})) {
+					const headId = turn.at(-1)?.id;
+					if (headId !== void 0) this.startResumeRun(headId);
+				}
+			}
 		}
 		if (this.state.pendingA2uiResumeOwner === abortController) {
 			this.dispatch({ type: "a2uiResumeCleared" });
@@ -1092,7 +1463,7 @@ var AgUiThreadController = class {
 		return {
 			threadId,
 			runId,
-			state: this.state.stateSnapshot ?? null,
+			state: this.state.stateSnapshot === void 0 ? {} : this.state.stateSnapshot,
 			messages,
 			tools: toAgUiTools(context?.tools),
 			context: [...context?.system ? [{
@@ -1194,15 +1565,47 @@ var AgUiThreadController = class {
 		this.publishUpdate();
 		return !collidesWithExisting;
 	}
-	updateAssistantMessage(messageId, update) {
+	updateAssistantMessage(messageId, update, replay, pendingToolCallIds) {
 		let latestStatus;
 		if (!this.session.updateMessage(messageId, (message) => {
 			if (message.role !== "assistant") return message;
 			const assistant = message;
 			const mergedMetadata = update.metadata ? this.mergeAssistantMetadata(assistant.metadata, update.metadata) : assistant.metadata;
 			latestStatus = update.status ?? assistant.status;
-			const metadata = latestStatus?.type === "requires-action" && latestStatus.reason === "tool-calls" ? mergedMetadata : withoutPendingToolCallIds(mergedMetadata);
-			const content = update.content !== void 0 ? this.preserveToolResults(assistant.content, update.content) : assistant.content;
+			let content = update.content !== void 0 ? replay ? replay.merge(assistant.content, update.content) : this.preserveToolResults(assistant.content, update.content) : assistant.content;
+			const calls = replay ? Array.from(iterateToolCallParts(content)) : [];
+			const pending = pendingToolCallIds ?? (replay ? /* @__PURE__ */ new Set([...replay.admittedToolCallIds, ...Array.from(iterateToolCallParts(update.content ?? [])).filter((part) => !isResolvedToolCall(part)).map((part) => part.toolCallId)]) : void 0);
+			if (replay && latestStatus?.type !== "running" && pending) replay.admittedToolCallIds = pending;
+			if (replay) {
+				const interrupts = latestStatus?.type === "requires-action" && latestStatus.reason === "interrupt" ? mergedMetadata.custom["agui"]?.interrupts : void 0;
+				const approvals = projectAgUiToolApprovals(interrupts, new Set(calls.map((part) => part.toolCallId)));
+				const originalCalls = new Map(Array.from(iterateToolCallParts(replay.originalContent), (part) => [part.toolCallId, part]));
+				content = mapToolCallPartsDeep(content, (part) => {
+					const approval = approvals.get(part.toolCallId);
+					if (approval) return {
+						...part,
+						approval: preserveToolApprovalDecision(originalCalls.get(part.toolCallId), {
+							...part,
+							approval
+						}) ?? approval
+					};
+					if (!part.approval || part.approval.approved !== void 0 || part.approval.resolution) return part;
+					const { approval: _approval, ...withoutApproval } = part;
+					return withoutApproval;
+				}).content;
+			}
+			if (replay && latestStatus?.type === "complete") {
+				const listed = pending ?? listedPendingToolCallIds({
+					...assistant,
+					metadata: mergedMetadata
+				});
+				if (calls.some((part) => (!isResolvedToolCall(part) || !replay.accountedResultIds.has(part.toolCallId)) && (!listed || listed.has(part.toolCallId)))) latestStatus = {
+					type: "requires-action",
+					reason: "tool-calls"
+				};
+			}
+			const admission = pending && replay ? withPendingToolCallIds(mergedMetadata, pending) : mergedMetadata;
+			const metadata = latestStatus?.type === "requires-action" && latestStatus.reason === "tool-calls" ? admission : replay && latestStatus?.type === "running" ? mergedMetadata : withoutPendingToolCallIds(admission);
 			return {
 				...assistant,
 				content,
@@ -1217,24 +1620,25 @@ var AgUiThreadController = class {
 			resolvedMessageId = stableId;
 		} else this.publishUpdate();
 		if (this.isPersistableStatus(latestStatus)) this.persistAssistantHistory(resolvedMessageId);
-		this.maybeResumeAfterToolResults(resolvedMessageId);
+		this.maybeResumeAfterToolResults(resolvedMessageId, replay?.accountedResultIds);
 		return resolvedMessageId;
 	}
-	preserveToolResults(previous, next) {
+	preserveToolResults(previous, next, decisionSource) {
 		const preserved = /* @__PURE__ */ new Map();
 		for (const part of iterateToolCallParts(previous)) if (isResolvedToolCall(part)) preserved.set(part.toolCallId, part);
-		if (preserved.size === 0) return this.preserveToolInteractions(previous, next);
+		const decisions = new Map(Array.from(iterateToolCallParts(decisionSource ?? [])).filter((part) => part.approval?.approved !== void 0).map((part) => [part.toolCallId, part]));
+		if (preserved.size === 0 && decisions.size === 0) return this.preserveToolInteractions(previous, next);
 		const { content: merged, changed } = mapToolCallPartsDeep(next, (part) => {
 			const prior = preserved.get(part.toolCallId);
-			if (!prior) return part;
-			if (!isResolvedToolCall(part) && isResolvedToolCall(prior)) return {
-				...part,
-				result: prior.result,
-				...prior.artifact !== void 0 ? { artifact: prior.artifact } : {},
-				...prior.isError !== void 0 ? { isError: prior.isError } : {},
-				...prior.modelContent !== void 0 ? { modelContent: prior.modelContent } : {}
-			};
-			return part;
+			const result = prior ? preserveToolResult(prior, part) : part;
+			if (result.approval && decisions.has(part.toolCallId)) {
+				const approval = preserveToolApprovalDecision(decisions.get(part.toolCallId), result);
+				if (approval && approval !== result.approval) return {
+					...result,
+					approval
+				};
+			}
+			return result;
 		});
 		return this.preserveToolInteractions(previous, changed ? merged : next);
 	}
@@ -1252,10 +1656,10 @@ var AgUiThreadController = class {
 		});
 		return changed ? content : next;
 	}
-	mergeSnapshotAssistantContent(previous, next, snapshotHasReasoning, snapshotHasActivity) {
-		const shouldKeep = (part) => part.type === "reasoning" ? this.showThinking && !snapshotHasReasoning : isActivityPart(part) && !snapshotHasActivity;
+	mergeSnapshotAssistantContent(previous, next, snapshotHasReasoning, snapshotHasActivity, keepMissingToolCalls = /* @__PURE__ */ new Set(), keepPriorTranscripts = false) {
+		const shouldKeep = (part) => part.type === "tool-call" ? keepMissingToolCalls.has(part.toolCallId) && !next.some((incoming) => incoming.type === "tool-call" && incoming.toolCallId === part.toolCallId) : part.type === "reasoning" ? this.showThinking && !snapshotHasReasoning : part.type === "data" && !isActivityPart(part) ? !next.some((incoming) => incoming.type === "data" && incoming.name === part.name) : isActivityPart(part) && !snapshotHasActivity;
 		const kept = previous.filter(shouldKeep);
-		const merged = this.reconcileSnapshotNestedContent(previous, this.preserveToolInteractions(previous, next));
+		const merged = this.reconcileSnapshotNestedContent(previous, this.preserveToolInteractions(previous, next), keepPriorTranscripts);
 		if (kept.length === 0) return merged;
 		const mergedByType = /* @__PURE__ */ new Map();
 		const mergedTools = /* @__PURE__ */ new Map();
@@ -1287,7 +1691,7 @@ var AgUiThreadController = class {
 		result.push(...insertions[merged.length]);
 		return result;
 	}
-	reconcileSnapshotNestedContent(previous, next) {
+	reconcileSnapshotNestedContent(previous, next, keepPriorTranscripts) {
 		const nestedIds = /* @__PURE__ */ new Set();
 		for (const part of previous) {
 			if (part.type !== "tool-call" || !part.messages) continue;
@@ -1317,12 +1721,50 @@ var AgUiThreadController = class {
 			if (part.type === "tool-call" && flattened.has(part.toolCallId)) return [];
 			if (part.type !== "tool-call") return [part];
 			const prior = previousCalls.get(part.toolCallId);
-			return prior?.messages === void 0 ? [part] : [{
+			if (prior?.messages === void 0) return [part];
+			if (part.messages === void 0) return [{
 				...part,
 				messages: prior.messages
 			}];
+			if (part.messages.length === 0) return [part];
+			return [{
+				...part,
+				messages: this.mergeNestedTranscripts(prior.messages, part.messages, keepPriorTranscripts)
+			}];
 		});
 	}
+	/**
+	* Merges one tool call's nested transcripts message by message. The incoming
+	* copy is the base for tool calls and reasoning; resolved results and calls
+	* only the prior copy has carry over, and the prior text wins when it extends
+	* the incoming text. Importing a snapshot keeps prior messages it lacks, a
+	* prior status that is running or incomplete, and the prior status when the
+	* snapshot waits on calls the merged content has already resolved.
+	*/
+	mergeNestedTranscripts(prior, next, importingSnapshot) {
+		const priorById = new Map(prior.map((message) => [message.id, message]));
+		const merged = next.map((message) => {
+			const previous = priorById.get(message.id);
+			if (previous?.role !== "assistant" || message.role !== "assistant") return message;
+			let content = this.mergeSnapshotAssistantContent(previous.content, this.preserveToolResults(previous.content, message.content), message.content.some((part) => part.type === "reasoning"), message.content.some(isActivityPart), new Set(Array.from(iterateToolCallParts(previous.content), (call) => call.toolCallId)), importingSnapshot);
+			const priorText = textOf(previous.content);
+			const incomingText = textOf(message.content);
+			if (priorText.length > incomingText.length && priorText.startsWith(incomingText)) content = replaceTextParts(content, previous.content);
+			const status = !importingSnapshot ? message.status : previous.status.type === "running" || previous.status.type === "incomplete" || message.status.type === "requires-action" && message.status.reason === "tool-calls" && !Array.from(iterateToolCallParts(content)).some((call) => !isResolvedToolCall(call)) ? previous.status : message.status;
+			return {
+				...message,
+				status,
+				content,
+				metadata: {
+					...message.metadata,
+					custom: mergeAgUiNamespace(previous.metadata.custom, message.metadata.custom)
+				}
+			};
+		});
+		if (!importingSnapshot) return merged;
+		const mergedById = new Map(merged.map((message) => [message.id, message]));
+		return [...prior.map((message) => mergedById.get(message.id) ?? message), ...merged.filter((message) => !priorById.has(message.id))];
+	}
 	mergeAssistantMetadata(current, incoming) {
 		const annotations = incoming.unstable_annotations ? [...current.unstable_annotations, ...incoming.unstable_annotations] : current.unstable_annotations;
 		const data = incoming.unstable_data ? [...current.unstable_data, ...incoming.unstable_data] : current.unstable_data;
@@ -1337,7 +1779,8 @@ var AgUiThreadController = class {
 			custom: incoming.custom ? mergeAgUiNamespace(current.custom, incoming.custom) : current.custom
 		};
 	}
-	handleEvent(aggregator, event, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary) {
+	handleEvent(aggregator, event, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary, reconcileSnapshot) {
+		if (event.type === "SUBAGENT_STARTED" && !this.subagentParentToolCallIds.has(event.subagentRunId)) this.subagentParentToolCallIds.set(event.subagentRunId, event.parentToolCallId);
 		switch (event.type) {
 			case "STATE_SNAPSHOT":
 				this.dispatch({
@@ -1360,12 +1803,26 @@ var AgUiThreadController = class {
 				}
 				break;
 			case "MESSAGES_SNAPSHOT": {
+				aggregator.handle(event);
 				const previousHeadId = this.session.headId;
 				const activeAssistant = activeAssistantId === void 0 ? void 0 : this.session.tryGetMessage(activeAssistantId)?.message;
 				const hasActiveText = activeAssistant?.role === "assistant" && activeAssistant.content.some((part) => part.type === "text");
-				this.importMessagesSnapshot(event.messages, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary);
+				this.importMessagesSnapshot(event.messages, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary, reconcileSnapshot);
 				const headId = this.session.headId;
-				if (hasActiveText && headId !== previousHeadId) activeAssistantId = (headId === null ? void 0 : this.session.tryGetMessage(headId)?.message)?.role === "assistant" ? headId ?? void 0 : void 0;
+				const head = headId === null ? void 0 : this.session.tryGetMessage(headId)?.message;
+				const hasNewPendingToolCallAnswer = head?.role === "assistant" && !runStartMessageIds.has(head.id) && head.status?.type === "requires-action" && head.status.reason === "tool-calls";
+				if (headId !== previousHeadId && (hasActiveText || hasNewPendingToolCallAnswer)) {
+					const nextActiveAssistantId = head?.role === "assistant" ? headId ?? void 0 : void 0;
+					if (activeAssistantId !== nextActiveAssistantId && activeAssistantId) {
+						const previous = this.session.tryGetMessage(activeAssistantId)?.message;
+						if (previous?.role === "assistant" && previous.status?.type === "running") this.updateAssistantMessage(activeAssistantId, {
+							status: FALLBACK_USER_STATUS,
+							content: settleNestedContent(previous.content, FALLBACK_USER_STATUS)
+						});
+					}
+					activeAssistantId = nextActiveAssistantId;
+					if (hasNewPendingToolCallAnswer && head) this.updateAssistantMessage(head.id, { status: { type: "running" } });
+				}
 				this.updateActiveAssistantState(activeAssistantId);
 				break;
 			}
@@ -1427,7 +1884,8 @@ var AgUiThreadController = class {
 						text: modelText
 					}] } : {},
 					...part.isError === void 0 ? typeof event.mcpResult?.isError === "boolean" ? { isError: event.mcpResult.isError } : event.role === "tool" ? { isError: false } : {} : {},
-					...event.messageId ? { unstable_toolMessageId: event.messageId } : {}
+					...event.messageId ? { unstable_toolMessageId: event.messageId } : {},
+					...event.metadata !== void 0 ? { providerMetadata: withAgUiPartMessageMetadata(part.providerMetadata, event.metadata) } : {}
 				};
 				const { modelContent: _modelContent, ...partWithoutModelContent } = part;
 				return {
@@ -1439,7 +1897,8 @@ var AgUiThreadController = class {
 					}] } : {},
 					...typeof event.mcpResult?.isError === "boolean" ? { isError: event.mcpResult.isError } : event.role === "tool" ? { isError: false } : {},
 					...part.mcp === void 0 && mcpAppUri !== void 0 ? { mcp: { app: { resourceUri: mcpAppUri } } } : {},
-					...event.messageId ? { unstable_toolMessageId: event.messageId } : {}
+					...event.messageId ? { unstable_toolMessageId: event.messageId } : {},
+					...event.metadata !== void 0 ? { providerMetadata: withAgUiPartMessageMetadata(part.providerMetadata, event.metadata) } : {}
 				};
 			});
 			if (!matchedToolCall) return message;
@@ -1449,7 +1908,8 @@ var AgUiThreadController = class {
 			};
 		})) return;
 		this.publishUpdate();
-		this.maybeCompleteAfterToolResults(messageId);
+		if (this.maybeCompleteAfterToolResults(messageId)) return;
+		this.persistSettledAssistant(messageId);
 	}
 	applyCrossRunActivitySnapshot(messageId, toolCallId, event) {
 		const resourceUri = event.content["resourceUri"];
@@ -1488,18 +1948,21 @@ var AgUiThreadController = class {
 			};
 		})) return;
 		this.publishUpdate();
-		this.maybeCompleteAfterToolResults(messageId);
+		if (this.maybeCompleteAfterToolResults(messageId)) return;
+		this.persistSettledAssistant(messageId);
 	}
-	importMessagesSnapshot(rawMessages, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary) {
+	importMessagesSnapshot(rawMessages, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary, reconcileSnapshot) {
 		try {
 			const activeAssistantItem = activeAssistantId ? this.session.tryGetMessage(activeAssistantId) : void 0;
 			const activeMessage = activeAssistantItem?.message;
 			const activeAssistantParentId = activeAssistantItem?.parentId;
 			const activeAssistant = activeMessage?.role === "assistant" ? activeMessage : void 0;
-			const normalized = fromAgUiMessages(rawMessages, { showThinking: this.showThinking });
+			const normalized = fromAgUiSnapshotMessages(rawMessages, { showThinking: this.showThinking }, this.subagentParentToolCallIds);
 			const converted = [];
 			for (const message of normalized) try {
-				converted.push(fromThreadMessageLike(message, generateId(), FALLBACK_USER_STATUS));
+				const previous = message.id ? this.session.tryGetMessage(message.id)?.message : void 0;
+				const fallbackStatus = previous?.role === "assistant" && previous.status?.type === "running" ? previous.status : FALLBACK_USER_STATUS;
+				converted.push(fromThreadMessageLike(message, generateId(), fallbackStatus));
 			} catch (error) {
 				this.logger.error?.("[agui] failed to import message from snapshot", error);
 			}
@@ -1508,10 +1971,16 @@ var AgUiThreadController = class {
 			for (let index = 0; index < converted.length; index++) {
 				const convertedMessage = converted[index];
 				const existing = this.session.tryGetMessage(convertedMessage.id)?.message;
-				if (convertedMessage.role === "assistant" && existing?.role === "assistant") converted[index] = {
-					...convertedMessage,
-					content: this.mergeSnapshotAssistantContent(existing.content, convertedMessage.content, snapshotHasReasoning, snapshotHasActivity)
-				};
+				if (convertedMessage.role === "assistant") {
+					const previous = existing?.role === "assistant" ? existing : void 0;
+					const snapshot = reconcileSnapshot?.(convertedMessage, previous) ?? convertedMessage;
+					const preservesRunningStatus = convertedMessage.id === activeAssistantId && previous?.status?.type === "running" && snapshot.status?.type === "requires-action" && snapshot.status.reason === "tool-calls";
+					converted[index] = previous ? {
+						...snapshot,
+						...preservesRunningStatus ? { status: previous.status } : {},
+						content: this.mergeSnapshotAssistantContent(previous.content, snapshot.content, snapshotHasReasoning, snapshotHasActivity, /* @__PURE__ */ new Set(), true)
+					} : snapshot;
+				}
 			}
 			if (joinStrategy === "concat-content") {
 				const activeIndex = converted.findIndex((message) => message.id === activeAssistantId);
@@ -1594,6 +2063,14 @@ var AgUiThreadController = class {
 		if (!this.history) return;
 		this.assistantHistoryParents.set(messageId, parentId);
 	}
+	persistSettledAssistant(messageId) {
+		const item = this.session.tryGetMessage(messageId);
+		if (!this.history?.update || !item) return;
+		if (!this.isTerminalStatus(item.message.status)) return;
+		if (!this.persistedHistoryIds.has(messageId) && this.historyWrites.pending(messageId) === void 0) return;
+		this.markPendingAssistantHistory(messageId, item.parentId);
+		this.persistAssistantHistory(messageId);
+	}
 	persistAssistantHistory(messageId) {
 		const history = this.history;
 		if (!history) return;
@@ -1604,7 +2081,7 @@ var AgUiThreadController = class {
 		if (!this.isPersistableStatus(message.status)) return;
 		const wasPersisted = this.persistedHistoryIds.has(messageId);
 		const update = history.update;
-		if (update !== void 0 && (wasPersisted || this.snapshotHistoryIds.has(messageId))) {
+		if (update !== void 0 && (wasPersisted || this.snapshotHistoryIds.has(messageId) || this.historyWrites.pending(messageId) !== void 0)) {
 			const write = this.historyWrites.chain(messageId, () => update.call(history, {
 				parentId,
 				message
@@ -1647,7 +2124,6 @@ var AgUiThreadController = class {
 		return write;
 	}
 };
-//#endregion
 export { AgUiThreadController };
 
 //# sourceMappingURL=AgUiThreadController.js.map