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

package/dist/runtime/{AgUiThreadRuntimeCore.js → AgUiThreadController.js}

@@ -1,18 +1,57 @@
 "use client";
-import { readMcpAppResourceUri } from "./mcp-tool-result.js";
+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, createMessageRepositorySession, invokeUserCallback, iterateToolCallParts, mapToolCallPartsDeep } from "@assistant-ui/core/internal";
+import { appendToolInteraction, createHistoryWriteChain, createMessageRepositorySession, invokeUserCallback, iterateToolCallParts, mapToolCallPartsDeep } from "@assistant-ui/core/internal";
 import jsonpatch from "fast-json-patch";
-//#region src/runtime/AgUiThreadRuntimeCore.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 === void 0 ? void 0 : new Set(ids);
+};
+const withoutPendingToolCallIds = (metadata) => {
+	const namespace = metadata.custom[AG_UI_METADATA_NAMESPACE];
+	if (!namespace || !("pendingToolCallIds" in namespace)) return metadata;
+	const { pendingToolCallIds: _pendingToolCallIds, ...remainingNamespace } = namespace;
+	const { [AG_UI_METADATA_NAMESPACE]: _namespace, ...remainingCustom } = metadata.custom;
+	return {
+		...metadata,
+		custom: {
+			...remainingCustom,
+			...Object.keys(remainingNamespace).length > 0 ? { [AG_UI_METADATA_NAMESPACE]: remainingNamespace } : {}
+		}
+	};
+};
+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",
@@ -34,7 +73,7 @@ const mergeAgUiNamespace = (current, incoming) => {
 	};
 	return merged;
 };
-var AgUiThreadRuntimeCore = class {
+var AgUiThreadController = class {
 	agent;
 	logger;
 	showThinking;
@@ -63,24 +102,16 @@ var AgUiThreadRuntimeCore = class {
 			headId: repository.headId
 		};
 	} });
-	isRunningFlag = false;
+	state = createAgUiThreadState();
 	abortController = null;
 	activeRunAgent = null;
-	stateSnapshot;
 	history;
-	lastRunConfig;
 	assistantHistoryParents = /* @__PURE__ */ new Map();
 	snapshotHistoryIds = /* @__PURE__ */ new Set();
 	persistedHistoryIds = /* @__PURE__ */ new Set();
-	historyWrites = /* @__PURE__ */ new Map();
-	_isLoading = false;
+	historyWrites = createHistoryWriteChain();
 	_historyImportPromise;
-	historyMutationGeneration = 0;
 	_loadPromise;
-	_loadRequested = false;
-	pendingResume = null;
-	pendingA2uiResumeOwner = null;
-	pendingA2uiAction;
 	constructor(options) {
 		this.agent = options.agent;
 		this.logger = options.logger;
@@ -99,11 +130,14 @@ var AgUiThreadRuntimeCore = class {
 		return () => this.listeners.delete(listener);
 	};
 	getSnapshot = () => this.snapshot ??= {
-		isLoading: this._isLoading,
-		isRunning: this.isRunningFlag,
+		isLoading: this.state.isLoading,
+		isRunning: this.state.isRunning,
 		messageRepository: this.session.export(),
-		state: this.stateSnapshot
+		state: this.state.stateSnapshot
 	};
+	dispatch(action) {
+		this.state = reduceAgUiThreadState(this.state, action);
+	}
 	publishUpdate() {
 		this.snapshot = void 0;
 		for (const listener of this.listeners) listener();
@@ -120,7 +154,7 @@ var AgUiThreadRuntimeCore = class {
 		this.onCancel = options.onCancel;
 		const previousHistory = this.history;
 		this.history = options.history;
-		if (this._loadRequested && !this._loadPromise && !previousHistory && options.history && this.session.getMessages().length === 0) this.__internal_load();
+		if (this.state.loadRequested && !this._loadPromise && !previousHistory && options.history && this.session.getMessages().length === 0) this.__internal_load();
 	}
 	attachRuntime(runtime) {
 		this.runtime = runtime;
@@ -138,16 +172,16 @@ var AgUiThreadRuntimeCore = class {
 		return this.session.export();
 	}
 	getState() {
-		return this.stateSnapshot;
+		return this.state.stateSnapshot;
 	}
 	isRunning() {
-		return this.isRunningFlag;
+		return this.state.isRunning;
 	}
 	get isLoading() {
-		return this._isLoading;
+		return this.state.isLoading;
 	}
 	__internal_load() {
-		this._loadRequested = true;
+		this.dispatch({ type: "loadRequested" });
 		if (this._loadPromise) return this._loadPromise;
 		if (!this.history) return Promise.resolve();
 		const promise = this.history.load().then((repo) => {
@@ -161,7 +195,7 @@ var AgUiThreadRuntimeCore = class {
 			if (repo.state !== void 0) this.loadExternalState(repo.state);
 			return repo;
 		});
-		this._isLoading = true;
+		this.dispatch({ type: "loadStarted" });
 		this._historyImportPromise = promise.then(() => {
 			this._historyImportPromise = void 0;
 		}, () => {
@@ -171,13 +205,13 @@ var AgUiThreadRuntimeCore = class {
 			if (repo?.unstable_resume) {
 				const parentId = repo.headId ?? this.session.headId;
 				const resumeStream = this.history?.resume?.bind(this.history);
-				await this.startRun(parentId, this.lastRunConfig, void 0, resumeStream);
+				await this.startRun(parentId, this.state.lastRunConfig, void 0, resumeStream);
 			}
 		}).catch((error) => {
 			this.logger.error?.("[agui] failed to load history", error);
 			this.reportError(error);
 		}).finally(() => {
-			this._isLoading = false;
+			this.dispatch({ type: "loadFinished" });
 			this.publishUpdate();
 		});
 		this.publishUpdate();
@@ -186,15 +220,15 @@ var AgUiThreadRuntimeCore = class {
 	waitForHistoryImport() {
 		const historyImport = this._historyImportPromise;
 		if (!historyImport) return void 0;
-		const generation = this.historyMutationGeneration;
-		return historyImport.then(() => generation === this.historyMutationGeneration && !this.isThreadSwitching?.());
+		const generation = this.state.historyMutationGeneration;
+		return historyImport.then(() => generation === this.state.historyMutationGeneration && !this.isThreadSwitching?.());
 	}
 	deferUntilHistoryImported(callback) {
 		const historyImport = this._historyImportPromise;
 		if (!historyImport) return false;
-		const generation = this.historyMutationGeneration;
+		const generation = this.state.historyMutationGeneration;
 		historyImport.then(() => {
-			if (generation !== this.historyMutationGeneration || this.isThreadSwitching?.()) return;
+			if (generation !== this.state.historyMutationGeneration || this.isThreadSwitching?.()) return;
 			try {
 				callback();
 			} catch (error) {
@@ -207,9 +241,9 @@ var AgUiThreadRuntimeCore = class {
 		const historyImport = this._historyImportPromise;
 		if (historyImport) {
 			const wasAtTail = message.parentId === this.session.headId;
-			const generation = this.historyMutationGeneration;
+			const generation = this.state.historyMutationGeneration;
 			await historyImport;
-			if (generation !== this.historyMutationGeneration || this.isThreadSwitching?.()) return;
+			if (generation !== this.state.historyMutationGeneration || this.isThreadSwitching?.()) return;
 			if (wasAtTail) message = {
 				...message,
 				parentId: this.session.headId
@@ -235,10 +269,10 @@ var AgUiThreadRuntimeCore = class {
 	}
 	maybeAutoCancelPendingToolCalls() {
 		if (this.autoCancelPendingToolCalls === false) return;
-		const pending = this.getPendingToolCalls();
-		if (!pending) return;
-		this.cancelUnresolvedToolCalls(pending.messageId);
-		this.maybeCompleteAfterToolResults(pending.messageId);
+		for (const assistant of this.getPendingToolCallMessages()) {
+			this.cancelUnresolvedToolCalls(assistant.id);
+			this.maybeCompleteAfterToolResults(assistant.id);
+		}
 	}
 	appendEntry(message) {
 		const threadMessage = this.toThreadMessage(message);
@@ -260,7 +294,7 @@ var AgUiThreadRuntimeCore = class {
 		await this.startRun(parentId, config.runConfig);
 	}
 	async cancel() {
-		this.historyMutationGeneration++;
+		this.dispatch({ type: "historyMutationAdvanced" });
 		this.abortActiveRun();
 	}
 	abortActiveRun() {
@@ -286,7 +320,7 @@ var AgUiThreadRuntimeCore = class {
 		const historyImport = this.waitForHistoryImport();
 		if (historyImport && !await historyImport) return;
 		this.assertNoPendingInterrupts();
-		await this.startRun(config.parentId, config.runConfig ?? this.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();
@@ -300,7 +334,7 @@ var AgUiThreadRuntimeCore = class {
 		}
 		const parentId = messages.at(-1)?.id ?? null;
 		try {
-			await this.startRun(parentId, this.lastRunConfig, void 0, resumeStream);
+			await this.startRun(parentId, this.state.lastRunConfig, void 0, resumeStream);
 		} catch {}
 	}
 	assertNoPendingInterrupts() {
@@ -308,9 +342,20 @@ var AgUiThreadRuntimeCore = 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();
+		const turn = [];
+		for (let index = messages.length - 1; index >= 0; index--) {
+			const message = messages[index];
+			if (message?.role !== "assistant") break;
+			turn.unshift(message);
+		}
+		return turn;
+	}
+	getPendingToolCallMessages() {
+		return this.getTrailingAssistantTurn().filter((message) => message.status?.type === "requires-action" && message.status.reason === "tool-calls");
 	}
 	getPendingInterrupts() {
 		const assistant = this.findRequiresActionAssistant("interrupt");
@@ -323,16 +368,18 @@ var AgUiThreadRuntimeCore = class {
 		};
 	}
 	getPendingToolCalls() {
-		const assistant = this.findRequiresActionAssistant("tool-calls");
-		if (!assistant) return null;
 		const toolCallIds = [];
-		for (const part of iterateToolCallParts(assistant.content)) {
-			if (isResolvedToolCall(part)) continue;
-			toolCallIds.push(part.toolCallId);
+		let messageId;
+		for (const assistant of this.getPendingToolCallMessages()) {
+			const listed = listedPendingToolCallIds(assistant);
+			for (const part of iterateToolCallParts(assistant.content)) {
+				if (isResolvedToolCall(part) || listed && !listed.has(part.toolCallId)) continue;
+				messageId ??= assistant.id;
+				toolCallIds.push(part.toolCallId);
+			}
 		}
-		if (toolCallIds.length === 0) return null;
-		return {
-			messageId: assistant.id,
+		return messageId === void 0 ? null : {
+			messageId,
 			toolCallIds
 		};
 	}
@@ -345,7 +392,7 @@ var AgUiThreadRuntimeCore = class {
 		const openIds = pending.interrupts.map((i) => i.id);
 		const missing = openIds.filter((id) => !responsesById.has(id));
 		if (missing.length > 0) throw new Error(`[agui] submitInterruptResponses: missing responses for open interrupts: ${missing.join(", ")}`);
-		this.assertInterruptsAnswerable("submitInterruptResponses", pending.interrupts);
+		this.assertInterruptsAnswerable("submitInterruptResponses", pending.interrupts, responsesById);
 		await this.resumeWithResponses(pending.messageId, openIds.map((id) => responsesById.get(id)));
 	}
 	/**
@@ -355,8 +402,9 @@ var AgUiThreadRuntimeCore = class {
 	* unretryable.
 	*/
 	async resumeWithResponses(messageId, resume) {
+		const parentId = this.session.headId ?? messageId;
 		this.clearPendingInterrupts(messageId, resume);
-		await this.startRun(messageId, this.lastRunConfig, {
+		await this.startRun(parentId, this.state.lastRunConfig, {
 			entries: resume,
 			interruptedMessageId: messageId
 		});
@@ -375,15 +423,15 @@ var AgUiThreadRuntimeCore = class {
 		}
 		invokeRuntimeCallback("onError", this.onError, error instanceof Error ? error : new Error(String(error)));
 	}
-	assertInterruptsAnswerable(method, interrupts) {
+	assertInterruptsAnswerable(method, interrupts, responsesById) {
 		const now = Date.now();
 		for (const interrupt of interrupts) {
 			if (!interrupt.expiresAt) continue;
 			const expiry = new Date(interrupt.expiresAt).getTime();
 			if (Number.isNaN(expiry)) throw new Error(`[agui] ${method}: interrupt ${interrupt.id} has malformed expiresAt "${interrupt.expiresAt}"`);
-			if (expiry <= now) throw new Error(`[agui] ${method}: interrupt ${interrupt.id} expired at ${interrupt.expiresAt}`);
+			if (expiry <= now && responsesById?.get(interrupt.id)?.status !== "cancelled") throw new Error(`[agui] ${method}: interrupt ${interrupt.id} expired at ${interrupt.expiresAt}`);
 		}
-		if (this.isRunningFlag) throw new Error(`[agui] ${method}: a run is already in progress`);
+		if (this.state.isRunning) throw new Error(`[agui] ${method}: a run is already in progress`);
 	}
 	async respondToToolApproval(options) {
 		const historyImport = this.waitForHistoryImport();
@@ -415,12 +463,13 @@ var AgUiThreadRuntimeCore = class {
 		if (historyImport && !await historyImport) return;
 		const pending = this.getPendingInterrupts();
 		if (!pending) {
-			const pendingTools = this.getPendingToolCalls();
-			if (pendingTools) {
+			if (this.getPendingToolCalls()) {
 				if (responses?.length) throw new Error("[agui] steerAway: responses are only valid for pending interrupts");
-				if (this.isRunningFlag) throw new Error("[agui] steerAway: a run is already in progress");
-				this.cancelUnresolvedToolCalls(pendingTools.messageId);
-				this.maybeCompleteAfterToolResults(pendingTools.messageId);
+				if (this.state.isRunning) throw new Error("[agui] steerAway: a run is already in progress");
+				for (const assistant of this.getPendingToolCallMessages()) {
+					this.cancelUnresolvedToolCalls(assistant.id);
+					this.maybeCompleteAfterToolResults(assistant.id);
+				}
 				const normalized = this.toAppendMessage(message);
 				const threadMessageId = this.appendEntry(normalized);
 				await this.startRun(threadMessageId, normalized.runConfig);
@@ -431,7 +480,7 @@ var AgUiThreadRuntimeCore = class {
 			return;
 		}
 		const resume = this.resolveSteerAwayResume(pending.interrupts, responses);
-		if (this.isRunningFlag) throw new Error("[agui] steerAway: a run is already in progress");
+		if (this.state.isRunning) throw new Error("[agui] steerAway: a run is already in progress");
 		const normalized = this.toAppendMessage(message);
 		this.clearPendingInterrupts(pending.messageId, resume);
 		const threadMessageId = this.appendEntry(normalized);
@@ -597,7 +646,7 @@ var AgUiThreadRuntimeCore = class {
 		const message = this.session.tryGetMessage(sessionMessageId)?.message;
 		const history = this.history;
 		if (!message || !history?.update || !this.isPersistableStatus(message.status)) return;
-		await this.chainHistoryWrite(sessionMessageId, () => history.update({
+		await this.historyWrites.chain(sessionMessageId, () => history.update({
 			parentId: item.parentId,
 			message
 		}));
@@ -614,25 +663,42 @@ var AgUiThreadRuntimeCore = class {
 		const userAction = { ...action };
 		delete userAction.type;
 		if (!("timestamp" in userAction)) userAction.timestamp = (/* @__PURE__ */ new Date()).toISOString();
-		this.pendingA2uiAction = userAction;
+		this.dispatch({
+			type: "a2uiActionDeferred",
+			action: userAction
+		});
 		const owner = this.abortController;
 		if (owner) {
-			this.pendingA2uiResumeOwner = owner;
+			this.dispatch({
+				type: "a2uiResumeDeferred",
+				owner
+			});
 			return;
 		}
 		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;
 		const owner = this.abortController;
 		if (owner) {
-			this.pendingResume = {
+			this.dispatch({
+				type: "resumeDeferred",
 				owner,
 				messageId
-			};
+			});
 			return;
 		}
-		this.startResumeRun(messageId);
+		if (this.getPendingToolCalls()) return;
+		const headId = turn.at(-1)?.id;
+		if (headId === void 0) return;
+		this.startResumeRun(headId);
 	}
 	maybeCompleteAfterToolResults(messageId) {
 		const message = this.session.tryGetMessage(messageId)?.message;
@@ -640,9 +706,13 @@ var AgUiThreadRuntimeCore = class {
 		const assistant = message;
 		if (assistant.status?.type !== "requires-action" || assistant.status.reason !== "tool-calls") return false;
 		let allResolved = true;
-		for (const part of iterateToolCallParts(assistant.content)) if (!isResolvedToolCall(part)) {
-			allResolved = false;
-			break;
+		const listed = listedPendingToolCallIds(assistant);
+		for (const part of iterateToolCallParts(assistant.content)) {
+			if (listed && !listed.has(part.toolCallId)) continue;
+			if (!isResolvedToolCall(part)) {
+				allResolved = false;
+				break;
+			}
 		}
 		if (!allResolved) return false;
 		if (!this.session.updateMessage(messageId, (current) => current.role === "assistant" ? {
@@ -650,14 +720,15 @@ var AgUiThreadRuntimeCore = class {
 			status: {
 				type: "complete",
 				reason: "unknown"
-			}
+			},
+			metadata: withoutPendingToolCallIds(current.metadata)
 		} : current)) return false;
 		this.publishUpdate();
 		this.persistAssistantHistory(messageId);
 		return true;
 	}
 	startResumeRun(messageId) {
-		this.startRun(messageId, this.lastRunConfig).catch((error) => {
+		this.startRun(messageId, this.state.lastRunConfig).catch((error) => {
 			this.reportError(error);
 		});
 	}
@@ -674,8 +745,7 @@ var AgUiThreadRuntimeCore = class {
 				}
 			};
 		});
-		this.pendingA2uiResumeOwner = null;
-		this.pendingA2uiAction = void 0;
+		this.dispatch({ type: "a2uiContinuationsCleared" });
 		this.assistantHistoryParents.clear();
 		if (messages.length === 0) this.session.clear();
 		else {
@@ -683,6 +753,10 @@ var AgUiThreadRuntimeCore = 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);
@@ -691,11 +765,12 @@ var AgUiThreadRuntimeCore = 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;
@@ -703,39 +778,55 @@ var AgUiThreadRuntimeCore = 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.pendingResume?.messageId;
-		if (resumeTarget !== void 0 && !this.session.getMessages().some((message) => message.id === resumeTarget)) this.pendingResume = null;
+		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) {
-		this.stateSnapshot = state;
+		this.dispatch({
+			type: "stateSnapshot",
+			snapshot: state
+		});
 		this.publishUpdate();
 	}
 	setState(next) {
-		this.stateSnapshot = typeof next === "function" ? next(this.stateSnapshot) : next;
+		const snapshot = typeof next === "function" ? next(this.state.stateSnapshot) : next;
+		this.dispatch({
+			type: "stateSnapshot",
+			snapshot
+		});
 		this.publishUpdate();
 	}
 	resetState() {
-		this.stateSnapshot = void 0;
+		this.dispatch({ type: "resetState" });
 		this.publishUpdate();
 	}
 	resetThreadState() {
-		this.historyMutationGeneration++;
+		this.dispatch({ type: "historyMutationAdvanced" });
 		const controller = this.abortController;
 		const activeRunAgent = this.activeRunAgent;
-		this.stateSnapshot = void 0;
-		this.pendingResume = null;
-		this.pendingA2uiResumeOwner = null;
-		this.pendingA2uiAction = void 0;
+		this.dispatch({ type: "resetThread" });
 		if (controller) {
 			this.abortController = null;
 			this.activeRunAgent = null;
@@ -749,52 +840,245 @@ var AgUiThreadRuntimeCore = 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.lastRunConfig = normalizedRunConfig;
+		this.dispatch({
+			type: "runConfigRecorded",
+			runConfig: normalizedRunConfig
+		});
 		const parent = parentId === null ? void 0 : this.session.tryGetMessage(parentId);
 		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) => {
 			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 = 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"
+					} : {
+						type: "complete",
+						reason: "unknown"
+					} : terminalStatus;
+					requiresToolResult = status.type === "requires-action";
+					const metadata = withoutPendingToolCallIds(assistant.metadata);
+					return {
+						...assistant,
+						status,
+						metadata: status.type === "requires-action" && (restrictedPendingToolCallIds || replayContexts.has(messageId)) ? withPendingToolCallIds(metadata, pendingToolCallIds) : metadata
+					};
+				})) {
+					this.publishUpdate();
+					this.persistAssistantHistory(messageId);
+					if (requiresToolResult) pendingMessages.push(messageId);
+				}
+			}
+			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");
-			const resolved = this.updateAssistantMessage(ensureAssistant(hasStreamContent), update);
-			if (resolved !== assistantMessageId) assistantMessageId = resolved;
+			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 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) => {
+		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) {
-				applyUpdate({ status: {
+				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);
@@ -817,14 +1101,60 @@ var AgUiThreadRuntimeCore = class {
 			onServerMessageId: (serverId) => {
 				adoptServerMessageId(serverId, false);
 			},
-			onTextMessageStart: (serverId) => adoptServerMessageId(serverId, true)
+			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;
-			const nextAssistantMessageId = this.handleEvent(aggregator, event, assistantMessageId, joinStrategy, runStartMessageIds, hasRunUserBoundary);
-			if (event.type === "MESSAGES_SNAPSHOT") assistantMessageId = nextAssistantMessageId;
+			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 === 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);
+			}
+			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, 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;
+			}
 		};
 		this.abortController = abortController;
 		const runAgentInstance = this.agent;
@@ -898,16 +1228,46 @@ var AgUiThreadRuntimeCore = class {
 			this.clearDeferredContinuations(abortController);
 			throw err;
 		}
-		if (this.pendingResume?.owner === abortController) {
-			const { messageId } = this.pendingResume;
-			this.pendingResume = null;
-			if (!abortSignal.aborted) this.startResumeRun(messageId);
+		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.pendingA2uiResumeOwner === abortController) {
-			this.pendingA2uiResumeOwner = null;
-			if (!abortSignal.aborted && this.pendingA2uiAction !== void 0) {
+		if (this.state.pendingResume?.owner === abortController) {
+			const { messageIds } = this.state.pendingResume;
+			this.dispatch({ type: "resumeCleared" });
+			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" });
+			if (!abortSignal.aborted && this.state.pendingA2uiAction !== void 0) {
 				if (this.getPendingInterrupts()) {
-					this.pendingA2uiAction = void 0;
+					this.dispatch({ type: "a2uiActionCleared" });
 					this.logger.debug("[agui] sendA2uiAction: pending interrupts, dropping action");
 					return;
 				}
@@ -915,15 +1275,14 @@ var AgUiThreadRuntimeCore = class {
 				const parentId = this.session.headId;
 				if (parentId !== null) this.startResumeRun(parentId);
 				else {
-					this.pendingA2uiAction = void 0;
+					this.dispatch({ type: "a2uiActionCleared" });
 					this.logger.debug("[agui] sendA2uiAction: no messages to resume, dropping action");
 				}
-			} else this.pendingA2uiAction = void 0;
+			} else this.dispatch({ type: "a2uiActionCleared" });
 		}
 	}
 	async consumeResumeStream(stream, ctx) {
-		this.pendingA2uiAction = void 0;
-		this.pendingA2uiResumeOwner = null;
+		this.dispatch({ type: "a2uiContinuationsCleared" });
 		const assistantId = ctx.ensureAssistant();
 		const currentId = () => ctx.getAssistantMessageId() ?? assistantId;
 		const options = {
@@ -964,8 +1323,8 @@ var AgUiThreadRuntimeCore = class {
 		} });
 	}
 	buildRunInput(runId, runConfig, historyMessages, resume) {
-		const pendingA2uiAction = this.pendingA2uiAction;
-		this.pendingA2uiAction = void 0;
+		const pendingA2uiAction = this.state.pendingA2uiAction;
+		this.dispatch({ type: "a2uiActionCleared" });
 		const threadId = this.agent.threadId || "main";
 		const messages = toAgUiMessages(this.selectRunMessages(historyMessages ?? this.session.getMessages(), resume));
 		const context = this.runtime?.thread.getModelContext();
@@ -983,7 +1342,7 @@ var AgUiThreadRuntimeCore = class {
 		return {
 			threadId,
 			runId,
-			state: this.stateSnapshot ?? null,
+			state: this.state.stateSnapshot ?? null,
 			messages,
 			tools: toAgUiTools(context?.tools),
 			context: [...context?.system ? [{
@@ -1013,14 +1372,11 @@ var AgUiThreadRuntimeCore = class {
 		return messages.slice(anchor + 1);
 	}
 	clearDeferredContinuations(owner) {
-		if (this.pendingResume?.owner === owner) this.pendingResume = null;
-		if (this.pendingA2uiResumeOwner === owner) {
-			this.pendingA2uiResumeOwner = null;
-			this.pendingA2uiAction = void 0;
-		}
+		if (this.state.pendingResume?.owner === owner) this.dispatch({ type: "resumeCleared" });
+		if (this.state.pendingA2uiResumeOwner === owner) this.dispatch({ type: "a2uiContinuationsCleared" });
 	}
 	setRunning(running) {
-		this.isRunningFlag = running;
+		this.dispatch({ type: running ? "runStarted" : "runFinished" });
 		this.publishUpdate();
 	}
 	finishRun(controller) {
@@ -1037,7 +1393,7 @@ var AgUiThreadRuntimeCore = class {
 			status: { type: "running" },
 			content: [],
 			metadata: {
-				unstable_state: this.stateSnapshot ?? null,
+				unstable_state: this.state.stateSnapshot ?? null,
 				unstable_annotations: [],
 				unstable_data: [],
 				steps: [],
@@ -1080,32 +1436,55 @@ var AgUiThreadRuntimeCore = class {
 			ids.delete(oldId);
 			if (!collidesWithExisting) ids.add(newId);
 		}
-		const pendingWrite = this.historyWrites.get(oldId);
-		if (pendingWrite) {
-			this.historyWrites.delete(oldId);
-			if (!collidesWithExisting) {
-				this.historyWrites.set(newId, pendingWrite);
-				const settle = () => {
-					if (this.historyWrites.get(newId) === pendingWrite) this.historyWrites.delete(newId);
-				};
-				pendingWrite.then(() => {
-					this.persistedHistoryIds.delete(oldId);
-					this.persistedHistoryIds.add(newId);
-					settle();
-				}, settle);
-			}
-		}
+		const pendingWrite = this.historyWrites.move(oldId, collidesWithExisting ? void 0 : newId);
+		if (pendingWrite && !collidesWithExisting) pendingWrite.then(() => {
+			this.persistedHistoryIds.delete(oldId);
+			this.persistedHistoryIds.add(newId);
+		}, () => {});
 		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 metadata = update.metadata ? this.mergeAssistantMetadata(assistant.metadata, update.metadata) : assistant.metadata;
+			const mergedMetadata = update.metadata ? this.mergeAssistantMetadata(assistant.metadata, update.metadata) : assistant.metadata;
 			latestStatus = update.status ?? assistant.status;
-			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,
@@ -1120,24 +1499,25 @@ var AgUiThreadRuntimeCore = 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);
 	}
@@ -1240,18 +1620,23 @@ var AgUiThreadRuntimeCore = 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.stateSnapshot = event.snapshot;
+				this.dispatch({
+					type: "stateSnapshot",
+					snapshot: event.snapshot
+				});
 				this.updateActiveAssistantState(activeAssistantId);
 				break;
 			case "STATE_DELTA":
 				if (event.delta.length === 0) break;
 				try {
-					const state = this.stateSnapshot ?? {};
-					const result = jsonpatch.applyPatch(state, event.delta, true, false);
-					this.stateSnapshot = result.newDocument;
+					const result = jsonpatch.applyPatch(this.state.stateSnapshot ?? {}, event.delta, true, false);
+					this.dispatch({
+						type: "stateSnapshot",
+						snapshot: result.newDocument
+					});
 					this.updateActiveAssistantState(activeAssistantId);
 				} catch (error) {
 					this.logger.error?.("[agui] failed to apply state delta", error);
@@ -1261,7 +1646,7 @@ var AgUiThreadRuntimeCore = 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);
@@ -1302,7 +1687,7 @@ var AgUiThreadRuntimeCore = class {
 				...assistant,
 				metadata: {
 					...assistant.metadata,
-					unstable_state: this.stateSnapshot ?? null
+					unstable_state: this.state.stateSnapshot ?? null
 				}
 			};
 		});
@@ -1313,25 +1698,27 @@ var AgUiThreadRuntimeCore = class {
 			if (message.role !== "assistant") return message;
 			const assistant = message;
 			const mcpAppUri = readMcpAppResourceUri(event.mcpResult?._meta);
+			const modelText = toolContentText(event.content);
 			let matchedToolCall = false;
 			const { content } = mapToolCallPartsDeep(assistant.content, (part) => {
 				if (part.toolCallId !== event.toolCallId) return part;
 				matchedToolCall = true;
 				if (part.mcp?.app !== void 0 && isPlainObject(part.result) && Array.isArray(part.result["content"])) return {
 					...part,
-					...part.modelContent === void 0 && event.content ? { modelContent: [{
+					...part.modelContent === void 0 ? { modelContent: [{
 						type: "text",
-						text: event.content
+						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 } : {}
 				};
+				const { modelContent: _modelContent, ...partWithoutModelContent } = part;
 				return {
-					...part,
-					result: event.mcpResult ?? tryParseJSON(event.content ?? ""),
+					...event.mcpResult === void 0 && Array.isArray(event.content) ? partWithoutModelContent : part,
+					result: event.mcpResult ?? (Array.isArray(event.content) ? event.content : tryParseJSON(event.content)),
 					...event.mcpResult !== void 0 ? { modelContent: [{
 						type: "text",
-						text: event.content
+						text: modelText
 					}] } : {},
 					...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 } } } : {},
@@ -1386,7 +1773,7 @@ var AgUiThreadRuntimeCore = 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;
@@ -1404,10 +1791,14 @@ var AgUiThreadRuntimeCore = 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);
@@ -1501,7 +1892,7 @@ var AgUiThreadRuntimeCore = class {
 		const wasPersisted = this.persistedHistoryIds.has(messageId);
 		const update = history.update;
 		if (update !== void 0 && (wasPersisted || this.snapshotHistoryIds.has(messageId))) {
-			const write = this.chainHistoryWrite(messageId, () => update.call(history, {
+			const write = this.historyWrites.chain(messageId, () => update.call(history, {
 				parentId,
 				message
 			}));
@@ -1509,7 +1900,7 @@ var AgUiThreadRuntimeCore = class {
 			write.then(() => {
 				this.persistedHistoryIds.add(messageId);
 			}, (error) => {
-				const pending = this.historyWrites.get(messageId);
+				const pending = this.historyWrites.pending(messageId);
 				if (pending === void 0 || pending === write) this.assistantHistoryParents.set(messageId, parentId);
 				this.logger.error?.("[agui] failed to update history entry", error);
 			});
@@ -1523,17 +1914,17 @@ var AgUiThreadRuntimeCore = class {
 		if (!write) return;
 		this.assistantHistoryParents.delete(messageId);
 		write.then(() => {}, (error) => {
-			const pending = this.historyWrites.get(messageId);
+			const pending = this.historyWrites.pending(messageId);
 			if (pending === void 0 || pending === write) this.assistantHistoryParents.set(messageId, parentId);
 			this.logger.error?.("[agui] failed to append history entry", error);
 		});
 	}
 	appendHistoryItem(parentId, message) {
 		if (!this.history || this.persistedHistoryIds.has(message.id)) return;
-		const pending = this.historyWrites.get(message.id);
+		const pending = this.historyWrites.pending(message.id);
 		if (pending) return pending;
 		const append = this.history.append.bind(this.history);
-		const write = this.chainHistoryWrite(message.id, () => append({
+		const write = this.historyWrites.chain(message.id, () => append({
 			parentId,
 			message
 		}));
@@ -1542,25 +1933,7 @@ var AgUiThreadRuntimeCore = class {
 		}, () => {});
 		return write;
 	}
-	chainHistoryWrite(id, write) {
-		const pending = this.historyWrites.get(id);
-		let next;
-		if (pending) next = pending.then(write, write);
-		else try {
-			next = Promise.resolve(write());
-		} catch (error) {
-			next = Promise.reject(error);
-		}
-		this.historyWrites.set(id, next);
-		next.then(() => {
-			if (this.historyWrites.get(id) === next) this.historyWrites.delete(id);
-		}, () => {
-			if (this.historyWrites.get(id) === next) this.historyWrites.delete(id);
-		});
-		return next;
-	}
 };
-//#endregion
-export { AgUiThreadRuntimeCore };
+export { AgUiThreadController };
 
-//# sourceMappingURL=AgUiThreadRuntimeCore.js.map
+//# sourceMappingURL=AgUiThreadController.js.map