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

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

@@ -1,18 +1,36 @@
 "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 { RunAggregator, isPlainObject, tryParseJSON } from "./adapter/run-aggregator.js";
 import { fromAgUiMessages, toAgUiMessages, toAgUiTools } from "./adapter/conversions.js";
 import { createAgUiSubscriber } from "./adapter/subscriber.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
+//#region 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 listedPendingToolCallIds = (assistant) => {
+	const ids = assistant.metadata.custom[AG_UI_METADATA_NAMESPACE]?.pendingToolCallIds;
+	return ids?.length ? new Set(ids) : void 0;
+};
+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 isActivityPart = (part) => part.type === "data" && part.name.startsWith("agui-activity/");
 const FALLBACK_USER_STATUS = {
 	type: "complete",
@@ -34,10 +52,11 @@ const mergeAgUiNamespace = (current, incoming) => {
 	};
 	return merged;
 };
-var AgUiThreadRuntimeCore = class {
+var AgUiThreadController = class {
 	agent;
 	logger;
 	showThinking;
+	joinStrategy;
 	getRunContext;
 	resumeTranscript;
 	autoCancelPendingToolCalls;
@@ -62,28 +81,21 @@ 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;
 		this.showThinking = options.showThinking;
+		this.joinStrategy = options.joinStrategy;
 		this.getRunContext = options.getRunContext;
 		this.resumeTranscript = options.resumeTranscript ?? "full";
 		this.autoCancelPendingToolCalls = options.autoCancelPendingToolCalls;
@@ -97,11 +109,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();
@@ -110,6 +125,7 @@ var AgUiThreadRuntimeCore = class {
 		this.agent = options.agent;
 		this.logger = options.logger;
 		this.showThinking = options.showThinking;
+		this.joinStrategy = options.joinStrategy;
 		this.getRunContext = options.getRunContext;
 		this.resumeTranscript = options.resumeTranscript ?? "full";
 		this.autoCancelPendingToolCalls = options.autoCancelPendingToolCalls;
@@ -117,7 +133,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;
@@ -135,16 +151,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) => {
@@ -158,7 +174,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;
 		}, () => {
@@ -168,13 +184,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();
@@ -183,15 +199,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) {
@@ -204,9 +220,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
@@ -232,10 +248,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);
@@ -257,7 +273,7 @@ var AgUiThreadRuntimeCore = class {
 		await this.startRun(parentId, config.runConfig);
 	}
 	async cancel() {
-		this.historyMutationGeneration++;
+		this.dispatch({ type: "historyMutationAdvanced" });
 		this.abortActiveRun();
 	}
 	abortActiveRun() {
@@ -283,7 +299,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);
 	}
 	async resumeInFlightRun(messages) {
 		const historyImport = this.waitForHistoryImport();
@@ -297,7 +313,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() {
@@ -309,6 +325,19 @@ var AgUiThreadRuntimeCore = class {
 		if (!assistant || assistant.status?.type !== "requires-action" || assistant.status.reason !== reason) return null;
 		return assistant;
 	}
+	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");
 		if (!assistant) return null;
@@ -320,16 +349,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
 		};
 	}
@@ -342,7 +373,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)));
 	}
 	/**
@@ -353,7 +384,7 @@ var AgUiThreadRuntimeCore = class {
 	*/
 	async resumeWithResponses(messageId, resume) {
 		this.clearPendingInterrupts(messageId, resume);
-		await this.startRun(messageId, this.lastRunConfig, {
+		await this.startRun(messageId, this.state.lastRunConfig, {
 			entries: resume,
 			interruptedMessageId: messageId
 		});
@@ -372,15 +403,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();
@@ -412,12 +443,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);
@@ -428,7 +460,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);
@@ -594,7 +626,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
 		}));
@@ -611,25 +643,38 @@ 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) {
 		if (!this.maybeCompleteAfterToolResults(messageId)) 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.pendingResume = {
+			this.dispatch({
+				type: "resumeDeferred",
 				owner,
-				messageId
-			};
+				messageId: headId
+			});
 			return;
 		}
-		this.startResumeRun(messageId);
+		this.startResumeRun(headId);
 	}
 	maybeCompleteAfterToolResults(messageId) {
 		const message = this.session.tryGetMessage(messageId)?.message;
@@ -637,9 +682,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" ? {
@@ -647,14 +696,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);
 		});
 	}
@@ -671,8 +721,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 {
@@ -709,30 +758,34 @@ var AgUiThreadRuntimeCore = class {
 		}
 		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 resumeTarget = this.state.pendingResume?.messageId;
+		if (resumeTarget !== void 0 && !this.session.getMessages().some((message) => message.id === resumeTarget)) this.dispatch({ type: "resumeCleared" });
 		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;
@@ -750,15 +803,23 @@ var AgUiThreadRuntimeCore = class {
 		if (this.isThreadSwitching?.()) return;
 		if (!this.supersedeActiveRun()) return;
 		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 joinStrategy = this.joinStrategy;
+		const hasRunUserBoundary = parent?.message.role === "user" && !resume;
 		let pendingError = null;
 		const assistantParentId = parent ? parentId : this.session.headId;
 		let assistantMessageId;
 		let assistantCollided = false;
+		const heldMessages = /* @__PURE__ */ new Map();
+		let restrictedPendingToolCallIds;
+		let settlingRun = false;
 		const ensureAssistant = (allowRecreate = false) => {
 			const cached = assistantMessageId;
 			if (cached !== void 0 && this.session.tryGetMessage(cached)) return cached;
@@ -771,14 +832,58 @@ var AgUiThreadRuntimeCore = class {
 			return created;
 		};
 		if (shouldEagerlyInsertAssistant) ensureAssistant();
+		const settleHeldMessages = (terminalStatus) => {
+			const pendingMessages = [];
+			for (const [messageId, openToolCallIds] of heldMessages) {
+				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 ? {
+						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 ? {
+							...metadata,
+							custom: {
+								...metadata.custom,
+								["agui"]: {
+									...metadata.custom["agui"],
+									pendingToolCallIds
+								}
+							}
+						} : metadata
+					};
+				})) {
+					this.publishUpdate();
+					this.persistAssistantHistory(messageId);
+					if (requiresToolResult) pendingMessages.push(messageId);
+				}
+			}
+			heldMessages.clear();
+			return pendingMessages;
+		};
 		const applyUpdate = (update) => {
+			const terminalStatus = update.status;
+			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 adoptServerMessageId = (serverId, startNewMessage) => {
+		const adoptServerMessageId = (serverId, startNewMessage, openToolCallIds = []) => {
 			if (startNewMessage && assistantMessageId !== void 0) {
-				applyUpdate({ status: {
+				if (openToolCallIds.length > 0) heldMessages.set(assistantMessageId, new Set(openToolCallIds));
+				else applyUpdate({ status: {
 					type: "complete",
 					reason: "unknown"
 				} });
@@ -806,19 +911,30 @@ var AgUiThreadRuntimeCore = class {
 		const abortSignal = abortController.signal;
 		const aggregator = new RunAggregator({
 			showThinking: this.showThinking,
+			joinStrategy,
 			logger: this.logger,
 			emit: applyUpdate,
 			onServerMessageId: (serverId) => {
 				adoptServerMessageId(serverId, false);
 			},
-			onTextMessageStart: (serverId) => adoptServerMessageId(serverId, true)
+			onTextMessageStart: (serverId, openToolCallIds) => adoptServerMessageId(serverId, true, openToolCallIds)
 		});
 		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);
-			if (event.type === "MESSAGES_SNAPSHOT") assistantMessageId = nextAssistantMessageId;
+			if (event.type === "RUN_FINISHED") {
+				runFinished = true;
+				const ids = event.outcome?.type === "success" ? event.outcome.pendingToolCallIds : void 0;
+				restrictedPendingToolCallIds = ids?.length ? new Set(ids) : void 0;
+			}
+			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";
+			try {
+				const nextAssistantMessageId = this.handleEvent(aggregator, event, assistantMessageId, joinStrategy, runStartMessageIds, hasRunUserBoundary);
+				if (event.type === "MESSAGES_SNAPSHOT") assistantMessageId = nextAssistantMessageId;
+			} finally {
+				settlingRun = false;
+			}
 		};
 		this.abortController = abortController;
 		const runAgentInstance = this.agent;
@@ -892,16 +1008,16 @@ var AgUiThreadRuntimeCore = class {
 			this.clearDeferredContinuations(abortController);
 			throw err;
 		}
-		if (this.pendingResume?.owner === abortController) {
-			const { messageId } = this.pendingResume;
-			this.pendingResume = null;
+		if (this.state.pendingResume?.owner === abortController) {
+			const { messageId } = this.state.pendingResume;
+			this.dispatch({ type: "resumeCleared" });
 			if (!abortSignal.aborted) this.startResumeRun(messageId);
 		}
-		if (this.pendingA2uiResumeOwner === abortController) {
-			this.pendingA2uiResumeOwner = null;
-			if (!abortSignal.aborted && this.pendingA2uiAction !== void 0) {
+		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;
 				}
@@ -909,15 +1025,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 = {
@@ -958,8 +1073,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();
@@ -977,7 +1092,7 @@ var AgUiThreadRuntimeCore = class {
 		return {
 			threadId,
 			runId,
-			state: this.stateSnapshot ?? null,
+			state: this.state.stateSnapshot ?? null,
 			messages,
 			tools: toAgUiTools(context?.tools),
 			context: [...context?.system ? [{
@@ -1007,14 +1122,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) {
@@ -1031,7 +1143,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: [],
@@ -1074,21 +1186,11 @@ 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;
 	}
@@ -1097,8 +1199,9 @@ var AgUiThreadRuntimeCore = class {
 		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 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;
 			return {
 				...assistant,
@@ -1234,18 +1337,23 @@ var AgUiThreadRuntimeCore = class {
 			custom: incoming.custom ? mergeAgUiNamespace(current.custom, incoming.custom) : current.custom
 		};
 	}
-	handleEvent(aggregator, event, activeAssistantId) {
+	handleEvent(aggregator, event, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary) {
 		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);
@@ -1255,7 +1363,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);
+				this.importMessagesSnapshot(event.messages, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary);
 				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);
@@ -1296,7 +1404,7 @@ var AgUiThreadRuntimeCore = class {
 				...assistant,
 				metadata: {
 					...assistant.metadata,
-					unstable_state: this.stateSnapshot ?? null
+					unstable_state: this.state.stateSnapshot ?? null
 				}
 			};
 		});
@@ -1307,25 +1415,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 } } } : {},
@@ -1380,7 +1490,7 @@ var AgUiThreadRuntimeCore = class {
 		this.publishUpdate();
 		this.maybeCompleteAfterToolResults(messageId);
 	}
-	importMessagesSnapshot(rawMessages, activeAssistantId) {
+	importMessagesSnapshot(rawMessages, activeAssistantId, joinStrategy, runStartMessageIds, hasRunUserBoundary) {
 		try {
 			const activeAssistantItem = activeAssistantId ? this.session.tryGetMessage(activeAssistantId) : void 0;
 			const activeMessage = activeAssistantItem?.message;
@@ -1403,6 +1513,53 @@ var AgUiThreadRuntimeCore = class {
 					content: this.mergeSnapshotAssistantContent(existing.content, convertedMessage.content, snapshotHasReasoning, snapshotHasActivity)
 				};
 			}
+			if (joinStrategy === "concat-content") {
+				const activeIndex = converted.findIndex((message) => message.id === activeAssistantId);
+				const lastKnownIndex = converted.findLastIndex((message) => runStartMessageIds.has(message.id));
+				const lastUserIndex = hasRunUserBoundary ? converted.findLastIndex((message) => message.role === "user") : -1;
+				const startIndex = activeIndex >= 0 ? activeIndex : lastKnownIndex >= 0 || lastUserIndex >= 0 ? Math.max(lastKnownIndex, lastUserIndex) + 1 : -1;
+				if (startIndex >= 0 && converted[startIndex]?.role === "assistant") {
+					let endIndex = startIndex + 1;
+					while (converted[endIndex]?.role === "assistant") endIndex++;
+					const runMessages = converted.slice(startIndex, endIndex);
+					const includesStreamedPrefix = activeIndex < 0 && activeAssistant?.content.some((part) => part.type !== "data");
+					if (includesStreamedPrefix && activeAssistant) runMessages.unshift(activeAssistant);
+					if (runMessages.length > 1) {
+						const [first, ...rest] = runMessages;
+						let content = runMessages.flatMap((message) => message.content);
+						if (includesStreamedPrefix) {
+							content = [...first.content];
+							let cursor = 0;
+							const keyOf = (part) => part.type === "tool-call" ? `tool:${part.toolCallId}` : part.type === "text" || part.type === "reasoning" ? `${part.type}:${part.text}` : void 0;
+							for (const message of rest) for (const part of message.content) {
+								const key = keyOf(part);
+								const match = key === void 0 ? -1 : content.findIndex((previous, index) => index >= cursor && keyOf(previous) === key);
+								if (match < 0) {
+									content.push(part);
+									cursor = content.length;
+								} else {
+									if (part.type === "tool-call") content[match] = this.preserveToolResults([content[match]], [part])[0];
+									cursor = match + 1;
+								}
+							}
+						}
+						converted.splice(startIndex, endIndex - startIndex, {
+							...first,
+							content,
+							status: rest.at(-1).status,
+							metadata: rest.reduce((metadata, message) => ({
+								...metadata,
+								...message.metadata,
+								unstable_state: message.metadata.unstable_state,
+								unstable_annotations: [...metadata.unstable_annotations, ...message.metadata.unstable_annotations],
+								unstable_data: [...metadata.unstable_data, ...message.metadata.unstable_data],
+								steps: [...metadata.steps, ...message.metadata.steps],
+								custom: mergeAgUiNamespace(metadata.custom, message.metadata.custom)
+							}), first.metadata)
+						});
+					}
+				}
+			}
 			const snapshotContainsActiveAssistant = converted.some((message) => message.id === activeAssistant?.id);
 			const preservesActiveAssistant = activeAssistant !== void 0 && !snapshotContainsActiveAssistant && (activeAssistant.metadata.isOptimistic !== true || converted.at(-1)?.role !== "assistant" || activeAssistantParentId !== void 0 && converted.at(-1)?.id === activeAssistantParentId);
 			if (preservesActiveAssistant) converted.push(activeAssistant);
@@ -1448,7 +1605,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
 			}));
@@ -1456,7 +1613,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);
 			});
@@ -1470,17 +1627,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
 		}));
@@ -1489,25 +1646,8 @@ 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