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

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 { 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,6 +37,21 @@ 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",
@@ -299,7 +320,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 +342,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 +402,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
 		});
@@ -657,23 +677,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) {
@@ -729,6 +753,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 +765,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 +778,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) {
@@ -799,9 +840,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,13 +853,43 @@ 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;
 		const ensureAssistant = (allowRecreate = false) => {
@@ -825,22 +897,33 @@ var AgUiThreadController = class {
 			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 +935,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 +946,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);
@@ -917,21 +1101,57 @@ var AgUiThreadController = class {
 			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;
+					if (!replayEnded && assistantMessageId === void 0) {
+						const tail = this.session.getMessages().at(-1);
+						snapshotAssistantId = tail?.role === "assistant" ? tail.id : void 0;
+					}
+				}
 			} finally {
 				settlingRun = false;
 			}
@@ -1008,10 +1228,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" });
@@ -1194,15 +1444,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 +1499,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);
 	}
@@ -1337,7 +1620,7 @@ 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) {
 		switch (event.type) {
 			case "STATE_SNAPSHOT":
 				this.dispatch({
@@ -1363,7 +1646,7 @@ var AgUiThreadController = class {
 				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;
 				this.updateActiveAssistantState(activeAssistantId);
@@ -1490,7 +1773,7 @@ var AgUiThreadController = class {
 		this.publishUpdate();
 		this.maybeCompleteAfterToolResults(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;
@@ -1508,10 +1791,14 @@ 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;
+					converted[index] = previous ? {
+						...snapshot,
+						content: this.mergeSnapshotAssistantContent(previous.content, snapshot.content, snapshotHasReasoning, snapshotHasActivity)
+					} : snapshot;
+				}
 			}
 			if (joinStrategy === "concat-content") {
 				const activeIndex = converted.findIndex((message) => message.id === activeAssistantId);
@@ -1647,7 +1934,6 @@ var AgUiThreadController = class {
 		return write;
 	}
 };
-//#endregion
 export { AgUiThreadController };
 
 //# sourceMappingURL=AgUiThreadController.js.map